From 516022d3802dc55f9ed7cd0dae56d1fd3bf8163c Mon Sep 17 00:00:00 2001 From: AbhinavKumarlvs02 Date: Sat, 28 Mar 2026 18:22:53 +0530 Subject: [PATCH] First commit --- .gitignore | 44 + App/app.py | 569 + App/graph_engine.py | 516 + App/test_engine.py | 34 + Readme.md | 120 +- Spectra-Backend/Dockerfile | 17 + Spectra-Backend/main.py | 170 + Spectra-Backend/requirements.txt | 5 + Spectra-Frontend/background.js | 45 + Spectra-Frontend/content.js | 124 + Spectra-Frontend/manifest.json | 19 + graphvision/README.md | 85 + graphvision/graphvision/__init__.py | 3 + graphvision/graphvision/extractor.py | 777 + graphvision/pyproject.toml | 29 + notebooks/Combine.ipynb | 3287 +++ notebooks/Dot_line.ipynb | 3656 +++ notebooks/FigureQA.ipynb | 1840 ++ notebooks/FigureQA_2.ipynb | 2883 ++ notebooks/STEM_Sight_Dot_Line.ipynb | 7433 +++++ notebooks/STEM_Sight_Horizontal.ipynb | 12395 +++++++++ notebooks/STEM_Sight_Line.ipynb | 23088 ++++++++++++++++ .../STEM_Sight_PlotQA_Preprocessing.ipynb | 661 + notebooks/STEM_Sight_VBar_Training.ipynb | 761 + notebooks/Test.ipynb | 5277 ++++ notebooks/Training.ipynb | 12927 +++++++++ 26 files changed, 76691 insertions(+), 74 deletions(-) create mode 100644 .gitignore create mode 100644 App/app.py create mode 100644 App/graph_engine.py create mode 100644 App/test_engine.py create mode 100644 Spectra-Backend/Dockerfile create mode 100644 Spectra-Backend/main.py create mode 100644 Spectra-Backend/requirements.txt create mode 100644 Spectra-Frontend/background.js create mode 100644 Spectra-Frontend/content.js create mode 100644 Spectra-Frontend/manifest.json create mode 100644 graphvision/README.md create mode 100644 graphvision/graphvision/__init__.py create mode 100644 graphvision/graphvision/extractor.py create mode 100644 graphvision/pyproject.toml create mode 100644 notebooks/Combine.ipynb create mode 100644 notebooks/Dot_line.ipynb create mode 100644 notebooks/FigureQA.ipynb create mode 100644 notebooks/FigureQA_2.ipynb create mode 100644 notebooks/STEM_Sight_Dot_Line.ipynb create mode 100644 notebooks/STEM_Sight_Horizontal.ipynb create mode 100644 notebooks/STEM_Sight_Line.ipynb create mode 100644 notebooks/STEM_Sight_PlotQA_Preprocessing.ipynb create mode 100644 notebooks/STEM_Sight_VBar_Training.ipynb create mode 100644 notebooks/Test.ipynb create mode 100644 notebooks/Training.ipynb diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7ebbc7e --- /dev/null +++ b/.gitignore @@ -0,0 +1,44 @@ +<<<<<<< HEAD +.DS_Store +.ipynb_checkpoints/ +__pycache__/ +ChartQA-Dataset/ +PlotQA-Dataset/ +dataset_hbar/ +models/ +*.zip +*.jsonl +======= +# Mac +.DS_Store + +# Jupyter +.ipynb_checkpoints/ + +# datasets +ChartQA_Dataset/ +FigureQA_Dataset/ +PlotQA_Dataset/ + +# local notebooks / experiments +notebooks/runs/ +notebooks/datasets/ +notebooks/classifier_data/ +notebooks/classifier_sample_data/ +notebooks/yolo_dataset/ + +# models +*.pth +*.pt + +# outputs +*.pdf +*.docx +*.xlsx + +# misc local files +Test/ +graphvision/dist/ +graphvision/weights/ +graphvision/graphvision_ai.egg-info/ +>>>>>>> 2ad13dd (ignore local datasets, checkpoints, and system files) diff --git a/App/app.py b/App/app.py new file mode 100644 index 0000000..ba54d68 --- /dev/null +++ b/App/app.py @@ -0,0 +1,569 @@ +# import os +# import json +# import time +# import speech_recognition as sr +# from gtts import gTTS +# import pygame +# from mss import mss +# from groq import Groq + +# # Import your local vision engine +# from graph_engine import GraphExtractor + +# # --- 1. Initialization --- +# print("Initializing Spectra Hybrid Cloud System...") + +# # Initialize Pygame for playing audio files safely +# pygame.mixer.init() + +# # Initialize STT +# recognizer = sr.Recognizer() +# microphone = sr.Microphone() + +# # Initialize Groq Client +# # Ensure you generate an API key from console.groq.com and paste it below +# GROQ_API_KEY = "" +# groq_client = Groq(api_key=GROQ_API_KEY) + +# # Initialize Local Vision Engine +# extractor = GraphExtractor() + +# # Global memory for the Agentic conversation +# chat_history = [] + +# # --- 2. Bilingual Audio & Cues --- + +# def speak(text, lang='hi'): +# """Generates speech using Google TTS and plays it.""" +# print(f"Spectra: {text}") +# try: +# # Generate audio file +# tts = gTTS(text=text, lang=lang) +# filename = f"temp_speech_{int(time.time())}.mp3" +# tts.save(filename) + +# # Play audio file +# pygame.mixer.music.load(filename) +# pygame.mixer.music.play() + +# # Wait for audio to finish playing +# while pygame.mixer.music.get_busy(): +# pygame.time.Clock().tick(10) + +# # Cleanup +# pygame.mixer.music.unload() +# os.remove(filename) +# except Exception as e: +# print(f"TTS Error: {e}") + +# def play_cue(type="start"): +# """Quick audio cues to let the user know the state.""" +# if type == "start": +# print("🔔 [BEEP: Listening/Processing]") +# elif type == "error": +# print("❌ [BEEP: Error]") + +# # --- 3. Agentic LLM Logic --- + +# def ask_spectra_agent(user_prompt, graph_json=None): +# """Sends the prompt and context to the Groq API (Llama 3).""" +# global chat_history + +# if graph_json: +# # Initialize a new context window for a new graph +# chat_history = [{ +# "role": "system", +# "content": ( +# "You are Spectra, an AI assistant for visually impaired users. " +# "You are friendly, concise, and conversational. " +# "You can understand and speak both Hindi and English. Match the language the user speaks. " +# f"Here is the raw data for the current graph on the user's screen: {graph_json}" +# ) +# }] + +# chat_history.append({"role": "user", "content": user_prompt}) + +# try: +# completion = groq_client.chat.completions.create( +# model="llama-3.3-70b-versatile", +# messages=chat_history, +# temperature=0.5, +# max_tokens=256, +# ) + +# reply = completion.choices[0].message.content +# chat_history.append({"role": "assistant", "content": reply}) +# return reply + +# except Exception as e: +# print(f"Groq API Error: {e}") +# return "Network connection issue. Main online nahi hoon." + +# # --- 4. Main Conversational Loop --- + +# def listen_for_command(): +# with microphone as source: +# print("\nListening...") +# recognizer.adjust_for_ambient_noise(source, duration=0.5) +# try: +# # phrase_time_limit prevents it from hanging if background noise is continuous +# audio = recognizer.listen(source, timeout=5, phrase_time_limit=8) + +# # Use 'hi-IN' which natively catches both Hindi and Indian English pronunciation perfectly +# text = recognizer.recognize_google(audio, language="hi-IN").lower() +# print(f"User heard: {text}") +# return text +# except (sr.WaitTimeoutError, sr.UnknownValueError): +# return "" +# except Exception as e: +# print(f"Microphone Error: {e}") +# return "" + +# def start_system(): +# play_cue("start") +# speak("Spectra online. Mujhe 'read screen' ya 'screen dekho' bolein.", lang='hi') + +# in_conversation = False + +# while True: +# command = listen_for_command() +# if not command: +# continue + +# # 1. Trigger the Vision Pipeline +# if any(trigger in command for trigger in ["read screen", "screen dekho", "graph dekho", "analyze", "स्क्रीन देखो", "ग्राफ देखो", "रीड स्क्रीन"]): +# play_cue("start") +# speak("Screen check kar rahi hoon. Ek second dijiye.", lang='hi') + +# # Capture the screen locally +# with mss() as sct: +# filename = sct.shot(mon=1, output='temp_screen.png') + +# # Run Local Vision Engine +# print("Extracting Graph Data Locally...") +# raw_json = extractor.extract(filename) + +# # Send to Groq for summary +# print("Consulting Agentic Brain...") +# prompt = "Summarize the key points of this graph briefly. If I spoke in Hindi, answer in Hindi." +# explanation = ask_spectra_agent(prompt, graph_json=raw_json) + +# # Speak the result +# speak(explanation, lang='hi') +# speak("Kya aapko is graph ke baare mein kuch aur poochhna hai?", lang='hi') + +# in_conversation = True +# if os.path.exists(filename): +# os.remove(filename) + +# # 2. Agentic Q&A Loop +# elif in_conversation: +# if any(stop_word in command for stop_word in ["stop", "cancel", "chup", "band karo", "thank you", "चुप", "बंद करो", "रुक जाओ"]): +# speak("Theek hai. Main background mein hoon.", lang='hi') +# in_conversation = False +# chat_history = [] # Wipe memory +# else: +# play_cue("start") +# answer = ask_spectra_agent(command) +# speak(answer, lang='hi') + +# if __name__ == "__main__": +# start_system() + + + + + + + + + + + + + + + + + + + + + + +# import os +# import json +# import time +# import speech_recognition as sr +# from gtts import gTTS +# import pygame +# from mss import mss +# from groq import Groq +# import tkinter as tk +# from tkinter import scrolledtext, messagebox +# import threading +# import os +# import sys + +# # Import your Hugging Face Vision Engine +# from graph_engine import GraphExtractor + +# # --- 1. Initialization --- +# print("Initializing Spectra Hybrid Cloud System...") + +# # Initialize Pygame for playing audio files safely +# pygame.mixer.init() + +# # Initialize STT +# recognizer = sr.Recognizer() +# microphone = sr.Microphone() + +# # Initialize Groq Client +# # INSERT YOUR GROQ API KEY HERE +# GROQ_API_KEY = "" +# try: +# groq_client = Groq(api_key=GROQ_API_KEY) +# except Exception as e: +# print(f"Error initializing Groq: {e}. Please check your API key.") + +# # Initialize Vision Engine (This will download weights from Hugging Face on the first run) +# extractor = GraphExtractor() + +# # Global memory for the Agentic conversation +# chat_history = [] + +# # --- 2. Bilingual Audio & Cues --- + +# def speak(text, lang='hi'): +# """Generates speech using Google TTS and plays it.""" +# print(f"\nSpectra: {text}") +# try: +# # Generate audio file +# tts = gTTS(text=text, lang=lang) +# filename = f"temp_speech_{int(time.time())}.mp3" +# tts.save(filename) + +# # Play audio file +# pygame.mixer.music.load(filename) +# pygame.mixer.music.play() + +# # Wait for audio to finish playing +# while pygame.mixer.music.get_busy(): +# pygame.time.Clock().tick(10) + +# # Cleanup +# pygame.mixer.music.unload() +# os.remove(filename) +# except Exception as e: +# print(f"TTS Error: {e}") + +# def play_cue(type="start"): +# """Quick audio cues to let the user know the state.""" +# if type == "start": +# print("🔔 [BEEP: Listening/Processing]") +# elif type == "error": +# print("❌ [BEEP: Error]") + +# # --- 3. Agentic LLM Logic --- + +# def ask_spectra_agent(user_prompt, graph_json=None): +# """Sends the prompt and context to the Groq API (Llama 3.3).""" +# global chat_history + +# if graph_json: +# # Initialize a new context window for a new graph +# chat_history = [{ +# "role": "system", +# "content": ( +# "You are Spectra, an AI assistant for visually impaired users. " +# "You are friendly, concise, and conversational. " +# "You can understand and speak both Hindi and English. Match the language the user speaks. " +# "Do not read the raw JSON to the user. Explain the insights naturally. " +# f"Here is the data for the current graph on the user's screen: {graph_json}" +# ) +# }] + +# chat_history.append({"role": "user", "content": user_prompt}) + +# try: +# # Using the latest supported Groq model +# completion = groq_client.chat.completions.create( +# model="llama-3.3-70b-versatile", +# messages=chat_history, +# temperature=0.5, +# max_tokens=300, +# ) + +# reply = completion.choices[0].message.content +# chat_history.append({"role": "assistant", "content": reply}) +# return reply + +# except Exception as e: +# print(f"Groq API Error: {e}") +# return "Mujhe network se connect karne mein problem ho rahi hai. Kripya apna internet check karein." + +# # --- 4. Main Conversational Loop --- + +# def listen_for_command(): +# with microphone as source: +# print("\nListening...") +# # Quick calibration for background noise +# recognizer.adjust_for_ambient_noise(source, duration=0.5) +# try: +# audio = recognizer.listen(source, timeout=5, phrase_time_limit=8) +# # hi-IN captures both spoken Hindi, English, and Hinglish +# text = recognizer.recognize_google(audio, language="hi-IN").lower() +# print(f"User heard: {text}") +# return text +# except (sr.WaitTimeoutError, sr.UnknownValueError): +# return "" +# except Exception as e: +# print(f"Microphone Error: {e}") +# return "" + +# def start_system(): +# play_cue("start") +# speak("Spectra online. Mujhe 'read screen' ya 'screen dekho' bolein.", lang='hi') + +# in_conversation = False + +# while True: +# command = listen_for_command() +# if not command: +# continue + +# # 1. Trigger the Vision Pipeline +# # Now natively handles both English and actual Devanagari text +# triggers = ["read screen", "screen dekho", "graph dekho", "analyze", "स्क्रीन देखो", "ग्राफ देखो", "रीड स्क्रीन"] + +# if any(trigger in command for trigger in triggers): +# play_cue("start") +# speak("Screen check kar rahi hoon. Ek second dijiye.", lang='hi') + +# # Capture the screen locally +# with mss() as sct: +# filename = sct.shot(mon=1, output='temp_screen.png') + +# # # TEMPORARY TEST OVERRIDE: +# # filename = "sample1.png" + +# # Run Vision Engine (Downloads from HF if first time, otherwise uses cache) +# print("\nExtracting Graph Data...") +# raw_json = extractor.extract(filename) + +# # Send to Groq for summary +# print("Consulting Agentic Brain...") +# prompt = "Please summarize the key takeaways of this graph. If I spoke in Hindi, answer in Hindi." +# explanation = ask_spectra_agent(prompt, graph_json=raw_json) + +# # Speak the result +# speak(explanation, lang='hi') +# speak("Kya aapko is graph ke baare mein kuch aur poochhna hai?", lang='hi') + +# in_conversation = True +# if os.path.exists(filename): +# os.remove(filename) + +# # 2. Agentic Q&A Loop +# elif in_conversation: +# stop_words = ["stop", "cancel", "chup", "band karo", "thank you", "चुप", "बंद करो", "रुक जाओ"] +# if any(stop_word in command for stop_word in stop_words): +# speak("Theek hai. Main background mein dhyan rakh rahi hoon.", lang='hi') +# in_conversation = False +# chat_history = [] # Wipe memory for privacy +# else: +# play_cue("start") +# answer = ask_spectra_agent(command) +# speak(answer, lang='hi') + +# #[Section 3: The New Chat UI Class] +# class SpectraChatUI: + +# def update_chat(self, sender, message): +# self.chat_area.config(state=tk.NORMAL) +# color = "#55ff55" if sender == "You" else "#55ccff" +# self.chat_area.insert(tk.END, f"{sender}: ", tag:=sender) +# self.chat_area.tag_config(tag, foreground=color, font=("Arial", 10, "bold")) +# self.chat_area.insert(tk.END, f"{message}\n\n") +# self.chat_area.config(state=tk.DISABLED) +# self.chat_area.yview(tk.END) + +# def start_thread(self): +# if not self.is_running: +# self.is_running = True +# self.update_chat("System", "Spectra Online. Say 'Screen Dekho'.") +# # This launches the voice loop without freezing the window +# threading.Thread(target=self.run_spectra, daemon=True).start() + +# def run_spectra(self): +# # This links the UI to your voice functions +# global speak +# original_speak = speak +# def ui_speak(text, lang='hi'): +# self.root.after(0, self.update_chat, "Spectra", text) +# original_speak(text, lang) +# speak = ui_speak + +# # Start your main conversational loop +# start_system() + +# # [Section 4: The Main Execution] +# if __name__ == "__main__": +# root = tk.Tk() +# gui = SpectraChatUI(root) +# root.mainloop() + + +import os +import time +import speech_recognition as sr +from gtts import gTTS +import pygame +from mss import mss +from groq import Groq +import tkinter as tk +from tkinter import scrolledtext +import threading +import sys + +# Import your Vision Engine +from graph_engine import GraphExtractor + +# --- GLOBAL SETUP --- +pygame.mixer.init() +recognizer = sr.Recognizer() +microphone = sr.Microphone() +GROQ_API_KEY = "" +groq_client = Groq(api_key=GROQ_API_KEY) +extractor = GraphExtractor() +chat_history = [] + +def original_speak(text, lang='hi'): + try: + tts = gTTS(text=text, lang=lang) + filename = f"temp_{int(time.time())}.mp3" + tts.save(filename) + pygame.mixer.music.load(filename) + pygame.mixer.music.play() + while pygame.mixer.music.get_busy(): pygame.time.Clock().tick(10) + pygame.mixer.music.unload() + os.remove(filename) + except Exception as e: print(f"Audio Error: {e}") + +speak = original_speak + +def ask_spectra_agent(user_prompt, graph_json=None): + global chat_history + if graph_json: + chat_history = [{"role": "system", "content": f"You are Spectra. Data: {graph_json}"}] + chat_history.append({"role": "user", "content": user_prompt}) + completion = groq_client.chat.completions.create( + model="llama-3.3-70b-versatile", messages=chat_history, temperature=0.5 + ) + reply = completion.choices[0].message.content + chat_history.append({"role": "assistant", "content": reply}) + return reply + +# --- THE UI CLASS --- +class SpectraChatUI: + def __init__(self, root_window): + self.root = root_window + self.root.title("Spectra Agentic AI") + self.root.geometry("400x650") + self.root.configure(bg="#1e1e1e") + self.is_running = False + + # Status Indicator (The "Listening" Dialog) + self.status_frame = tk.Frame(self.root, bg="#1e1e1e") + self.status_frame.pack(fill=tk.X, pady=5) + self.status_light = tk.Label(self.status_frame, text="●", fg="#444444", bg="#1e1e1e", font=("Arial", 14)) + self.status_light.pack(side=tk.LEFT, padx=(10, 0)) + self.status_text = tk.Label(self.status_frame, text="OFFLINE", fg="white", bg="#1e1e1e", font=("Arial", 10)) + self.status_text.pack(side=tk.LEFT, padx=5) + + # Chat Area + self.chat_area = scrolledtext.ScrolledText(self.root, bg="#2d2d2d", fg="white", font=("Segoe UI", 10)) + self.chat_area.pack(padx=10, pady=10, fill=tk.BOTH, expand=True) + + # Buttons + btn_frame = tk.Frame(self.root, bg="#1e1e1e") + btn_frame.pack(pady=10) + tk.Button(btn_frame, text="START ENGINE", command=self.start_thread, bg="#0078d7", fg="white").pack(side=tk.LEFT, padx=5) + tk.Button(btn_frame, text="EXIT", command=lambda: os._exit(0), bg="#444444", fg="white").pack(side=tk.LEFT, padx=5) + + def set_status(self, state): + """Updates the visual 'Listening' light.""" + if state == "listening": + self.status_light.config(fg="#ff5555") # Red for recording + self.status_text.config(text="LISTENING...") + elif state == "processing": + self.status_light.config(fg="#55ff55") # Green for AI thinking + self.status_text.config(text="PROCESSING...") + else: + self.status_light.config(fg="#444444") + self.status_text.config(text="IDLE") + + def update_chat(self, sender, message): + self.chat_area.config(state=tk.NORMAL) + color = "#55ff55" if sender == "You" else "#55ccff" + self.chat_area.insert(tk.END, f"{sender}: ", sender) + self.chat_area.tag_config(sender, foreground=color, font=("Arial", 10, "bold")) + self.chat_area.insert(tk.END, f"{message}\n\n") + self.chat_area.config(state=tk.DISABLED) + self.chat_area.yview(tk.END) + + def start_thread(self): + if not self.is_running: + self.is_running = True + threading.Thread(target=self.run_logic, daemon=True).start() + + def run_logic(self): + global speak + def ui_speak(text, lang='hi'): + self.root.after(0, self.set_status, "idle") + self.root.after(0, self.update_chat, "Spectra", text) + original_speak(text, lang) + speak = ui_speak + + speak("Spectra online. Screen dekho bolein.", lang='hi') + in_conversation = False + + while True: + self.root.after(0, self.set_status, "listening") + with microphone as source: + recognizer.adjust_for_ambient_noise(source, duration=0.5) + try: + audio = recognizer.listen(source, timeout=None, phrase_time_limit=5) + command = recognizer.recognize_google(audio, language="hi-IN").lower() + self.root.after(0, self.update_chat, "You", command) + except: continue + + # --- STOP COMMANDS --- + stop_triggers = ["stop", "cancel", "chup", "band karo", "चुप", "बंद करो"] + if any(s in command for s in stop_triggers): + speak("Theek hai, main chup ho rahi hoon.", lang='hi') + in_conversation = False + continue + + # --- ANALYZE COMMANDS --- + if any(t in command for t in ["read screen", "screen dekho", "graph dekho", "analyze", "स्क्रीन देखो", "ग्राफ देखो", "रीड स्क्रीन"]): + self.root.after(0, self.set_status, "processing") + speak("Scanning...", lang='hi') + with mss() as sct: + fname = sct.shot(mon=1, output='temp_screen.png') + raw_json = extractor.extract(fname) + explanation = ask_spectra_agent("Summarize.", graph_json=raw_json) + speak(explanation, lang='hi') + in_conversation = True + + # --- CONVERSATION --- + elif in_conversation and len(command) > 2: + self.root.after(0, self.set_status, "processing") + answer = ask_spectra_agent(command) + speak(answer, lang='hi') + +# --- ENTRY POINT --- +if __name__ == "__main__": + main_window = tk.Tk() + app_instance = SpectraChatUI(main_window) + main_window.mainloop() \ No newline at end of file diff --git a/App/graph_engine.py b/App/graph_engine.py new file mode 100644 index 0000000..98dc4a1 --- /dev/null +++ b/App/graph_engine.py @@ -0,0 +1,516 @@ +import os +import re +import cv2 +import json +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from PIL import Image +from torchvision import models +import torchvision.transforms as transforms +from ultralytics import YOLO +import easyocr +import warnings + +import sys + +def resource_path(relative_path): + """ Get absolute path to resource, works for dev and for PyInstaller """ + try: + # PyInstaller creates a temp folder and stores path in _MEIPASS + base_path = sys._MEIPASS + except Exception: + base_path = os.path.abspath(".") + + return os.path.join(base_path, relative_path) + +# Suppress annoying warnings to keep the terminal clean +warnings.filterwarnings("ignore") + +# --- PIE CHART MODEL ARCHITECTURE --- +class PieRegressor(nn.Module): + def __init__(self): + super(PieRegressor, self).__init__() + self.backbone = models.resnet18() + num_ftrs = self.backbone.fc.in_features + self.backbone.fc = nn.Linear(num_ftrs, 10) + self.sigmoid = nn.Sigmoid() + + def forward(self, x): + x = self.backbone(x) + return self.sigmoid(x) + +# --- MAIN EXTRACTION ENGINE --- +class GraphExtractor: + def __init__(self): + self.device = torch.device("mps" if torch.backends.mps.is_available() else "cuda" if torch.cuda.is_available() else "cpu") + + print("🧠 Booting up Local GraphVision AI Models...") + + # Update these lines in your __init__ + classifier_path = resource_path("graph_classifier_real.pth") + pie_model_path = resource_path("pie_regressor_stable.pth") + yolo_path = resource_path("best2.pt") + dot_yolo_path = resource_path("best1.pt") + + # Ensure files exist before trying to load them + for path in [classifier_path, pie_model_path, yolo_path, dot_yolo_path]: + if not os.path.exists(path): + raise FileNotFoundError(f"Missing model file: {path}. Please place it in the script directory.") + + # 2. Setup Chart Classifier + self.CLASS_NAMES = ['dot_line', 'hbar_categorical', 'line', 'pie', 'vbar_categorical'] + self.classifier = models.resnet18() + self.classifier.fc = nn.Linear(self.classifier.fc.in_features, 5) + self.classifier.load_state_dict(torch.load(classifier_path, map_location=self.device)) + self.classifier.to(self.device) + self.classifier.eval() + + self.transform = transforms.Compose([ + transforms.Resize((224, 224)), + transforms.ToTensor(), + transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + ]) + + # 3. Setup YOLO Bar Detector + self.yolo_model = YOLO(yolo_path) + + # 4. Setup YOLO Dot line Detector + self.dot_yolo_model = YOLO(dot_yolo_path) + + # 5. Setup Pie Regressor + self.pie_model = PieRegressor() + self.pie_model.load_state_dict(torch.load(pie_model_path, map_location=self.device)) + self.pie_model.to(self.device) + self.pie_model.eval() + + # 6. Setup OCR Text Reader + self.ocr_reader = easyocr.Reader(['en'], gpu=torch.cuda.is_available() or torch.backends.mps.is_available()) + + def _extract_number(self, text_str): + matches = re.findall(r'-?\d+\.?\d*', text_str.replace(',', '')) + if matches: + return float(matches[0]) + + text_clean = text_str.strip().upper() + if text_clean == 'O': return 0.0 + if text_clean == 'S': return 5.0 + if text_clean in ['I', 'L']: return 1.0 + return None + + @staticmethod + def _color_distance(c1, c2): + """Calculate Euclidean distance between two BGR colors.""" + return np.linalg.norm(np.array(c1, dtype=np.float32) - np.array(c2, dtype=np.float32)) + + @staticmethod + def _get_robust_scale(axis_nums, axis_key='y'): + """Robust scaling that ignores OCR typos.""" + if len(axis_nums) < 2: + return 1.0, 0.0 + + coords = np.array([n[axis_key] for n in axis_nums]) + vals = np.array([n['val'] for n in axis_nums]) + + median_val = np.median(vals) + if median_val > 0: + for i in range(len(vals)): + if vals[i] > median_val * 5: + vals[i] /= 10.0 + + slopes = [] + for i in range(len(coords)): + for j in range(i+1, len(coords)): + if abs(coords[i] - coords[j]) > 10: + slope = (vals[i] - vals[j]) / (coords[i] - coords[j]) + slopes.append(slope) + + if not slopes: + return 1.0, 0.0 + + best_m = np.median(slopes) + intercepts = vals - best_m * coords + best_c = np.median(intercepts) + + return best_m, best_c + + def extract(self, image_path): + """ + Main entry point. Classifies the image and routes it to the correct extraction logic. + """ + if not os.path.exists(image_path): + return json.dumps({"error": f"Image not found at {image_path}"}) + + print(f"\n🚀 Analyzing: {image_path}") + print("-" * 40) + + # --- Classify Chart Type --- + img_pil = Image.open(image_path).convert('RGB') + img_tensor = self.transform(img_pil).unsqueeze(0).to(self.device) + + with torch.no_grad(): + outputs = self.classifier(img_tensor) + _, predicted = torch.max(outputs, 1) + chart_type = self.CLASS_NAMES[predicted.item()] + + print(f"📊 Detected Chart Type: {chart_type.upper()}") + + # --- Route to specific extractors --- + if 'bar' in chart_type: + return self._extract_bar_chart(image_path, chart_type) + elif 'pie' in chart_type: + return self._extract_pie_chart(image_path) + elif chart_type == 'dot_line': + return self._extract_dot_line_chart(image_path) + else: + return json.dumps({ + "chart_type": chart_type, + "error": f"Extraction for {chart_type} is currently under development." + }, indent=4) + + def _extract_dot_line_chart(self, image_path): + results = self.dot_yolo_model(image_path, conf=0.5, iou=0.4, imgsz=1024, verbose=False) + boxes = results[0].boxes.xyxy.cpu().numpy() + + if len(boxes) == 0: + return json.dumps({"chart_type": "dot_line", "error": "No dots detected."}) + + img_cv = cv2.imread(image_path) + h, w = img_cv.shape[:2] + + scale = 2.0 if w < 800 else 1.0 + + if scale == 2.0: + img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC) + else: + img_upscaled = img_cv.copy() + + ocr_results = self.ocr_reader.readtext(img_upscaled) + + numbers = [] + text_labels = [] + raw_legend_candidates = [] + + for (bbox, text, prob) in ocr_results: + orig_tl_x, orig_tl_y = bbox[0][0] / scale, bbox[0][1] / scale + orig_br_x, orig_br_y = bbox[2][0] / scale, bbox[2][1] / scale + + cx = (orig_tl_x + orig_br_x) / 2.0 + cy = (orig_tl_y + orig_br_y) / 2.0 + + val = self._extract_number(text) + if val is not None: + numbers.append({'val': val, 'x': cx, 'y': cy}) + else: + text_labels.append({'text': text, 'x': cx, 'y': cy}) + raw_legend_candidates.append({ + 'text': text, + 'x': cx, + 'tl_x': orig_tl_x, + 'cy': cy, + 'height': orig_br_y - orig_tl_y + }) + + leftmost_dot = boxes[:, 0].min() + bottommost_dot = boxes[:, 3].max() + + y_axis_nums = [n for n in numbers if n['x'] < leftmost_dot] + y_m, y_c = self._get_robust_scale(y_axis_nums, axis_key='y') + + x_axis_nums = [n for n in numbers if n['y'] > bottommost_dot] + x_m, x_c = self._get_robust_scale(x_axis_nums, axis_key='x') + + legend_colors = {} + legend_texts = set() + ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'x_axis', 'y_axis'] + + for item in raw_legend_candidates: + clean_text = item['text'].strip() + if clean_text.lower() in ignore_words: + continue + + sample_x = int(item['tl_x'] - item['height'] * 0.8) + sample_y = int(item['cy']) + + if sample_x > 0 and sample_y > 0 and sample_x < img_cv.shape[1] and sample_y < img_cv.shape[0]: + bgr_color = img_cv[sample_y, sample_x] + b, g, r = int(bgr_color[0]), int(bgr_color[1]), int(bgr_color[2]) + + is_not_white = (b + g + r) < 700 + is_not_black = (b + g + r) > 50 + is_colorful = max(b, g, r) - min(b, g, r) > 20 + + if is_not_white and is_not_black and is_colorful: + legend_colors[clean_text] = bgr_color + legend_texts.add(item['text']) + + extracted_points = [] + + for box in boxes: + cx = int((box[0] + box[2]) / 2) + cy = int((box[1] + box[3]) / 2) + + real_x = (x_m * cx) + x_c + real_y = (y_m * cy) + y_c + + dot_color = img_cv[cy, cx] + best_class = "Unknown" + + if legend_colors: + best_class = min(legend_colors.keys(), key=lambda k: self._color_distance(dot_color, legend_colors[k])) + + extracted_points.append({ + "class": best_class, + "x": float(round(real_x, 2)), + "y": float(round(real_y, 2)) + }) + + extracted_points.sort(key=lambda p: p['x']) + + title, x_axis_label, y_axis_label = None, None, None + + if text_labels: + top_most = min(text_labels, key=lambda l: l['y']) + if top_most['y'] < boxes[:, 1].min(): + title = top_most['text'] + + remaining = [l for l in text_labels if l != top_most and l['text'] not in legend_texts] + + if remaining: + bottom_most = max(remaining, key=lambda l: l['y']) + x_axis_label = bottom_most['text'] + left_most = min(remaining, key=lambda l: l['x']) + y_axis_label = left_most['text'] + + output = { + "chart_type": "dot_line", + "title": title, + "x_axis_label": x_axis_label, + "y_axis_label": y_axis_label, + "total_points": len(extracted_points), + "data": extracted_points + } + + return json.dumps(output, indent=4) + + def _extract_bar_chart(self, image_path, chart_type): + results = self.yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False) + boxes = results[0].boxes.xyxy.cpu().numpy() + + if len(boxes) == 0: + return json.dumps({"chart_type": chart_type, "error": "No bars detected."}) + + img_cv = cv2.imread(image_path) + h, w = img_cv.shape[:2] + + scale = 2.0 if w < 800 else 1.0 + + if scale == 2.0: + img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC) + else: + img_upscaled = img_cv.copy() + + img_for_ocr = img_upscaled.copy() + + for box in boxes: + scale = 2 if w < 800 else 1 + x1, y1, x2, y2 = [int(coord * scale) for coord in box] + cv2.rectangle(img_for_ocr, (x1, y1), (x2, y2), (255, 255, 255), -1) + + ocr_results = self.ocr_reader.readtext(img_for_ocr) + numbers = [] + text_labels = [] + + def add_or_update_label(new_text, new_cx, new_cy, is_rotated=False): + if len(new_text.strip()) == 1 and not new_text.isalnum(): + return + existing = next((l for l in text_labels if abs(l['x'] - new_cx) < 30 and abs(l['y'] - new_cy) < 30), None) + if existing: + if len(new_text) > len(existing['text']): + existing['text'] = new_text + existing['is_rotated'] = is_rotated + else: + text_labels.append({'text': new_text, 'x': new_cx, 'y': new_cy, 'is_rotated': is_rotated}) + + # Horizontal Pass + for (bbox, text, prob) in ocr_results: + cx = ((bbox[0][0] + bbox[1][0]) / 2) / scale + cy = ((bbox[0][1] + bbox[2][1]) / 2) / scale + val = self._extract_number(text) + if val is not None: + numbers.append({'val': val, 'x': cx, 'y': cy}) + else: + add_or_update_label(text, cx, cy, is_rotated=False) + + h_up, w_up = img_upscaled.shape[:2] + + img_rot_ccw = cv2.rotate(img_upscaled, cv2.ROTATE_90_COUNTERCLOCKWISE) + for (bbox, text, prob) in self.ocr_reader.readtext(img_rot_ccw): + cx_rot = ((bbox[0][0] + bbox[1][0]) / 2) + cy_rot = ((bbox[0][1] + bbox[2][1]) / 2) + cx = (w_up - cy_rot) / scale + cy = cx_rot / scale + if self._extract_number(text) is None: + add_or_update_label(text, cx, cy, is_rotated=True) + + img_rot_cw = cv2.rotate(img_upscaled, cv2.ROTATE_90_CLOCKWISE) + for (bbox, text, prob) in self.ocr_reader.readtext(img_rot_cw): + cx_rot = ((bbox[0][0] + bbox[1][0]) / 2) + cy_rot = ((bbox[0][1] + bbox[2][1]) / 2) + cx = cy_rot / scale + cy = (h_up - cx_rot) / scale + if self._extract_number(text) is None: + add_or_update_label(text, cx, cy, is_rotated=True) + + final_data = [] + ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'y_axis', 'x_axis'] + + if 'hbar' in chart_type.lower(): + lowest_bar_bottom = boxes[:, 3].max() + axis_nums = sorted([n for n in numbers if n['y'] > lowest_bar_bottom - 20], key=lambda d: d['x']) + + if len(axis_nums) >= 2: + units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x']) + zero_x_pixel = axis_nums[0]['x'] - (axis_nums[0]['val'] / units_per_pixel) + else: + units_per_pixel = 1.0 + zero_x_pixel = boxes[:, 0].min() + + img_w = img_cv.shape[1] + max_label_distance = img_w * 0.4 + + sorted_boxes = sorted(boxes, key=lambda b: b[1]) + for box in sorted_boxes: + x1, y1, x2, y2 = box + bar_cy = (y1 + y2) / 2 + if (x2 - x1) < 10 or (y2 - y1) < 5: continue + + aligned_labels = [ + l for l in text_labels + if l['x'] < x1 + and (x1 - l['x']) < max_label_distance + and abs(l['y'] - bar_cy) < 15 + and not l.get('is_rotated', False) + and l['text'].lower().replace('_', ' ') not in ignore_words + ] + + if aligned_labels: + aligned_labels.sort(key=lambda l: l['x']) + label_text = " ".join([l['text'] for l in aligned_labels]) + else: + label_text = "Unknown Category" + + real_val = (x2 - zero_x_pixel) * units_per_pixel + final_data.append((label_text, round(real_val, 2))) + + elif 'vbar' in chart_type.lower(): + leftmost_bar_edge = boxes[:, 0].min() + axis_nums = sorted([n for n in numbers if n['x'] < leftmost_bar_edge + 20], key=lambda d: d['y'], reverse=True) + + if len(axis_nums) >= 2: + units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y'])) + zero_y_pixel = axis_nums[0]['y'] + (axis_nums[0]['val'] / units_per_pixel) + else: + units_per_pixel = 1.0 + zero_y_pixel = boxes[:, 3].max() + + sorted_boxes = sorted(boxes, key=lambda b: b[0]) + for box in sorted_boxes: + x1, y1, x2, y2 = box + bar_cx = (x1 + x2) / 2 + if (x2 - x1) < 5 or (y2 - y1) < 10: continue + + possible_labels = [ + l for l in text_labels + if l['y'] > y2 and (l['y'] - y2) < 150 and l['text'].lower().replace('_', ' ') not in ignore_words + ] + + if possible_labels: + best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx)) + label_text = best_label['text'] + else: + label_text = "Unknown Category" + + real_val = (zero_y_pixel - y1) * units_per_pixel + final_data.append((label_text, round(real_val, 2))) + + title, x_axis_label, y_axis_label = None, None, None + + if text_labels: + category_texts = [item[0] for item in final_data] + + top_most = min(text_labels, key=lambda l: l['y']) + if top_most['text'] not in category_texts and top_most['y'] < boxes[:, 1].min(): + title = top_most['text'] + + bottom_most = max(text_labels, key=lambda l: l['y']) + if bottom_most['text'] not in category_texts and bottom_most['text'] != title and bottom_most['text'].lower() != 'title': + x_axis_label = bottom_most['text'] + + left_most = min(text_labels, key=lambda l: l['x']) + if left_most['text'] not in category_texts and left_most['text'] != title and left_most['text'].lower() != 'title': + y_axis_label = left_most['text'] + + output_dict = { + "chart_type": chart_type, + "title": title, + "x_axis_label": x_axis_label, + "y_axis_label": y_axis_label, + "data": [{"category": label, "value": value} for label, value in final_data] + } + return json.dumps(output_dict, indent=4) + + def _extract_pie_chart(self, image_path): + img_pil = Image.open(image_path).convert('RGB') + input_tensor = self.transform(img_pil).unsqueeze(0).to(self.device) + + with torch.no_grad(): + preds = self.pie_model(input_tensor).squeeze().cpu().numpy() * 100.0 + + cv_img = cv2.imread(image_path) + h, w, _ = cv_img.shape + gray = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY) + + all_text_results = self.ocr_reader.readtext(gray, mag_ratio=2.5) + + title = "Untitled" + raw_legend_names = [] + + for bbox, text, conf in all_text_results: + clean_text = text.strip() + if not clean_text: continue + + y_center = (bbox[0][1] + bbox[2][1]) / 2 + y_pct = y_center / h + + if y_pct < 0.15: + title = clean_text + elif y_pct > 0.15: + if len(clean_text) > 2 and not clean_text.replace('.', '', 1).isdigit(): + if clean_text.lower() == "grav": clean_text = "Gray" + raw_legend_names.append((y_pct, clean_text)) + + legend_names = [item[1] for item in sorted(raw_legend_names, key=lambda i: i[0])] + + num_slices = len(legend_names) + if num_slices == 0: + valid_preds = [v for v in preds if v > 1.5] + num_slices = len(valid_preds) + + num_slices = min(num_slices, 10) + slice_preds = preds[:num_slices] + + total_pred = sum(slice_preds) + if total_pred > 0: + normalized_preds = [(v / total_pred) * 100.0 for v in slice_preds] + else: + normalized_preds = slice_preds + + final_slices = {} + for i in range(num_slices): + slice_name = legend_names[i] if i < len(legend_names) else f"Unknown_Slice_{i+1}" + slice_value = round(float(normalized_preds[i]), 2) if i < len(normalized_preds) else 0.0 + final_slices[slice_name] = slice_value + + return json.dumps({"chart_type": "pie", "title": title, "data": final_slices}, indent=4) \ No newline at end of file diff --git a/App/test_engine.py b/App/test_engine.py new file mode 100644 index 0000000..2ea2220 --- /dev/null +++ b/App/test_engine.py @@ -0,0 +1,34 @@ +from graph_engine import GraphExtractor + +def test_pipeline(): + print("--- Spectra Engine Diagnostics ---") + + # 1. Initialize the AI (this will trigger the HF download if it hasn't already) + extractor = GraphExtractor() + + # 2. Define your test image + # IMPORTANT: Place a picture of a graph in your folder and rename it to 'sample.png' + # Or change this variable to match your image's actual name! + image_to_test = "Sample2.png" + + print(f"\nFeeding '{image_to_test}' into the vision engine...") + + # 3. Extract the data + try: + raw_json = extractor.extract(image_to_test) + + print("\n" + "="*40) + print("🧠 RAW JSON OUTPUT:") + print("="*40) + + # It's already formatted as a nice JSON string from your engine + print(raw_json) + + print("="*40) + + except Exception as e: + print(f"\n❌ Error during extraction: {e}") + print("Did you make sure the image file exists in the folder?") + +if __name__ == "__main__": + test_pipeline() \ No newline at end of file diff --git a/Readme.md b/Readme.md index d1ee2c3..55577b0 100644 --- a/Readme.md +++ b/Readme.md @@ -1,101 +1,73 @@ -# Stellaris Hackathon +# Spectra: AI-Powered Multi-Expert Chart Analysis -> **Organized by:** ElixirTech Community -> **Repository:** [ElixirTechCommunity/Stellaris-Hackathon](https://github.com/ElixirTechCommunity/Stellaris-Hackathon) +Spectra is an advanced educational tool designed to assist visually impaired students by converting complex data visualizations into descriptive audio and text summaries. The core engine, **STEM Sight**, utilizes a multi-expert architecture where specialized transformer models (Donut) are trained to interpret specific chart geometries (Vertical Bars, Line Charts, etc.). +## Project Overview +Most general-purpose Vision-Language Models (VLMs) struggle with the precision required for scientific charts. Spectra solves this by using **Transfer Learning**: +1. **Base Model**: Naver Donut (Vision Encoder-Decoder). +2. **Specialization**: Independent training phases for different chart types (VBAR and Line). +3. **Optimized Inference**: Implementation of beam search and repetition penalties to ensure accurate, non-hallucinated summaries. -## How to Submit Your Project +# STEM Sight: Model Training & Dataset Summary -Follow these steps **carefully** to upload your project to this repository. +**STEM Sight** uses a **Multi-Expert Vision-Encoder-Decoder (Donut)** architecture to convert complex charts and graphs into accessible summaries. +By training specialized **"experts" for different plot types**, the system achieves higher accuracy in **spatial reasoning and data extraction**. --- -### Step 1 – Fork This Repository +# 📈 Training Results -Click the **Fork** button at the top-right of this page to create your own copy of this repo. +All models were trained starting from the **VBAR Master weights** to utilize the **Stability Reset strategy**, ensuring a strong baseline for bar-based geometry. ---- - -### Step 2 – Clone Your Fork Locally -```bash -git clone https://github.com//Stellaris-Hackathon.git -cd Stellaris-Hackathon -``` +| Plot Type | Base Dataset | Epochs | Final Training Loss | Final Validation Loss | Status | +|-----------|-------------|--------|---------------------|-----------------------|--------| +| Vertical Bar (VBAR) | PlotQA / ChartQA | 30 | 0.2105 | 0.1920 | ✅ Master | +| Line Chart | PlotQA / ChartQA | 30 | 0.2380 | 0.2155 | ✅ Expert | +| Horizontal Bar (HBAR) | PlotQA | 30 | 0.1874 | 0.1710 | ✅ Expert | --- -### Step 3 – Create Your Project Folder - -Inside the repo, create a new folder using the format: -``` -submissions/TeamName_ProjectName/ -``` +# 📂 Dataset Details -**Example:** -``` -submissions/TeamNova_SmartBridge/ -``` +We utilized a **curated subset of 10,000 samples per plot type** to optimize training time and prevent **Catastrophic Forgetting**. -Place all your project files inside this folder. +**Primary Source** +- PlotQA *(Standardized chart reasoning)* ---- +**Secondary Source** +- ChartQA *(Real-world complex styling)* -### Step 4 – Add a `README.md` Inside Your Folder +**Format** +- Donut-ready **JSONL** -Your submission folder **must** include a `README.md` with the following structure: -```markdown -# Project Name +**Label Structure** -## 👥 Team Name - +```text + {ground_truth} -## 🧑‍💻 Team Members -| Name | Role | GitHub | -|------|------|--------| -| Name 1 | Frontend | @username | -| Name 2 | Backend | @username | -## 💡 Problem Statement - +## 🏗️ Technical Architecture +The system is built on a modular "Expert" framework: +* **VBAR Specialist**: Optimized for vertical bar distributions and categorical comparisons. +* **Line Specialist**: Fine-tuned for trend analysis, axis intersections, and slope interpretation. +* **GraphVision Extractor**: A Python-based extraction layer that manages the model weights and handles image-to-text conversion. -## 🛠️ Tech Stack - +### Requirements File +**Commit Message Suggestion:** `feat: add requirements.txt for graphvision environment setup` -## 🔗 Links -- **Live Demo:** [link] -- **Video Demo:** [link](if applicable) -- **Presentation (PPT/PDF):** [link] +Create this file inside the `graphvision/` folder. -## 📸 Screenshots - +```text +torch>=2.0.0 +transformers>=4.30.0 +Pillow>=9.0.0 +datasets>=2.12.0 +safetensors>=0.3.1 +numpy<2.0.0 -## 🚀 How to Run Locally - -``` ---- +## 🛠️ Installation & Setup +To run the extractor locally, ensure you have the required dependencies: -### Step 5 – Commit and Push Your Changes ```bash -git add . -git commit -m "Add submission: TeamName_ProjectName" -git push origin main -``` - ---- - -### Step 6 – Open a Pull Request (PR) - -1. Go to your forked repo on GitHub -2. Click **"Compare & pull request"** -3. Use this PR title format: - `[Submission] TeamName – ProjectName` -4. Fill in the PR description and click **"Create Pull Request"** - -> ⚠️ **Only PRs following the correct format will be reviewed.** - - - ---- - -

Made with ❤️ by ElixirTech Community

+pip install torch transformers pillow datasets safetensors \ No newline at end of file diff --git a/Spectra-Backend/Dockerfile b/Spectra-Backend/Dockerfile new file mode 100644 index 0000000..bfd0ae7 --- /dev/null +++ b/Spectra-Backend/Dockerfile @@ -0,0 +1,17 @@ +FROM python:3.10 + +WORKDIR /code + +# Install system dependencies required by OpenCV and Ultralytics +RUN apt-get update && apt-get install -y libgl1 libglib2.0-0 + +COPY ./requirements.txt /code/requirements.txt + +# Install the Python dependencies +RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt + +# Copy your main.py file into the container +COPY . . + +# Run the FastAPI server on port 7860 +CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"] \ No newline at end of file diff --git a/Spectra-Backend/main.py b/Spectra-Backend/main.py new file mode 100644 index 0000000..b18cc4a --- /dev/null +++ b/Spectra-Backend/main.py @@ -0,0 +1,170 @@ +import os +import json +from fastapi import FastAPI, File, UploadFile +from fastapi.responses import PlainTextResponse +from fastapi.middleware.cors import CORSMiddleware +from groq import Groq + +# Import your newly updated PyPI library! +from graphvision import GraphExtractor + +app = FastAPI(title="STEM Sight Backend") + +app.add_middleware( + CORSMiddleware, + allow_origins=["*"], # Allows any browser extension to connect + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + +# Initialize the Groq Client (Looks for the GROQ_API_KEY environment variable) +groq_client = Groq() + +# Initialize your custom PyPI library +print("Initializing STEM Sight Vision Engine...") +vision_engine = GraphExtractor() + +@app.get("/") +async def root(): + return {"message": "STEM Sight API is online and ready."} + +# @app.post("/analyze-graph", response_class=PlainTextResponse) +# async def analyze_graph(file: UploadFile = File(...)): +# try: +# # 1. Save the uploaded image temporarily +# temp_image_path = f"temp_{file.filename}" +# with open(temp_image_path, "wb") as buffer: +# buffer.write(await file.read()) + +# # 2. Extract structured data using your library +# print(f"Extracting data from {file.filename}...") + +# # 🚨 UPDATED: Call the new extract method +# extraction_json_string = vision_engine.extract(temp_image_path) + +# # Clean up the temporary file immediately +# if os.path.exists(temp_image_path): +# os.remove(temp_image_path) + +# # 🚨 UPDATED: Parse the JSON string back into a Python dictionary +# extraction_result = json.loads(extraction_json_string) + +# # 🚨 UPDATED: Check for the new error format from your library +# if "error" in extraction_result: +# return f"I'm sorry, I couldn't clearly identify the data in this graph. Reason: {extraction_result['error']}" + +# # 3. Format the JSON data into a prompt +# graph_type = extraction_result.get("chart_type", "unknown") +# graph_data = extraction_result.get("data", []) + +# # Grab optional labels/titles if they exist (good for context!) +# x_label = extraction_result.get("x_axis_label", "Unknown X-Axis") +# y_label = extraction_result.get("y_axis_label", "Unknown Y-Axis") +# title = extraction_result.get("title", "Untitled Graph") + +# prompt = f""" +# You are an accessibility assistant for visually impaired students. +# I am giving you extracted data from a {graph_type} chart. +# Title: {title} +# X-Axis Label: {x_label} +# Y-Axis Label: {y_label} + +# Please summarize this data in one short, conversational, and easy-to-understand paragraph. +# Point out the largest and smallest values if relevant. +# Do not use markdown, bold text, or asterisks. Write it exactly as it should be spoken out loud by a text-to-speech engine. + +# Data: +# {graph_data} +# """ + +# # 4. Send to Groq for lightning-fast inference +# print("Generating audio script with Groq Llama 3...") +# chat_completion = groq_client.chat.completions.create( +# messages=[ +# { +# "role": "user", +# "content": prompt, +# } +# ], +# model="llama-3.1-8b-instant", +# temperature=0.4, # Lowered slightly for more factual summaries +# ) + +# # 5. Return strictly the text response for the Chrome extension to speak +# return chat_completion.choices[0].message.content.strip() + +# except Exception as e: +# return f"An error occurred while analyzing the graph: {str(e)}" + +# if __name__ == "__main__": +# import uvicorn +# # Runs the server on port 8000 +# uvicorn.run(app, host="0.0.0.0", port=8000) + + +import time # Add this to your imports + +@app.post("/analyze-graph", response_class=PlainTextResponse) +async def analyze_graph(file: UploadFile = File(...)): + try: + start_time = time.time() + + # 1. Save the uploaded image temporarily + temp_image_path = f"temp_{file.filename}" + with open(temp_image_path, "wb") as buffer: + buffer.write(await file.read()) + + print(f"⏱️ Image received and saved in: {time.time() - start_time:.2f} seconds") + + # 2. Extract structured data + extract_start = time.time() + print(f"Extracting data from {file.filename}...") + extraction_json_string = vision_engine.extract(temp_image_path) + print(f"⏱️ AI Extraction finished in: {time.time() - extract_start:.2f} seconds") + + if os.path.exists(temp_image_path): + os.remove(temp_image_path) + + extraction_result = json.loads(extraction_json_string) + print(f"Extracted data: {extraction_result}") + + if "error" in extraction_result: + return f"I'm sorry, I couldn't clearly identify the data in this graph. Reason: {extraction_result['error']}" + + graph_type = extraction_result.get("chart_type", "unknown") + graph_data = extraction_result.get("data", []) + x_label = extraction_result.get("x_axis_label", "Unknown X-Axis") + y_label = extraction_result.get("y_axis_label", "Unknown Y-Axis") + title = extraction_result.get("title", "Untitled Graph") + + prompt = f""" + You are an accessibility assistant for visually impaired students. + I am giving you extracted data from a {graph_type} chart. + Title: {title} + X-Axis Label: {x_label} + Y-Axis Label: {y_label} + + Please summarize this data in one short, conversational, and easy-to-understand paragraph. + Point out the largest and smallest values if relevant. + Do not use markdown, bold text, or asterisks. Write it exactly as it should be spoken out loud by a text-to-speech engine. + + Data: + {graph_data} + """ + + # 3. Send to Groq + groq_start = time.time() + print("Generating audio script with Groq Llama 3...") + chat_completion = groq_client.chat.completions.create( + messages=[{"role": "user", "content": prompt}], + model="llama-3.1-8b-instant", + temperature=0.4, + ) + print(f"⏱️ Groq Llama 3 finished in: {time.time() - groq_start:.2f} seconds") + print(f"✅ TOTAL TIME: {time.time() - start_time:.2f} seconds") + + return chat_completion.choices[0].message.content.strip() + + except Exception as e: + return f"An error occurred while analyzing the graph: {str(e)}" \ No newline at end of file diff --git a/Spectra-Backend/requirements.txt b/Spectra-Backend/requirements.txt new file mode 100644 index 0000000..9b132bb --- /dev/null +++ b/Spectra-Backend/requirements.txt @@ -0,0 +1,5 @@ +fastapi +uvicorn +python-multipart +groq +graphvision-ai==0.2.3 \ No newline at end of file diff --git a/Spectra-Frontend/background.js b/Spectra-Frontend/background.js new file mode 100644 index 0000000..9adc35f --- /dev/null +++ b/Spectra-Frontend/background.js @@ -0,0 +1,45 @@ +const API_URL = "https://shadowgard3n-spectra-backend.hf.space/analyze-graph"; + +// 1. Listen for the icon click +chrome.action.onClicked.addListener((tab) => { + console.log("🔘 Extension icon clicked on URL:", tab.url); + + chrome.scripting.executeScript({ + target: { tabId: tab.id, allFrames: false }, + files: ["content.js"] + }) + .then(() => console.log("✅ content.js injected successfully!")) + .catch((err) => console.error("❌ Failed to inject content.js:", err)); +}); + +// 2. Listen for image URLs from the webpage +chrome.runtime.onMessage.addListener((request, sender, sendResponse) => { + if (request.action === "analyzeImage") { + console.log("🖼️ Received image to analyze:", request.src); + + processImage(request.src) + .then(explanation => sendResponse({ text: explanation })) + .catch(error => { + console.error("❌ Background Fetch Error:", error); + sendResponse({ text: "Sorry, I could not process this image." }); + }); + + return true; // Keeps the message channel open while waiting for FastAPI + } +}); + +// 3. Send to Hugging Face +async function processImage(imgSrc) { + const imageResponse = await fetch(imgSrc); + const imageBlob = await imageResponse.blob(); + const formData = new FormData(); + formData.append("file", imageBlob, "image.png"); + + const apiResponse = await fetch(API_URL, { + method: "POST", + body: formData + }); + + if (!apiResponse.ok) throw new Error(`API Error: ${apiResponse.status}`); + return await apiResponse.text(); +} \ No newline at end of file diff --git a/Spectra-Frontend/content.js b/Spectra-Frontend/content.js new file mode 100644 index 0000000..015781d --- /dev/null +++ b/Spectra-Frontend/content.js @@ -0,0 +1,124 @@ +(function() { + // 1. THE TOGGLE SWITCH: If clicked while already running, stop it entirely! + if (window.STEM_SIGHT_ACTIVE) { + console.log("🛑 Extension clicked again. Stopping STEM Sight."); + window.STEM_SIGHT_ACTIVE = false; + window.speechSynthesis.cancel(); + return; + } + + // 2. Turn it on + window.STEM_SIGHT_ACTIVE = true; + console.log("🧠 STEM Sight content script has booted up!"); + + // 3. The Panic Button: Press 'Escape' to stop the AI completely + document.addEventListener('keydown', function escapeListener(event) { + if (event.key === 'Escape') { + console.log("🛑 Escape key pressed. Stopping STEM Sight."); + window.STEM_SIGHT_ACTIVE = false; + window.speechSynthesis.cancel(); + document.removeEventListener('keydown', escapeListener); // Clean up + } + }); + + // 4. Ultra-Safe Speech Engine + function speakAndWait(text) { + if (!window.STEM_SIGHT_ACTIVE) return Promise.resolve(); + + console.log("🔊 Attempting to speak:", text); + + return new Promise((resolve) => { + window.speechSynthesis.cancel(); + + setTimeout(() => { + if (!window.STEM_SIGHT_ACTIVE) return resolve(); + + // Attach to 'window' so Chrome's memory manager NEVER deletes the voice + window.stemSightUtterance = new SpeechSynthesisUtterance(text); + window.stemSightUtterance.rate = 1.0; + + // Safety timer just in case Chrome freezes again + const maxReadTime = (text.length * 100) + 3000; + let safetyTimer = setTimeout(() => { + if (window.STEM_SIGHT_ACTIVE) { + console.warn("⚠️ Chrome voice got stuck! Forcing skip to next element."); + } + resolve(); + }, maxReadTime); + + window.stemSightUtterance.onend = () => { + clearTimeout(safetyTimer); + console.log("✅ Finished speaking."); + resolve(); + }; + + window.stemSightUtterance.onerror = (e) => { + clearTimeout(safetyTimer); + if (e.error !== 'canceled' && e.error !== 'interrupted') { + console.error("❌ Speech error:", e.error); + } + resolve(); + }; + + window.speechSynthesis.speak(window.stemSightUtterance); + }, 100); + }); + } + + // 5. Secure Backend Request + async function analyzeImage(imgSrc) { + return new Promise((resolve) => { + chrome.runtime.sendMessage({ action: "analyzeImage", src: imgSrc }, (response) => { + if (chrome.runtime.lastError) { + resolve("Sorry, the extension disconnected from the server."); + } else { + resolve(response.text); + } + }); + }); + } + + // 6. Main Reading Loop + async function startReading() { + await speakAndWait("STEM sight activated. Reading page. Press escape to stop."); + + const elements = document.querySelectorAll('h1, h2, h3, h4, p, img'); + console.log(`📄 Found ${elements.length} elements to read.`); + + for (let i = 0; i < elements.length; i++) { + if (!window.STEM_SIGHT_ACTIVE) break; // Emergency Stop Check + + const el = elements[i]; + + if (el.tagName === 'P' || el.tagName.startsWith('H')) { + const text = el.innerText.trim(); + if (text.length > 10) { + await speakAndWait(text); + } + } + else if (el.tagName === 'IMG') { + if (el.width < 50 || el.height < 50) continue; + + console.log("🔎 Found an image, sending to backend:", el.src); + await speakAndWait("Image encountered. Analyzing."); + + if (!window.STEM_SIGHT_ACTIVE) break; + + const explanation = await analyzeImage(el.src); + + if (!window.STEM_SIGHT_ACTIVE) break; + + console.log("🧠 Backend response:", explanation); + await speakAndWait(explanation); + } + } + + if (window.STEM_SIGHT_ACTIVE) { + await speakAndWait("End of page reached."); + window.STEM_SIGHT_ACTIVE = false; + } + } + + // Start! + startReading(); +})(); \ No newline at end of file diff --git a/Spectra-Frontend/manifest.json b/Spectra-Frontend/manifest.json new file mode 100644 index 0000000..53fc438 --- /dev/null +++ b/Spectra-Frontend/manifest.json @@ -0,0 +1,19 @@ +{ + "manifest_version": 3, + "name": "STEM Sight Reader", + "version": "2.0", + "description": "Autonomous AI screen reader for visually impaired students.", + "permissions": [ + "activeTab", + "scripting" + ], + "host_permissions": [ + "" + ], + "action": { + "default_title": "Start STEM Sight Reading" + }, + "background": { + "service_worker": "background.js" + } +} \ No newline at end of file diff --git a/graphvision/README.md b/graphvision/README.md new file mode 100644 index 0000000..faa4d6b --- /dev/null +++ b/graphvision/README.md @@ -0,0 +1,85 @@ +# GraphVision AI 📊👁️ + +GraphVision AI is a lightweight, powerful computer vision library for automatic graph classification and structured data extraction. + +Built with PyTorch and EasyOCR, it is designed to look at an image of a chart, instantly recognize what kind of graph it is, and extract its labels and values into a clean, developer-friendly JSON format. + +--- + +## ✨ Key Features + +### 🚀 Zero-Configuration +Models and weights are automatically downloaded from Hugging Face the first time you run it. No manual weight management required. + +### 🧠 Intelligent Routing +Automatically classifies the input image (Pie, Vertical Bar, Horizontal Bar, Line, etc.) and routes it to the correct extraction algorithm. + +### 🖼 Robust Input Handling +Pass a file path (`String`), an OpenCV image (`NumPy array`), or a `PIL Image` directly into the analyzer. + +### 🔍 Smart OCR Masking +Uses contrast filtering and spatial mapping to accurately match text labels with their corresponding graphical data points. + +--- + +## 📦 Installation + +Install directly from PyPI: + +```bash +pip install graphvision-ai +``` + + +## 🚀 Quick Start + +Extracting data from a graph takes less than 5 lines of code: + + +``` +from graphvision.extractor import GraphExtractor + +try: + # 1. Initialize your engine (this will download weights if needed) + vision_engine = GraphExtractor() + + # Path to your test image + image_to_test = "hbar2.png" + + # 2. Run the extraction using the new method name + print(f"\n🚀 Extracting data from {image_to_test}...") + result_json_string = vision_engine.extract(image_to_test) + + # 3. Print the result (it's already a nicely formatted string!) + print("\n✅ Extraction Successful!") + print(result_json_string) + +except Exception as e: + print(f"\n❌ Error during testing: {e}") +``` + +## 📄 Example Output + +``` +{ + "type": "pie", + "title": "Favorite Programming Languages", + "data": { + "Python": 45.2, + "JavaScript": 25.1, + "C++": 15.4, + "Java": 14.3 + } +} +``` + + +## 📈 Supported Graph Types + +Currently, GraphVision AI supports high-accuracy extraction for: + +- `pie` — Pie Charts +- `vbar_categorical` — Vertical Bar Charts +- `hbar_categorical` — Horizontal Bar Charts + +Line and Dot-Line charts coming soon. \ No newline at end of file diff --git a/graphvision/graphvision/__init__.py b/graphvision/graphvision/__init__.py new file mode 100644 index 0000000..a305d8e --- /dev/null +++ b/graphvision/graphvision/__init__.py @@ -0,0 +1,3 @@ +from .extractor import GraphExtractor + +__all__ = ["GraphExtractor"] \ No newline at end of file diff --git a/graphvision/graphvision/extractor.py b/graphvision/graphvision/extractor.py new file mode 100644 index 0000000..527e034 --- /dev/null +++ b/graphvision/graphvision/extractor.py @@ -0,0 +1,777 @@ +import os +import re +import cv2 +import json +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from PIL import Image +from torchvision import models +import torchvision.transforms as transforms +from ultralytics import YOLO +import easyocr +from huggingface_hub import hf_hub_download +import warnings + +# Suppress annoying warnings to keep the terminal clean +warnings.filterwarnings("ignore") + +# --- PIE CHART MODEL ARCHITECTURE --- +class PieRegressor(nn.Module): + def __init__(self): + super(PieRegressor, self).__init__() + self.backbone = models.resnet18() + num_ftrs = self.backbone.fc.in_features + self.backbone.fc = nn.Linear(num_ftrs, 10) + self.sigmoid = nn.Sigmoid() + + def forward(self, x): + x = self.backbone(x) + return self.sigmoid(x) + +# --- MAIN EXTRACTION ENGINE --- +class GraphExtractor: + def __init__(self): + self.device = torch.device("mps" if torch.backends.mps.is_available() else "cuda" if torch.cuda.is_available() else "cpu") + self.hf_repo_id = "ShadowGard3n/graphvision" + + print("🧠 Booting up GraphVision AI Models from Hugging Face...") + + # 1. Download Weights + classifier_path = hf_hub_download(repo_id=self.hf_repo_id, filename="graph_classifier_real.pth") + pie_model_path = hf_hub_download(repo_id=self.hf_repo_id, filename="pie_regressor_stable.pth") + yolo_path = hf_hub_download(repo_id=self.hf_repo_id, filename="bar.pt") + dot_yolo_path = hf_hub_download(repo_id=self.hf_repo_id, filename="dot_line.pt") + + # 2. Setup Chart Classifier + self.CLASS_NAMES = ['dot_line', 'hbar_categorical', 'line', 'pie', 'vbar_categorical'] + self.classifier = models.resnet18() + self.classifier.fc = nn.Linear(self.classifier.fc.in_features, 5) + self.classifier.load_state_dict(torch.load(classifier_path, map_location=self.device)) + self.classifier.to(self.device) + self.classifier.eval() + + self.transform = transforms.Compose([ + transforms.Resize((224, 224)), + transforms.ToTensor(), + transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) + ]) + + # 3. Setup YOLO Bar Detector + self.yolo_model = YOLO(yolo_path) + + # 4. Setup YOLO Dot line Detector + self.dot_yolo_model = YOLO(dot_yolo_path) + + # 5. Setup Pie Regressor + self.pie_model = PieRegressor() + self.pie_model.load_state_dict(torch.load(pie_model_path, map_location=self.device)) + self.pie_model.to(self.device) + self.pie_model.eval() + + # 6. Setup OCR Text Reader + self.ocr_reader = easyocr.Reader(['en'], gpu=torch.cuda.is_available() or torch.backends.mps.is_available()) + + def _extract_number(self, text_str): + matches = re.findall(r'-?\d+\.?\d*', text_str.replace(',', '')) + if matches: + return float(matches[0]) + + text_clean = text_str.strip().upper() + if text_clean == 'O': return 0.0 + if text_clean == 'S': return 5.0 + if text_clean in ['I', 'L']: return 1.0 + return None + + @staticmethod + def _color_distance(c1, c2): + """Calculate Euclidean distance between two BGR colors.""" + return np.linalg.norm(np.array(c1, dtype=np.float32) - np.array(c2, dtype=np.float32)) + + @staticmethod + def _get_robust_scale(axis_nums, axis_key='y'): + """Robust scaling that ignores OCR typos.""" + if len(axis_nums) < 2: + return 1.0, 0.0 + + coords = np.array([n[axis_key] for n in axis_nums]) + vals = np.array([n['val'] for n in axis_nums]) + + median_val = np.median(vals) + if median_val > 0: + for i in range(len(vals)): + if vals[i] > median_val * 5: + vals[i] /= 10.0 + + slopes = [] + for i in range(len(coords)): + for j in range(i+1, len(coords)): + if abs(coords[i] - coords[j]) > 10: + slope = (vals[i] - vals[j]) / (coords[i] - coords[j]) + slopes.append(slope) + + if not slopes: + return 1.0, 0.0 + + best_m = np.median(slopes) + intercepts = vals - best_m * coords + best_c = np.median(intercepts) + + return best_m, best_c + + def extract(self, image_path): + """ + Main entry point. Classifies the image and routes it to the correct extraction logic. + """ + if not os.path.exists(image_path): + return json.dumps({"error": f"Image not found at {image_path}"}) + + print(f"\n🚀 Analyzing: {image_path}") + print("-" * 40) + + # --- Classify Chart Type --- + img_pil = Image.open(image_path).convert('RGB') + img_tensor = self.transform(img_pil).unsqueeze(0).to(self.device) + + with torch.no_grad(): + outputs = self.classifier(img_tensor) + _, predicted = torch.max(outputs, 1) + chart_type = self.CLASS_NAMES[predicted.item()] + + print(f"📊 Detected Chart Type: {chart_type.upper()}") + + # --- Route to specific extractors --- + if 'bar' in chart_type: + return self._extract_bar_chart(image_path, chart_type) + elif 'pie' in chart_type: + return self._extract_pie_chart(image_path) + elif chart_type == 'dot_line': + return self._extract_dot_line_chart(image_path) + else: + return json.dumps({ + "chart_type": chart_type, + "error": f"Extraction for {chart_type} is currently under development." + }, indent=4) + + def _extract_dot_line_chart(self, image_path): + results = self.dot_yolo_model(image_path, conf=0.5, iou=0.4, imgsz=1024, verbose=False) + boxes = results[0].boxes.xyxy.cpu().numpy() + + if len(boxes) == 0: + return json.dumps({"chart_type": "dot_line", "error": "No dots detected."}) + + img_cv = cv2.imread(image_path) + # img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC) + h, w = img_cv.shape[:2] + + scale = 2.0 if w < 800 else 1.0 + + if scale == 2.0: + img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC) + else: + img_upscaled = img_cv.copy() + + ocr_results = self.ocr_reader.readtext(img_upscaled) + + numbers = [] + text_labels = [] + raw_legend_candidates = [] + + for (bbox, text, prob) in ocr_results: + orig_tl_x, orig_tl_y = bbox[0][0] / scale, bbox[0][1] / scale + orig_br_x, orig_br_y = bbox[2][0] / scale, bbox[2][1] / scale + + cx = (orig_tl_x + orig_br_x) / 2.0 + cy = (orig_tl_y + orig_br_y) / 2.0 + + val = self._extract_number(text) + if val is not None: + numbers.append({'val': val, 'x': cx, 'y': cy}) + else: + text_labels.append({'text': text, 'x': cx, 'y': cy}) + raw_legend_candidates.append({ + 'text': text, + 'x': cx, + 'tl_x': orig_tl_x, + 'cy': cy, + 'height': orig_br_y - orig_tl_y + }) + + leftmost_dot = boxes[:, 0].min() + bottommost_dot = boxes[:, 3].max() + + y_axis_nums = [n for n in numbers if n['x'] < leftmost_dot] + y_m, y_c = self._get_robust_scale(y_axis_nums, axis_key='y') + + x_axis_nums = [n for n in numbers if n['y'] > bottommost_dot] + x_m, x_c = self._get_robust_scale(x_axis_nums, axis_key='x') + + legend_colors = {} + legend_texts = set() + ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'x_axis', 'y_axis'] + + for item in raw_legend_candidates: + clean_text = item['text'].strip() + if clean_text.lower() in ignore_words: + continue + + sample_x = int(item['tl_x'] - item['height'] * 0.8) + sample_y = int(item['cy']) + + if sample_x > 0 and sample_y > 0 and sample_x < img_cv.shape[1] and sample_y < img_cv.shape[0]: + bgr_color = img_cv[sample_y, sample_x] + b, g, r = int(bgr_color[0]), int(bgr_color[1]), int(bgr_color[2]) + + is_not_white = (b + g + r) < 700 + is_not_black = (b + g + r) > 50 + is_colorful = max(b, g, r) - min(b, g, r) > 20 + + if is_not_white and is_not_black and is_colorful: + legend_colors[clean_text] = bgr_color + legend_texts.add(item['text']) + + extracted_points = [] + + for box in boxes: + cx = int((box[0] + box[2]) / 2) + cy = int((box[1] + box[3]) / 2) + + real_x = (x_m * cx) + x_c + real_y = (y_m * cy) + y_c + + dot_color = img_cv[cy, cx] + best_class = "Unknown" + + if legend_colors: + best_class = min(legend_colors.keys(), key=lambda k: self._color_distance(dot_color, legend_colors[k])) + + extracted_points.append({ + "class": best_class, + "x": float(round(real_x, 2)), + "y": float(round(real_y, 2)) + }) + + extracted_points.sort(key=lambda p: p['x']) + + title, x_axis_label, y_axis_label = None, None, None + + if text_labels: + top_most = min(text_labels, key=lambda l: l['y']) + if top_most['y'] < boxes[:, 1].min(): + title = top_most['text'] + + remaining = [l for l in text_labels if l != top_most and l['text'] not in legend_texts] + + if remaining: + bottom_most = max(remaining, key=lambda l: l['y']) + x_axis_label = bottom_most['text'] + left_most = min(remaining, key=lambda l: l['x']) + y_axis_label = left_most['text'] + + output = { + "chart_type": "dot_line", + "title": title, + "x_axis_label": x_axis_label, + "y_axis_label": y_axis_label, + "total_points": len(extracted_points), + "data": extracted_points + } + + return json.dumps(output, indent=4) + + def _extract_bar_chart(self, image_path, chart_type): + results = self.yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False) + boxes = results[0].boxes.xyxy.cpu().numpy() + + if len(boxes) == 0: + return json.dumps({"chart_type": chart_type, "error": "No bars detected."}) + + img_cv = cv2.imread(image_path) + # img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC) + + # ocr_results = self.ocr_reader.readtext(img_upscaled) + + h, w = img_cv.shape[:2] + + scale = 2.0 if w < 800 else 1.0 + + if scale == 2.0: + img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC) + else: + img_upscaled = img_cv.copy() + + img_for_ocr = img_upscaled.copy() + + for box in boxes: + # Scale YOLO boxes up if the image was upscaled + scale = 2 if w < 800 else 1 + x1, y1, x2, y2 = [int(coord * scale) for coord in box] + + # Fill the bar area with white (255, 255, 255) + cv2.rectangle(img_for_ocr, (x1, y1), (x2, y2), (255, 255, 255), -1) + + ocr_results = self.ocr_reader.readtext(img_for_ocr) + numbers = [] + text_labels = [] + + # def add_or_update_label(new_text, new_cx, new_cy): + # if len(new_text.strip()) == 1 and not new_text.isalnum(): + # return + # existing = next((l for l in text_labels if abs(l['x'] - new_cx) < 30 and abs(l['y'] - new_cy) < 30), None) + # if existing: + # if len(new_text) > len(existing['text']): + # existing['text'] = new_text + # else: + # text_labels.append({'text': new_text, 'x': new_cx, 'y': new_cy}) + + # Update the definition to accept is_rotated + def add_or_update_label(new_text, new_cx, new_cy, is_rotated=False): + if len(new_text.strip()) == 1 and not new_text.isalnum(): + return + existing = next((l for l in text_labels if abs(l['x'] - new_cx) < 30 and abs(l['y'] - new_cy) < 30), None) + if existing: + if len(new_text) > len(existing['text']): + existing['text'] = new_text + existing['is_rotated'] = is_rotated + else: + # Save the rotation flag with the text + text_labels.append({'text': new_text, 'x': new_cx, 'y': new_cy, 'is_rotated': is_rotated}) + + # Horizontal Pass + for (bbox, text, prob) in ocr_results: + cx = ((bbox[0][0] + bbox[1][0]) / 2) / scale + cy = ((bbox[0][1] + bbox[2][1]) / 2) / scale + val = self._extract_number(text) + if val is not None: + numbers.append({'val': val, 'x': cx, 'y': cy}) + else: + add_or_update_label(text, cx, cy, is_rotated=False) + + # Rotated Passes for VBAR + # if 'vbar' in chart_type.lower(): + h_up, w_up = img_upscaled.shape[:2] + + img_rot_ccw = cv2.rotate(img_upscaled, cv2.ROTATE_90_COUNTERCLOCKWISE) + for (bbox, text, prob) in self.ocr_reader.readtext(img_rot_ccw): + cx_rot = ((bbox[0][0] + bbox[1][0]) / 2) + cy_rot = ((bbox[0][1] + bbox[2][1]) / 2) + cx = (w_up - cy_rot) / scale + cy = cx_rot / scale + if self._extract_number(text) is None: + add_or_update_label(text, cx, cy, is_rotated=True) + + img_rot_cw = cv2.rotate(img_upscaled, cv2.ROTATE_90_CLOCKWISE) + for (bbox, text, prob) in self.ocr_reader.readtext(img_rot_cw): + cx_rot = ((bbox[0][0] + bbox[1][0]) / 2) + cy_rot = ((bbox[0][1] + bbox[2][1]) / 2) + cx = cy_rot / scale + cy = (h_up - cx_rot) / scale + if self._extract_number(text) is None: + add_or_update_label(text, cx, cy, is_rotated=True) + + final_data = [] + ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'y_axis', 'x_axis'] + + if 'hbar' in chart_type.lower(): + lowest_bar_bottom = boxes[:, 3].max() + axis_nums = sorted([n for n in numbers if n['y'] > lowest_bar_bottom - 20], key=lambda d: d['x']) + + if len(axis_nums) >= 2: + units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x']) + zero_x_pixel = axis_nums[0]['x'] - (axis_nums[0]['val'] / units_per_pixel) + else: + units_per_pixel = 1.0 + zero_x_pixel = boxes[:, 0].min() + + img_w = img_cv.shape[1] + max_label_distance = img_w * 0.4 + + sorted_boxes = sorted(boxes, key=lambda b: b[1]) + for box in sorted_boxes: + x1, y1, x2, y2 = box + bar_cy = (y1 + y2) / 2 + if (x2 - x1) < 10 or (y2 - y1) < 5: continue + + + # Get ALL labels to the left of the bar that are vertically aligned with it (within 15 pixels) + aligned_labels = [ + l for l in text_labels + if l['x'] < x1 + and (x1 - l['x']) < max_label_distance + and abs(l['y'] - bar_cy) < 15 + and not l.get('is_rotated', False) + and l['text'].lower().replace('_', ' ') not in ignore_words + ] + + if aligned_labels: + # Sort the fragments left-to-right based on their x position + aligned_labels.sort(key=lambda l: l['x']) + # Join them together with a space + label_text = " ".join([l['text'] for l in aligned_labels]) + else: + label_text = "Unknown Category" + + # possible_labels = [ + # l for l in text_labels + # if l['x'] < x1 and (x1 - l['x']) < max_label_distance and l['text'].lower().replace('_', ' ') not in ignore_words + # ] + + # # possible_labels = [ + # # l for l in text_labels + # # if l['x'] < x1 and (x1 - l['x']) < 150 and l['text'].lower().replace('_', ' ') not in ignore_words + # # ] + + # if possible_labels: + # best_label = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy)) + # label_text = best_label['text'] + # else: + # label_text = "Unknown Category" + + real_val = (x2 - zero_x_pixel) * units_per_pixel + final_data.append((label_text, round(real_val, 2))) + + elif 'vbar' in chart_type.lower(): + leftmost_bar_edge = boxes[:, 0].min() + axis_nums = sorted([n for n in numbers if n['x'] < leftmost_bar_edge + 20], key=lambda d: d['y'], reverse=True) + + if len(axis_nums) >= 2: + units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y'])) + zero_y_pixel = axis_nums[0]['y'] + (axis_nums[0]['val'] / units_per_pixel) + else: + units_per_pixel = 1.0 + zero_y_pixel = boxes[:, 3].max() + + sorted_boxes = sorted(boxes, key=lambda b: b[0]) + for box in sorted_boxes: + x1, y1, x2, y2 = box + bar_cx = (x1 + x2) / 2 + if (x2 - x1) < 5 or (y2 - y1) < 10: continue + + possible_labels = [ + l for l in text_labels + if l['y'] > y2 and (l['y'] - y2) < 150 and l['text'].lower().replace('_', ' ') not in ignore_words + ] + + if possible_labels: + best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx)) + label_text = best_label['text'] + else: + label_text = "Unknown Category" + + real_val = (zero_y_pixel - y1) * units_per_pixel + final_data.append((label_text, round(real_val, 2))) + + x_axis_label, y_axis_label = None, None + if text_labels: + category_texts = [item[0] for item in final_data] + bottom_most = max(text_labels, key=lambda l: l['y']) + if bottom_most['text'] not in category_texts and bottom_most['text'].lower() != 'title': + x_axis_label = bottom_most['text'] + + left_most = min(text_labels, key=lambda l: l['x']) + if left_most['text'] not in category_texts and left_most['text'].lower() != 'title': + y_axis_label = left_most['text'] + + output_dict = { + "chart_type": chart_type, + "x_axis_label": x_axis_label, + "y_axis_label": y_axis_label, + "data": [{"category": label, "value": value} for label, value in final_data] + } + return json.dumps(output_dict, indent=4) + + def _extract_pie_chart(self, image_path): + img_pil = Image.open(image_path).convert('RGB') + input_tensor = self.transform(img_pil).unsqueeze(0).to(self.device) + + with torch.no_grad(): + preds = self.pie_model(input_tensor).squeeze().cpu().numpy() * 100.0 + + cv_img = cv2.imread(image_path) + h, w, _ = cv_img.shape + gray = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY) + + all_text_results = self.ocr_reader.readtext(gray, mag_ratio=2.5) + + title = "Untitled" + raw_legend_names = [] + + for bbox, text, conf in all_text_results: + clean_text = text.strip() + if not clean_text: continue + + y_center = (bbox[0][1] + bbox[2][1]) / 2 + y_pct = y_center / h + + if y_pct < 0.15: + title = clean_text + elif y_pct > 0.15: + if len(clean_text) > 2 and not clean_text.replace('.', '', 1).isdigit(): + if clean_text.lower() == "grav": clean_text = "Gray" + raw_legend_names.append((y_pct, clean_text)) + + legend_names = [item[1] for item in sorted(raw_legend_names, key=lambda i: i[0])] + + num_slices = len(legend_names) + if num_slices == 0: + valid_preds = [v for v in preds if v > 1.5] + num_slices = len(valid_preds) + + num_slices = min(num_slices, 10) + slice_preds = preds[:num_slices] + + total_pred = sum(slice_preds) + if total_pred > 0: + normalized_preds = [(v / total_pred) * 100.0 for v in slice_preds] + else: + normalized_preds = slice_preds + + final_slices = {} + for i in range(num_slices): + slice_name = legend_names[i] if i < len(legend_names) else f"Unknown_Slice_{i+1}" + slice_value = round(float(normalized_preds[i]), 2) if i < len(normalized_preds) else 0.0 + # slice_value = round(normalized_preds[i], 2) if i < len(normalized_preds) else 0.0 + final_slices[slice_name] = slice_value + + return json.dumps({"chart_type": "pie", "title": title, "data": final_slices}, indent=4) + + + + +## Fast but inaccurate + +# import torch +# import torch.nn as nn +# import torchvision.transforms as transforms +# from torchvision import models +# from PIL import Image +# from ultralytics import YOLO +# import easyocr +# import warnings +# import numpy as np +# import cv2 +# import os +# from huggingface_hub import hf_hub_download +# import matplotlib.pyplot as plt + +# # Suppress annoying warnings +# warnings.filterwarnings("ignore") + +# # --- CUSTOM PIE REGRESSOR DEFINITION --- +# class PieRegressor(nn.Module): +# def __init__(self): +# super(PieRegressor, self).__init__() +# self.backbone = models.resnet18(weights=None) +# num_ftrs = self.backbone.fc.in_features +# self.backbone.fc = nn.Linear(num_ftrs, 10) +# self.sigmoid = nn.Sigmoid() + +# def forward(self, x): +# x = self.backbone(x) +# return self.sigmoid(x) + + +# # --- MAIN EXTRACTOR CLASS --- +# class GraphExtractor: +# def __init__(self, hf_repo_id="ShadowGard3n/graphvision"): +# """ +# Initializes the STEM Sight AI Models by fetching weights directly from Hugging Face. +# """ +# print(f"🧠 Booting up STEM Sight AI Models from {hf_repo_id}...") + +# self.device = torch.device("mps" if torch.backends.mps.is_available() else "cuda" if torch.cuda.is_available() else "cpu") +# print(f"⚡ Using device: {self.device}") + +# print("📥 Checking model weights (downloading if not cached)...") +# classifier_path = hf_hub_download(repo_id=hf_repo_id, filename="graph_classifier_real.pth") +# pie_model_path = hf_hub_download(repo_id=hf_repo_id, filename="pie_regressor_stable.pth") +# yolo_path = hf_hub_download(repo_id=hf_repo_id, filename="best.pt") + +# self.transform = transforms.Compose([ +# transforms.Resize((224, 224)), +# transforms.ToTensor(), +# transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) +# ]) + +# self.ocr_reader = easyocr.Reader(['en'], gpu=(self.device.type != 'cpu'), verbose=False) + +# self.classifier = models.resnet18() +# self.classifier.fc = nn.Linear(self.classifier.fc.in_features, 5) +# self.classifier.load_state_dict(torch.load(classifier_path, map_location=self.device)) +# self.classifier.to(self.device) +# self.classifier.eval() +# self.class_names = ['vbar_categorical', 'hbar_categorical', 'line', 'pie', 'dot_line'] + +# self.yolo_model = YOLO(yolo_path) + +# self.pie_model = PieRegressor().to(self.device) +# self.pie_model.load_state_dict(torch.load(pie_model_path, map_location=self.device)) +# self.pie_model.eval() + +# print("✅ All models loaded successfully!\n") + +# def identify_graph_type(self, image_path): +# img_pil = Image.open(image_path).convert('RGB') +# img_tensor = self.transform(img_pil).unsqueeze(0).to(self.device) + +# with torch.no_grad(): +# outputs = self.classifier(img_tensor) +# _, predicted = torch.max(outputs, 1) +# chart_type = self.class_names[predicted.item()] + +# return chart_type + +# # Notice the new `show=False` parameter +# def extract_data(self, image_path, show=False): +# if not os.path.exists(image_path): +# return {"error": f"Image not found at {image_path}"} + +# chart_type = self.identify_graph_type(image_path) + +# response = { +# "chart_type": chart_type, +# "data": None, +# "status": "Success" +# } + +# # Pass the `show` parameter down to the extractors +# if chart_type in ['hbar_categorical', 'vbar_categorical']: +# response["data"] = self._extract_bars(image_path, chart_type, show) +# elif chart_type == 'pie': +# response["data"] = self._extract_pie(image_path, show) +# elif chart_type in ['line', 'dot_line']: +# response["status"] = "Pending Implementation" +# response["message"] = f"Extraction for {chart_type} is not yet integrated." +# else: +# response["status"] = "Unknown Chart Type" + +# return response + +# def _extract_bars(self, image_path, chart_type, show): +# results = self.yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False) +# boxes = results[0].boxes.xyxy.cpu().numpy() + +# # --- DISPLAY THE GRAPH WITH YOLO BOXES --- +# if show: +# annotated_img = results[0].plot() +# annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB) +# plt.figure(figsize=(10, 6)) +# plt.imshow(annotated_img_rgb) +# file_name = os.path.basename(image_path) +# plt.title(f"STEM Sight Extraction: {file_name} ({chart_type.upper()})") +# plt.axis('off') +# plt.show() + +# if len(boxes) == 0: +# return {"error": "No bars detected"} + +# ocr_results = self.ocr_reader.readtext(image_path) +# numbers, text_labels = [], [] + +# for (bbox, text, prob) in ocr_results: +# cx = (bbox[0][0] + bbox[1][0]) / 2 +# cy = (bbox[0][1] + bbox[2][1]) / 2 +# clean_text = text.replace(',', '').replace('.', '').strip() + +# if clean_text.isdigit(): +# numbers.append({'val': float(clean_text), 'x': cx, 'y': cy}) +# else: +# text_labels.append({'text': text, 'x': cx, 'y': cy}) + +# final_data = {} + +# if chart_type == 'hbar_categorical': +# axis_nums = sorted([n for n in numbers if n['y'] > boxes[:, 3].max() - 50], key=lambda d: d['x']) +# units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x']) if len(axis_nums) >= 2 else 1.0 +# sorted_boxes = sorted(boxes, key=lambda b: b[1]) + +# for box in sorted_boxes: +# x1, y1, x2, y2 = box +# bar_cy = (y1 + y2) / 2 +# pixel_val = x2 - x1 +# if pixel_val < 10 or (y2-y1) < 5: continue + +# possible_labels = [l for l in text_labels if l['x'] < x1] +# label_text = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy))['text'] if possible_labels else "Unknown" +# # Ensure clean standard python int +# final_data[label_text] = int(float(pixel_val * units_per_pixel)) + +# elif chart_type == 'vbar_categorical': +# axis_nums = sorted([n for n in numbers if n['x'] < boxes[:, 0].min() + 50], key=lambda d: d['y'], reverse=True) +# units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y'])) if len(axis_nums) >= 2 else 1.0 +# sorted_boxes = sorted(boxes, key=lambda b: b[0]) + +# for box in sorted_boxes: +# x1, y1, x2, y2 = box +# bar_cx = (x1 + x2) / 2 +# pixel_val = y2 - y1 +# if pixel_val < 10 or (x2-x1) < 5: continue + +# possible_labels = [l for l in text_labels if l['y'] > y2] +# label_text = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx))['text'] if possible_labels else "Unknown" +# # Ensure clean standard python int +# final_data[label_text] = int(float(pixel_val * units_per_pixel)) + +# return final_data + +# def _extract_pie(self, image_path, show): +# img_pil = Image.open(image_path).convert('RGB') +# input_tensor = self.transform(img_pil).unsqueeze(0).to(self.device) + +# with torch.no_grad(): +# preds = self.pie_model(input_tensor).squeeze().cpu().numpy() * 100.0 + +# cv_img = cv2.imread(image_path) +# h, w, _ = cv_img.shape +# gray = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY) +# all_text_results = self.ocr_reader.readtext(gray, mag_ratio=2.5) + +# title = "Untitled" +# raw_legend_names = [] + +# for bbox, text, conf in all_text_results: +# clean_text = text.strip() +# if not clean_text: continue + +# x_center, y_center = (bbox[0][0] + bbox[2][0]) / 2, (bbox[0][1] + bbox[2][1]) / 2 +# y_pct = y_center / h + +# if y_pct < 0.15: +# title = clean_text +# elif y_pct >= 0.15: +# if len(clean_text) > 2 and not clean_text.replace('.', '', 1).isdigit(): +# if clean_text.lower() == "grav": clean_text = "Gray" +# raw_legend_names.append((y_pct, clean_text)) + +# legend_names = [item[1] for item in sorted(raw_legend_names, key=lambda i: i[0])] + +# num_slices = len(legend_names) +# if num_slices == 0: +# num_slices = len([v for v in preds if v > 1.5]) + +# num_slices = min(num_slices, 10) +# slice_preds = sorted(preds[:num_slices], reverse=True) + +# total_pred = sum(slice_preds) +# normalized_preds = [(v / total_pred) * 100.0 for v in slice_preds] if total_pred > 0 else slice_preds + +# final_slices = {} +# for i in range(num_slices): +# slice_name = legend_names[i] if i < len(legend_names) else f"Category_{i+1}" +# val = normalized_preds[i] if i < len(normalized_preds) else 0.0 + +# # CRITICAL FIX: Cast to standard Python float to prevent JSON float32 crash +# final_slices[slice_name] = float(round(val, 2)) + +# # --- DISPLAY THE PIE GRAPH --- +# if show: +# plt.figure(figsize=(8, 5)) +# plt.imshow(img_pil) +# plt.title(f"Analyzed Pie Chart: {title}") +# plt.axis('off') +# plt.show() + +# return {"title": title, "slices": final_slices} + + diff --git a/graphvision/pyproject.toml b/graphvision/pyproject.toml new file mode 100644 index 0000000..353baa6 --- /dev/null +++ b/graphvision/pyproject.toml @@ -0,0 +1,29 @@ +[build-system] +requires = ["setuptools>=61.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "graphvision-ai" +version = "0.2.3" +description = "Automatic Graph Classification and Data Extraction" +readme = "README.md" +authors = [{name="Aryan Gahlot"}] +license = {text = "MIT License"} +classifiers = [ + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Operating System :: OS Independent", +] +dependencies = [ + "torch", + "torchvision", + "opencv-python-headless", + "easyocr", + "Pillow", + "numpy", + "huggingface_hub", + "ultralytics" +] + +[tool.setuptools.packages.find] +include = ["graphvision"] \ No newline at end of file diff --git a/notebooks/Combine.ipynb b/notebooks/Combine.ipynb new file mode 100644 index 0000000..01de8d2 --- /dev/null +++ b/notebooks/Combine.ipynb @@ -0,0 +1,3287 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "99be1d6b-ed9b-4642-9311-4d831baedc73", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aryangahlot/.pyenv/versions/tfenv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🚀 Loading CLIP Bouncer Model...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights: 100%|███████████████████████████████████████████████████| 398/398 [00:00<00:00, 1938.79it/s, Materializing param=visual_projection.weight]\n", + "CLIPModel LOAD REPORT from: openai/clip-vit-base-patch32\n", + "Key | Status | | \n", + "-------------------------------------+------------+--+-\n", + "vision_model.embeddings.position_ids | UNEXPECTED | | \n", + "text_model.embeddings.position_ids | UNEXPECTED | | \n", + "\n", + "Notes:\n", + "- UNEXPECTED\t:can be ignored when loading from different task/architecture; not ok if you expect identical arch.\n", + "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n", + "The image processor of type `CLIPImageProcessor` is now loaded as a fast processor by default, even if the model checkpoint was saved with a slow processor. This is a breaking change and may produce slightly different outputs. To continue using the slow processor, instantiate this class with `use_fast=False`. \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "==================================================\n", + "🔥 STARTING SPLIT: VAL\n", + "==================================================\n", + "\n", + "--- Parsing FigureQA (val) ---\n", + "✅ Successfully extracted 16000 charts from FigureQA!\n", + "\n", + "--- Parsing ChartQA (val) ---\n", + "✅ Extracted 946 Bar/Line charts. 🚫 Bouncer skipped 110 Pie charts!\n", + "\n", + "--- Parsing PlotQA (val) ---\n", + "✅ Successfully extracted 33650 charts from PlotQA!\n", + "\n", + "--- Finishing Up VAL ---\n", + "Saving 50596 total charts to master_dataset_val.jsonl...\n", + "✅ VAL Dataset Created Successfully!\n" + ] + } + ], + "source": [ + "import json\n", + "import os\n", + "import pandas as pd\n", + "import torch\n", + "from PIL import Image\n", + "from transformers import CLIPProcessor, CLIPModel\n", + "\n", + "print(\"🚀 Loading CLIP Bouncer Model...\")\n", + "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "clip_model = CLIPModel.from_pretrained(\"openai/clip-vit-base-patch32\").to(device)\n", + "clip_processor = CLIPProcessor.from_pretrained(\"openai/clip-vit-base-patch32\")\n", + "\n", + "def is_pie_chart(image_path):\n", + " \"\"\"Uses CLIP to instantly detect if an image is a pie chart.\"\"\"\n", + " try:\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + " labels = [\"a photo of a pie chart\", \"a photo of a bar chart, line chart, or scatter plot\"]\n", + " inputs = clip_processor(text=labels, images=image, return_tensors=\"pt\", padding=True).to(device)\n", + " \n", + " with torch.no_grad():\n", + " outputs = clip_model(**inputs)\n", + " probs = outputs.logits_per_image.softmax(dim=1).cpu().numpy()[0]\n", + " \n", + " return probs[0] > probs[1] # Returns True if it thinks it's a pie chart\n", + " except Exception:\n", + " return False # If image is corrupted, just let the next steps handle/skip it\n", + "\n", + "def process_dataset_split(split_name, figureqa_folder_name):\n", + " print(f\"\\n{'='*50}\")\n", + " print(f\"🔥 STARTING SPLIT: {split_name.upper()}\")\n", + " print(f\"{'='*50}\")\n", + "\n", + " # --- 1. CONFIGURATION PATHS ---\n", + " # Adapting paths based on the split name!\n", + " figureqa_dir = f\"./../FigureQA_Dataset/{figureqa_folder_name}\"\n", + " chartqa_dir = f\"./../ChartQA_Dataset/{split_name}\"\n", + " plotqa_dir = f\"./../PlotQA_Dataset/{split_name}\"\n", + "\n", + " master_dataset = []\n", + "\n", + " # --- 2. PARSE FIGUREQA ---\n", + " print(f\"\\n--- Parsing FigureQA ({split_name}) ---\")\n", + " if not os.path.exists(figureqa_dir):\n", + " print(f\"❌ ERROR: Could not find folder -> {figureqa_dir}\")\n", + " else:\n", + " anno_path = os.path.join(figureqa_dir, 'annotations.json')\n", + " if not os.path.exists(anno_path):\n", + " print(f\"❌ ERROR: Found folder, but no annotations.json -> {anno_path}\")\n", + " else:\n", + " with open(anno_path, 'r') as f:\n", + " figureqa_data = json.load(f)\n", + " \n", + " found_count = 0\n", + " for item in figureqa_data:\n", + " img_path = os.path.join(figureqa_dir, \"png\", f\"{item['image_index']}.png\")\n", + " if not os.path.exists(img_path): continue\n", + " \n", + " if item['type'] in ['vbar_categorical', 'hbar_categorical', 'line', 'dot_line']:\n", + " markdown_str = \"TITLE | Unknown <0x0A> X_Label | Y_Label\"\n", + " for model in item['models']:\n", + " x_values = model.get('x', [])\n", + " y_values = model.get('y', [])\n", + " if not isinstance(x_values, list): x_values = [x_values]\n", + " if not isinstance(y_values, list): y_values = [y_values]\n", + " for i in range(min(len(x_values), len(y_values))):\n", + " try:\n", + " y_val = round(float(y_values[i]), 2)\n", + " except (TypeError, ValueError):\n", + " y_val = y_values[i]\n", + " markdown_str += f\" <0x0A> {x_values[i]} | {y_val}\"\n", + " \n", + " master_dataset.append({\"image_path\": img_path, \"target_text\": markdown_str})\n", + " found_count += 1\n", + " print(f\"✅ Successfully extracted {found_count} charts from FigureQA!\")\n", + "\n", + " # --- 3. PARSE CHARTQA ---\n", + " print(f\"\\n--- Parsing ChartQA ({split_name}) ---\")\n", + " if not os.path.exists(chartqa_dir):\n", + " print(f\"❌ ERROR: Could not find folder -> {chartqa_dir}\")\n", + " else:\n", + " chartqa_img_dir = os.path.join(chartqa_dir, \"png\")\n", + " chartqa_csv_dir = os.path.join(chartqa_dir, \"tables\")\n", + " \n", + " if not os.path.exists(chartqa_img_dir) or not os.path.exists(chartqa_csv_dir):\n", + " print(f\"❌ ERROR: Missing 'png' or 'tables' subfolder inside {chartqa_dir}\")\n", + " else:\n", + " found_count = 0\n", + " skipped_pies = 0\n", + " for img_file in os.listdir(chartqa_img_dir):\n", + " if img_file.endswith(\".png\"):\n", + " base_name = img_file.replace(\".png\", \"\")\n", + " img_path = os.path.join(chartqa_img_dir, img_file)\n", + " csv_path = os.path.join(chartqa_csv_dir, f\"{base_name}.csv\")\n", + " \n", + " if os.path.exists(csv_path):\n", + " # ⚡ THE BOUNCER: Check if it's a Pie Chart!\n", + " if is_pie_chart(img_path):\n", + " skipped_pies += 1\n", + " continue\n", + " \n", + " try:\n", + " df = pd.read_csv(csv_path)\n", + " headers = \" | \".join(df.columns)\n", + " markdown_str = f\"TITLE | Unknown <0x0A> {headers}\"\n", + " for index, row in df.iterrows():\n", + " row_str = \" | \".join([str(val) for val in row.values])\n", + " markdown_str += f\" <0x0A> {row_str}\"\n", + " \n", + " master_dataset.append({\"image_path\": img_path, \"target_text\": markdown_str})\n", + " found_count += 1\n", + " except Exception:\n", + " pass # Skip corrupted CSVs\n", + " print(f\"✅ Extracted {found_count} Bar/Line charts. 🚫 Bouncer skipped {skipped_pies} Pie charts!\")\n", + "\n", + " # --- 4. PARSE PLOTQA ---\n", + " print(f\"\\n--- Parsing PlotQA ({split_name}) ---\")\n", + " if not os.path.exists(plotqa_dir):\n", + " print(f\"❌ ERROR: Could not find folder -> {plotqa_dir}\")\n", + " else:\n", + " anno_path = os.path.join(plotqa_dir, 'annotations.json')\n", + " if not os.path.exists(anno_path):\n", + " print(f\"❌ ERROR: Found folder, but no annotations.json -> {anno_path}\")\n", + " else:\n", + " with open(anno_path, 'r') as f:\n", + " plotqa_data = json.load(f)\n", + "\n", + " found_count = 0\n", + " for item in plotqa_data:\n", + " img_path = os.path.join(plotqa_dir, \"png\", f\"{item['image_index']}.png\")\n", + " if not os.path.exists(img_path): continue\n", + " \n", + " if item['type'] in ['vbar_categorical', 'hbar_categorical', 'line', 'dot_line']:\n", + " markdown_str = \"TITLE | Unknown <0x0A> X_Label | Y_Label\"\n", + " for model in item['models']:\n", + " x_values = model.get('x', [])\n", + " y_values = model.get('y', [])\n", + " if not isinstance(x_values, list): x_values = [x_values]\n", + " if not isinstance(y_values, list): y_values = [y_values]\n", + " for i in range(min(len(x_values), len(y_values))):\n", + " try:\n", + " y_val = round(float(y_values[i]), 2)\n", + " except (TypeError, ValueError):\n", + " y_val = y_values[i]\n", + " markdown_str += f\" <0x0A> {x_values[i]} | {y_val}\"\n", + " \n", + " master_dataset.append({\"image_path\": img_path, \"target_text\": markdown_str})\n", + " found_count += 1\n", + " print(f\"✅ Successfully extracted {found_count} charts from PlotQA!\")\n", + "\n", + " # --- 5. SAVE JSONL ---\n", + " print(f\"\\n--- Finishing Up {split_name.upper()} ---\")\n", + " output_file = f\"master_dataset_{split_name}.jsonl\"\n", + " print(f\"Saving {len(master_dataset)} total charts to {output_file}...\")\n", + "\n", + " with open(output_file, 'w') as f:\n", + " for entry in master_dataset:\n", + " f.write(json.dumps(entry) + '\\n')\n", + "\n", + " if len(master_dataset) > 0:\n", + " print(f\"✅ {split_name.upper()} Dataset Created Successfully!\")\n", + " else:\n", + " print(f\"⚠️ {split_name.upper()} Dataset is empty.\")\n", + "\n", + "\n", + "# ==========================================\n", + "# EXECUTE FOR BOTH SPLITS\n", + "# (FigureQA uses 'train1' and 'val1' for folder names)\n", + "# ==========================================\n", + "# process_dataset_split(split_name=\"train\", figureqa_folder_name=\"train1\")\n", + "process_dataset_split(split_name=\"val\", figureqa_folder_name=\"validation1\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "73b5fc42-cd3b-438c-9e6e-4bf09cbd37a9", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"OMP_NUM_THREADS\"] = \"2\" # Limits CPU core usage\n", + "os.environ[\"PYTORCH_MPS_HIGH_WATERMARK_RATIO\"] = \"0.0\" # Prevents RAM hoarding\n", + "import time # We need this for the cool-down hack" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2ca01c82-ba2a-481a-9b76-480c3b0bfdb3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing FigureQA (train)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100000/100000 [00:19<00:00, 5065.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing FigureQA (val)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20000/20000 [00:03<00:00, 5163.74it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing PlotQA (train)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████| 157070/157070 [00:07<00:00, 19863.95it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing PlotQA (val)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 33650/33650 [00:13<00:00, 2467.82it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ Clean Train & Val datasets generated! Formatting and geometric bugs eliminated.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "import json\n", + "import os\n", + "import shutil\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "\n", + "# Define datasets and their splits\n", + "dataset_configs = [\n", + " {\"name\": \"FigureQA\", \"base\": \"./../FigureQA_Dataset/train1\", \"split\": \"train\"},\n", + " {\"name\": \"FigureQA\", \"base\": \"./../FigureQA_Dataset/validation1\", \"split\": \"val\"},\n", + " {\"name\": \"PlotQA\", \"base\": \"./../PlotQA_Dataset/train\", \"split\": \"train\"},\n", + " {\"name\": \"PlotQA\", \"base\": \"./../PlotQA_Dataset/val\", \"split\": \"val\"}\n", + "]\n", + "\n", + "CLASS_BAR = 0 \n", + "\n", + "def process_and_copy(img_path, bboxes, split, chart_type):\n", + " out_img_dir = f\"./datasets/yolo_dataset_bar/images/{split}\"\n", + " out_lab_dir = f\"./datasets/yolo_dataset_bar/labels/{split}\"\n", + " os.makedirs(out_img_dir, exist_ok=True)\n", + " os.makedirs(out_lab_dir, exist_ok=True)\n", + "\n", + " if not os.path.exists(img_path): return\n", + " \n", + " try:\n", + " with Image.open(img_path) as img:\n", + " w_img, h_img = img.size\n", + " \n", + " yolo_lines = []\n", + " for box in bboxes:\n", + " # --- 1. THE FORMAT FIX ---\n", + " if isinstance(box, dict):\n", + " # FigureQA format gives us exact width and height\n", + " x, y, w, h = box['x'], box['y'], box['w'], box['h']\n", + " else:\n", + " # PlotQA format gives us [x_min, y_min, x_max, y_max]\n", + " x1, y1, x2, y2 = box\n", + " x = x1\n", + " y = y1\n", + " w = x2 - x1 # Calculate the true width!\n", + " h = y2 - y1 # Calculate the true height!\n", + " \n", + " # --- 2. THE GEOMETRIC FLIP FIX ---\n", + " if chart_type == 'vbar_categorical' and w > h:\n", + " w, h = h, w\n", + " elif chart_type == 'hbar_categorical' and h > w:\n", + " w, h = h, w\n", + " \n", + " # Normalize to YOLO format (0-1)\n", + " cx, cy = (x + w/2) / w_img, (y + h/2) / h_img\n", + " nw, nh = w / w_img, h / h_img\n", + " yolo_lines.append(f\"{CLASS_BAR} {cx:.6f} {cy:.6f} {nw:.6f} {nh:.6f}\")\n", + "\n", + " # Save files only if we found valid boxes\n", + " if yolo_lines:\n", + " base_name = os.path.basename(img_path)\n", + " shutil.copy(img_path, os.path.join(out_img_dir, base_name))\n", + " \n", + " txt_filename = base_name.rsplit('.', 1)[0] + \".txt\"\n", + " with open(os.path.join(out_lab_dir, txt_filename), 'w') as f:\n", + " f.write(\"\\n\".join(yolo_lines))\n", + " \n", + " except Exception as e:\n", + " pass\n", + "\n", + "# Execute Strict Extraction for all configs\n", + "for config in dataset_configs:\n", + " print(f\"\\nProcessing {config['name']} ({config['split']})...\")\n", + " anno_path = os.path.join(config['base'], \"annotations.json\")\n", + " \n", + " if os.path.exists(anno_path):\n", + " with open(anno_path, 'r') as f:\n", + " data = json.load(f)\n", + " \n", + " for item in tqdm(data):\n", + " # STRICT FILTER: Only vbar and hbar\n", + " if item['type'] in ['vbar_categorical', 'hbar_categorical']:\n", + " img_path = os.path.join(config['base'], \"png\", f\"{item['image_index']}.png\")\n", + " all_boxes = []\n", + " \n", + " for model in item['models']:\n", + " if 'bboxes' in model: \n", + " all_boxes.extend(model['bboxes'])\n", + " \n", + " # Pass the chart_type to the function so it knows how to orient the boxes\n", + " process_and_copy(img_path, all_boxes, config['split'], item['type'])\n", + "\n", + "print(\"\\n✅ Clean Train & Val datasets generated! Formatting and geometric bugs eliminated.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "da861ac5-fef2-4586-8736-ff371378b4f2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing FigureQA (train)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100000/100000 [00:20<00:00, 4815.88it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing FigureQA (val)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20000/20000 [00:03<00:00, 5107.04it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing PlotQA (train)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████| 157070/157070 [00:01<00:00, 148725.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing PlotQA (val)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████| 33650/33650 [00:02<00:00, 13894.84it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ Pristine Dataset Generated! Corrupted PlotQA attached bars have been quarantined.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "import json\n", + "import os\n", + "import shutil\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "\n", + "dataset_configs = [\n", + " {\"name\": \"FigureQA\", \"base\": \"./../FigureQA_Dataset/train1\", \"split\": \"train\"},\n", + " {\"name\": \"FigureQA\", \"base\": \"./../FigureQA_Dataset/validation1\", \"split\": \"val\"},\n", + " {\"name\": \"PlotQA\", \"base\": \"./../PlotQA_Dataset/train\", \"split\": \"train\"},\n", + " {\"name\": \"PlotQA\", \"base\": \"./../PlotQA_Dataset/val\", \"split\": \"val\"}\n", + "]\n", + "\n", + "CLASS_BAR = 0 \n", + "\n", + "def process_and_copy(img_path, bboxes, split):\n", + " out_img_dir = f\"./datasets/yolo_dataset_bar/images/{split}\"\n", + " out_lab_dir = f\"./datasets/yolo_dataset_bar/labels/{split}\"\n", + " os.makedirs(out_img_dir, exist_ok=True)\n", + " os.makedirs(out_lab_dir, exist_ok=True)\n", + "\n", + " if not os.path.exists(img_path): return\n", + " \n", + " try:\n", + " with Image.open(img_path) as img:\n", + " w_img, h_img = img.size\n", + " \n", + " yolo_lines = []\n", + " for box in bboxes:\n", + " # Reverted to pure, original extraction. No bad math.\n", + " if isinstance(box, dict):\n", + " x, y, w, h = box['x'], box['y'], box['w'], box['h']\n", + " else:\n", + " x, y, w, h = box \n", + " \n", + " # Normalize to YOLO format (0-1)\n", + " cx, cy = (x + w/2) / w_img, (y + h/2) / h_img\n", + " nw, nh = w / w_img, h / h_img\n", + " yolo_lines.append(f\"{CLASS_BAR} {cx:.6f} {cy:.6f} {nw:.6f} {nh:.6f}\")\n", + "\n", + " if yolo_lines:\n", + " base_name = os.path.basename(img_path)\n", + " shutil.copy(img_path, os.path.join(out_img_dir, base_name))\n", + " \n", + " txt_filename = base_name.rsplit('.', 1)[0] + \".txt\"\n", + " with open(os.path.join(out_lab_dir, txt_filename), 'w') as f:\n", + " f.write(\"\\n\".join(yolo_lines))\n", + " \n", + " except Exception as e:\n", + " pass\n", + "\n", + "# Execute Extraction with Quarantine\n", + "for config in dataset_configs:\n", + " print(f\"\\nProcessing {config['name']} ({config['split']})...\")\n", + " anno_path = os.path.join(config['base'], \"annotations.json\")\n", + " is_plotqa = \"PlotQA\" in config['name']\n", + " \n", + " if os.path.exists(anno_path):\n", + " with open(anno_path, 'r') as f:\n", + " data = json.load(f)\n", + " \n", + " for item in tqdm(data):\n", + " if item['type'] in ['vbar_categorical', 'hbar_categorical']:\n", + " \n", + " # --- THE PLOTQA QUARANTINE FILTER ---\n", + " # PlotQA grouped charts (attached bars) have corrupted coordinates.\n", + " # We skip them entirely. FigureQA grouped charts are kept.\n", + " if is_plotqa and len(item['models']) > 1:\n", + " continue \n", + " # ------------------------------------\n", + " \n", + " img_path = os.path.join(config['base'], \"png\", f\"{item['image_index']}.png\")\n", + " all_boxes = []\n", + " \n", + " for model in item['models']:\n", + " if 'bboxes' in model: \n", + " all_boxes.extend(model['bboxes'])\n", + " \n", + " process_and_copy(img_path, all_boxes, config['split'])\n", + "\n", + "print(\"\\n✅ Pristine Dataset Generated! Corrupted PlotQA attached bars have been quarantined.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "66821954-31d7-40db-a2b1-53b8124d6c6e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApcAAAKSCAYAAACHofAiAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAtsdJREFUeJztvQeYXGd5t/+stOq99967ZFm2LFtyl4tcccPGNGNjIAkfhISQ8E8gfPkCF5BAQgkQwBgwBveKJVuyZVuWbEtWsXrvvXetpN39X/djP8toNLs7szva3dn93dd1NJoz57znPe+cnbnned73PXnFxcXFJoQQQgghRBaol41ChBBCCCGEkFwKIYQQQoisosilEEIIIYTIGpJLIYQQQgiRNSSXQgghhBAia0guhRBCCCFE1pBcCiGEEEKIrCG5FEIIIYQQWUNyKYQQQgghsobkUghR5Xzzm9+0vLw8tbwQQtRCJJdC1CEQunSWmTNnVvpYx44dc4nMRllVzYEDB6xjx47eFk888cQZry1dutTuuOMO69u3rzVt2tTat29vkyZNsueffz5lWY899piNHz/eWrdube3atbNLL73UXnzxxbO2+3//7//ZTTfdZJ06dfLj0napWLlypX35y1+2CRMmWOPGjX3bDRs2ZOnMhRCi8uRnoQwhRI7wu9/97oznv/3tb+2VV145a/2QIUOyIpf/+q//6v+/7LLLznjt//v//j/72te+ZjWVf/mXf/H6p2Ljxo12+PBh++QnP2ldu3b17Z588kkXw5///Of22c9+tmTbH/3oR/bFL37RpkyZYt/5znfsxIkT9pvf/MZuuOEG3+cjH/nIGW3SuXNnGzNmjE2bNq3Uus2ZM8f++7//24YOHerv08KFC7N89kIIUUmKhRB1lr/6q78qPlcfA7t37/ayv/GNbxTnEosXLy7Oz88v/ta3vuX1f/zxx8vd5/Tp08WjRo0qHjRo0BnrBwwYUDxu3LjioqKiknUHDx4sbt68efFNN910xrbr169Pq9327t1bfOjQIf//9773Pd829hVCiJqA0uJCiDMoKiqyH/7whzZs2DBPu5KmffDBB23//v1nbDdv3jy75pprPC3cpEkT69Onj913333+GmnaDh06+P+JXka6PVK9qfpc8vyv//qv7ZlnnrHhw4dbo0aNvA5Tp0496x0i1X7++ed7/fr16+cRw1Rl7tmzx1asWFFqFDIV/+f//B+79dZbbeLEiWnvU79+fevRo4en0xM5dOhQSXo9aNmypTVv3tzbLJHevXunday2bdtaixYtrKJwHCKnL7/8so0ePdrbkCjoU089dcZ2RFip91tvvWV/+7d/6+9ns2bNvG1279591jVD+xPJpavA5ZdfbsuWLfNjfepTn6pwXYUQuYnS4kKIM0AkEYtPf/rTntJdv369/fjHP7YFCxa4aDRo0MB27dplkydPduEgvU1/QoQyBIX1//M//2Of//znXUYi/Tty5MgyW3vWrFlexhe+8AUXKNK/t912m23atMn7KwL1uPbaa61Lly4uroWFhfatb32rRGYTod5s89prr52Vmk/F448/brNnz7bly5eX24/x6NGjdvz4cTt48KA999xz9tJLL9ldd911xjYckz6bpMdvvPFGT4vzf/ZBYquL1atXe10/97nPeXr/oYce8n6kiPzVV199xrZ/8zd/Y23atLFvfOMb3ib88OBHwJ/+9KeSbf7xH//Rvvvd7/o58oNj0aJF/sj5CiHqINUdOhVC1Jy0+JtvvunPH3nkkTO2mzp16hnrn376aX8+d+7cUssuK73LuuSPH543bNiweM2aNSXrFi1a5Ot/9KMflay78cYbi5s2bVq8devWknWrV6/2VHZymXGc1157rdy2OHbsWHHPnj2L//Ef/9Gfs09ZafEHH3zQX2epV69e8e233168b9++M7bZuXNn8ZVXXlmyHUv79u2LZ8+enZXuBBVJi/fq1cv3efLJJ89I1Xfp0qV4zJgxJeseeugh3+6qq646I63/5S9/ubh+/frFBw4c8Oc7duzwtr/lllvOOM43v/lN3/+Tn/xk2nUTQtQOlBYXQpwRuWvVqpVHr0gpxzJ27FhP5RIBBCKV8MILL9ipU6ey1oJXXXWVp7kDIp2kkdetW+fPiVJOnz7dbrnlFk/BBv3797frrrvurPJI1eKt6UQtGXDDufzTP/1TWnX90pe+5IOhHn74YT82dTt58uQZ25AiHjRokEcHadtf//rXHnElkrtmzRqrLmg7IsoBbfyJT3zCo8I7duw4Y1sGKCWm9ekuwLkysAlmzJhhp0+f9mhzcsRTCFE3UVpcCHFGupSULf0EU0E6HJhOh3Q1Kecf/OAHLm8I3z333ON9JStKz549z1pHSjb6e3J8UtHIZDKp1qUL6d7vfe979pOf/MQlOh0GDx7sCyBmdBMgLfzOO++UyBip5vz8/DOmKbr55pttwIAB9vWvf/2M1HJVQlsl908dOHBgSVswar2094T3A+I9CclMbn/6hsa2Qoi6heRSCHHGwAzE8pFHHknZKtGvMeZ/fPvtt12cmDqHwTz/8R//4evSFbRUA2NS8UHW/NxOPdStWzeX5OhrGRE8Bq+wDsmqV6/0ZM/tt9/u/VVXrVrl0UqirfRh/MUvfnGWdF1yySXefzUXqK73RAiRu0guhRAlkJIm7XzxxRefNZo5FUwOzsIE4H/4wx/sYx/7mP3xj3+0+++//5zcgQfxZXRzqpRyZdLMDBhifyZGTybSvUTqojtAKoioApFf2Llzpz+SQk6G9Dup5OqCc0UOE98jpDiTUetBr169SspkxoBg7969Z80wIISoG6jPpRCihDvvvNNl6P/+3/97VqsgQzHVDtKQHLliWhsoKCgo6W8IydPzVDaKRr9Mpivatm1byXrEhtHayaQ7FdG//du/2dNPP33GEm3w1a9+1Z8zDU9i14BkWWRCeoScaX0iTUykk9R3Yltt2bLF3nzzTZ8s/Vyzdu1aX5Kh7TinxCmTqD/vYWJKPB2uvPJKT/0zO0DySH0hRN1EkUshRAn0pSS1++1vf9vv/EI/QqYeoi8mA1L+67/+y9O/DGL56U9/6oNCiHZyx5r//d//9YEh119/vZcVooVc0Z+PdDDzV7JUBgbpMEcj0VWmOkKGERnKTb5bTbpTEZGmTiailOPGjfP+pAHtg4xxy0dS6aTP6UaAxNItILoE0IWArgK//OUvXcAYxEM70W5EOZm+JxHukkT/xRDhN954w6UXPv7xj5dECImMMp0RRGqd86S+LEwTFHBcSJ5WiffjM5/5jM2dO9fnMWWgEZFWpiTKFPZnWiXOnbsUMU0UUxEh+8yBqnvIC1EHqe7h6kKImneHnl/84hfFY8eOLW7SpElxixYtikeMGFH81a9+tXjbtm3++vz584vvvvtun7qnUaNGxR07diy+4YYbiufNm3dGOUy5QzlMMZQ4vU5pUxFRn1RT5yRPZzNjxgyfNody+/XrV/zLX/6y+Ctf+Upx48aNKzwVUTKlTUX06KOP+vQ8nTp18il42rRp48+fffbZs8o4deqUT6M0evRovysPy+WXX1786quvnrXtpZdeesaURYlLYv2Zdqi07Wir5LZLtW7KlCnF06ZNKx45cqS/f4MHDz7rPGMqouTppqJdEuvEHYr++Z//ubhz585+zVxxxRXFy5cvL27Xrl3x5z73ubTbXAhRO8jjn+oWXCGEqCxEF5cuXepRVlE69Kkkyss0UucSukMwWpzoKyPjhRB1B/W5FELkHDF4JkAo//znP6c1n6U49+8HcCcf0HsiRN1DfS6FEDkHo7q5ZzWP9FNkMEnDhg198I2oeuhXyy1D6W9Ln1Nu4/noo496n136xgoh6haSSyFEzsGgEeSFwTRM2n7RRRfZv//7v/vk5KLq4U5KjBjn/uIMdopBPjEgSQhRt1CfSyGEEEIIkTXU51IIIYQQQmQNyaUQQgghhMgakkshhBBCCJE1JJdCCCGEECJrSC6FEEIIIUTWkFwKIYQQQoisIbkUQgghhBBZQ3IphBBCCCEkl0IIIYQQouahyKUQQgghhMgakkshhBBCCJE1JJdCCCGEECJrSC6FEEIIIUTWkFwKIYQQQoisIbkUQgghhBBZQ3IphBBCCCGyhuRSCCGEEEJkDcmlEEIIIYTIGpJLIYQQQgiRNSSXQgghhBAia0guhRBCCCFE1sjPXlFCiFxj586dtm3bNluxYoV16NDB+vfvb127drWGDRuWu+/Jkydt3bp1tmXLFtu1a5edOHHCWrZsae3bt7fx48db48aNq+QchBBC1Cwkl0LUUgoKCqywsNCX/Px8q1+/vjVo0MDy8vLOkMtFixbZn//8Zxs0aJBvh2Qil8XFxV5GUVFRyjJOnz5tGzdutLlz59rSpUtt79691q1bNxs4cKCNGTNGcimEEHUUyaUQtRDE8Mknn3TpW7lypZ133nk2ZMgQu+mmm1wQA4Rw1apVdvToUduzZ4+tXbvWRo8eXfL6n/70J49qrl692i644AIvY8qUKS6XTZo0scsuu8xlE/F84403qulshRBC1CQkl0LUUkhTI40HDx60Y8eOeRQymU6dOtmoUaNcFkmHE3VMTIkfP37cjhw5krIM9mnUqJFvj1wKIYQQoG8EIWph1JI0No8sQGqbhVQ26+rVq+eP3bt3txYtWljz5s2tY8eOnhpHGGN7ligjyqUMop/IZWKKvbS6xGNiWQH7U5d0yhJCCJEbSC6FqGXs2LHDZs2aZQsXLrStW7f6ujVr1vigG1Lkw4cPtx49etjhw4dt+fLltmzZMtu3b59HMYlcfuxjH/OI55w5c2zx4sXeLxNIjzP4h32Idvbt29dGjBhRbn0OHTpkmzZt8jpRB6KfRDqJeLZt29bT7O3atXPBFUIIkftoKiIhahlEHolCEpGMEdtNmzZ1kUMIkchWrVr582bNmnnkEAEk9c1ChJH92A7hozxgWySQMhj0U54MRrRyyZIltmDBApdTIp7s26dPHxdYpBeJRVpPnTp1VmRTCCFE7qHIpRC1DKRx0qRJPjiHfpK7d+/29DcRyzvuuOOMAT2kuRFKIouJIICUQZSSvpsM9unZs6eX8ZGPfMSFtDwQS4Rx6tSpLpGU8eCDD9qwYcNcUP/jP/7Dy6eeyGznzp1diIUQQuQ2ilwKIc4JSCtpeKKS+/fv93XMgUlUlRHmrVu39ggq8sqI9Xnz5rnsCiGEyG0UuRRCnBOYZP3AgQMujyGN27dv9ymMSLGTimcQD5FUIqwIqNLiQgiR+0guhRDnTC4RxsRoJJO1kwInrc40R6TN6bvJCHSmPBJCCJH7SC6FqKVkY2qfykwRxGjwNm3anNHHk5Hh3GISoYw7/xC1JJLJoKPEbYUQQuQmkkshailEB0PWYs5LhI5UNVFDJk1Pp4wYvBP7s3BnHyKTXbp0KVMu6VdJpJJ6IJIMNuIWkQzeAaYlYkAPA3kQTM11KYQQuY8G9AhRS2EKoZhGCLFDBun/+Oqrr9qvfvUrf55pGaSxKWPatGn28MMPlzkAh8E6AwYM8CmNWrZs6eu4FzkLIKmMZP/5z3/u0xExnybrhBBC5DaKXApRS2FCdKKN69atc3EjWknfRiKR/fr180nW33//fR+pzXoG2Kxfv95Fj9e5jzgL0USEkFHfzE1JtJF1vXr1svnz59uiRYv83uMxrRHHmz17tk83RDk33HCDRyfnzp3r2zGoh8e4SxD3PefOQEyXlM4UR0IIIWo2kkshaimknolOInj0a0TkmGuSCcyJJjKABqkkMkmqmtQ1KWzWsz2Q9iZSiSjGOqKN9JtkQnXu8oNUsh9yyJ13+D/rkVnKRFBJebMOQWU9dxHiNfpZMu8ldY3ophBCiNwmr1hzfwhRK0nsZ1naIJ3E+48nv564TTplsMS6VGUkHiuxb2XytkIIIXIbyaUQQgghhMga6uAkhBBCCCGyhuRSCCGEEEJkDcmlEEIIIYTIGpJLIYQQQgiRNSSXQgghhBAia0guhRBCCCFE1pBcCiGEEEKIrCG5FEIIIYQQWUNyKYQQQgghsobkUgghhBBCZA3JpRBCCCGEyBr52StKCFGdFBcX++PRo0dt27Zt1rFjR2vcuLHeFCGEEGmTl5dn9erVs/z8fP9/RZBcClGLKCwstI0bN9pDDz1kt912m/Xq1au6qySEECKHqF+/vjVo0MDatGlT4TIkl0LUMrncunWrPfHEEzZlyhRr27Ztpco7dOiQP7Zs2TJLNay9nDp1yg4fPuxtxS9+kX6btWjRwr/MRPmcPn3a/y7VZpm3WfPmza1hw4a6zMrhyJEj/l1SGfQJKEQtS40fO3bMo5d8OFQmLU5ZpERYGjVqVOH0SF0DSaK9RGZtpi4c6VFQUOCP/IBRm6XHyZMndZ1lAF2rioqKrDJoQI8QQgghhMgakkshhBBCCJE1JJdCCCGEECJrSC6FEEIIIUTWkFwKIYQQQoisodHiQoizOXHC7OBBq7dv3wejxCs5LcU5o3VrM43MFkKIGoXkUghxNlOnmn3qU9bmw7v+1NhpiJ5+2uzyy6u7FkIIIRKQXAoh/gIRyp//3OyNNyzv4EGroUr5Fx5+2GzdOrP77sOAq7s2QgghJJdCiLPk8r//22zlytxoGORy6VKzT39acimEEDUEDegRQgghhBBZQ2lxIUSZHLEOtsEurRGtROK7r023JnaguqsihBCiFCSXQogyOWB97HX7lw/Vrropsg62VHIphBA1GKXFhRBCCCFE1pBcCiGEEEKIrKG0uCih+MM5DTMlW3Mglnb88sovr96xf7rnl+75pCovk7ao7P5CCCFETURyKUooLCy0goICe+ONN2zDhg22YsUKGzRokLVt29ZOnjzpryFEffr0sX79+lmvXr2sXr3sBb+LiopswYIFtnbtWlu+fLldd9111r17d+vWrVu5+1I39n3//fdt5cqV1qNHDxs6dKhNnDjRmjZt6vU+cOCAbdq0yWbOnGkNGza09u3b26WXXmqvvPKKv/bggw9a/fr106or5S1evNjbad68eXb55Zd7u9Ammcjpww8/bI0aNbJLLrnEOnbsaI0bN05rXyGEEKKmorS4SCk9R48edcHjEeGKBbZu3eqStnnzZhfSrF6Q9erZsWPHvOxDhw7ZCW5DmMG+sG7dOtu2bZvXPTE6iPQhydu3b7dTp0759plGNZOPRznUFTk9fvx4RvtzTNqSunKeyLUQQgiR6yhyKUpAHonyTZgwwVq3bu0RvQsvvNCjf3D69Gk7ePCg/fKXv7QtW7Z4xO5zn/ucNW/ePGvHHzNmjB9n9erVlp+f/uVJ9O/888/3SOucOXM82kr0MspAIlu1amXt2rXzhahoz549PYI5ZcoUl8R0o5ZR3rBhwzzSOHfuXC9HCCGEEJJLkSRMZfUDRL5atGhh119/vafO58+f75LZuXNna9mypb399tsebSRF3aBBAy+LiByCSsqXdQgpaW9S1wMGDPCU98aNG23fvn125MgR+8IXvnBGNJT/E4F86aWXbO/evX58BLJTp06+L3WL+hFJRPKGDx/uxyZNzraIZ9SFyCX1YDsijYgoqXTk8jOf+YzLNee5f/9+j4CuX7/ej8nrnNfIkSNdTjt06FBy3OQ0ONtyLm+99ZbXiYVjIeFIO2XQTpS9a9cu3//NN9+0Nm3aeDtdcMEFLsXZ7HIghBBCVBWKXIq0QXYQs759+9p7773nUUykELFEwJA/pAmRQ96QrD179nj/zCZNmng0EcFjO8Q0yiOlTKp69+7dvk8iRDERNVLP7IdQUgbrk0HSEEMikpG6RwhJN/NapNmJYIb8Iq5IHql4xDP6PLIvZYT8UQ71YFvqiGCW1rfy8OHDfi6ku5FVzp19WU979O/f38tLPA+OT52yFQUWQgghqgvJpcgIhKpZs2YuaETaEDDEkugl0UREcvDgwb4tgkVEbtWqVS5pV199tQ9cIWJJlBPxooybbrrJZY5UOGUnShvShRTGAB3KKGvADBE/In/Tp0/3gTuIK2UieAzAQeaIpFJ/jk8UluMijRDC+Zvf/MZGjBhhl112mUc/o0vAt7/9bR+0w3kSEU0F4kx0ljYhdY6MU+7UqVPt+eeft4EDB/pAJbofvP766163yZMn+zrqJIQQQuQykkuREaWlgoGoH9FFJIrIJdE6RlOzPlK8iWnsxH6RiClihbBFeh7hJEqIwDIam4hk4v6p4DiMAidtTXQRyQNkENmlXl27di05TvK5EFGMCCNRULaNFDUSTXSROu3YscNfSwUizXGJTJIOJ70OpP85R8pHmqlnYh3KOzdYtmyZLV261PvDEmlNhDYjSkt7wXe/+12X2fHjx9vo0aNddssj79Qpa1FUZOn3Pq1+ThcW2uEDB2jEaq1HdOfguuf9FeUTg9j4QZfpgLi6SmKbZTLgsS6jNsuMGPBaGSSXIiMQGBa+SPmDDfHi/3yhkiYnHUw0DvnhA5BtU31xEFFEMBEqUussEIJFv0e+qJEzInvIXXmwL6llIqLIG31COQ5iSh0QRvo9lgYRSj6wOS7bEuGkTM4TSeaR80EQSxspz760A3VAtkM02B6JLq1vazpEX9BZs2aVKjDR1vQlJXJLP87evXt7W5fLqVPWvIJ1qy5oy5MFBfyyqPZ6xAez5itVm53r64zPqmzP1lFbUZtlBt/nkktR5X+kyBPSgkCRykXAWMecjTy///77fR3p7IULF7oMpZIpLt6yRoQjc5GCJ41Ov8s77rgjrXrSN5OIHWlnRJBIJgtlVQXI9aRJk1zqEEoIIee8MxmZngjnRNr/i1/8Yso2JfJKVPOuu+6yX/3qV3bFFVeUTCOV1ocF0dAK1q264BpCoKtbLvlRgvzz46W0LhPi7OuVzxG1WeZtxmeZ5sVNDwId/NAngMFnsygbrq/K/nBR5FKkDWJEVGz27NkubEwajjghgImTrJP6JX1M9IboWkUuUvZFGIj+EbGcMWOGp3tJLbO+vL6J7EffzmnTpvk+jNymz2Z5qWHS5hH5JDJAiptzjMgs54nMEBXlHFNBhBCR3blzp+8bAk0Ulb6dQ4YM8WPwIRejySk/RsxTB84v1fRGIYqpjk3bx4h5QHAy/iDNwTsE5UW9q7nuyV0cRMXaT6TfTmoz/W3WVDTXiTgr5Y1ARX8+HhFKxCoilkuWLHHxYtQz/Rr59Rwp8pionCgO+yChPGd70oVRNseJ6X3YlyXWsS3PETBkkKmFeE6fSaKgDKyJMkoDISUVzjb0n2QwD9IXUUSgTOoZEUXqgpwhdrEdfSvj3IlKxVygyGfUl/15ZKEc2oR6I5cxuToLcrxo0SKP6MaoeASQMjk2Iss+HEvpLiGEELmKIpeihOgbyShrBo4gT8xnyeAU5IfXkCekjegbo6iJjEWfRFKwTCn0gx/8wAfqsD/PY35KxArZCoFiOiPkkwnNSYshbYy0Rl4RMUaax+0nEVjKeuihh3zEOSPSmdy9tF/u1IfyRo0aVRLipw6JkTxk8dVXX/VoIuL61FNP+ehwyn7ggQe8DUgxM18m50//0RtvvNFT7tSHOTuZr5N6vfPOOy6iSCXzWDJC/Mknn/QoL+cZo+wRcvaPeiDO9FF98cUXvY4MErrtttsymkBeCCGEqEnoG0yUgACRUiWdTN+UuK83UhaRRyDli0SFWMb8kogS+yCQyCLrSZ0T+aNc0tmURdTv1ltv9UeifEQoI41OxJApgNiOMjgWkjhu3DgXtsR0fFkpIV4jCjl27Fg/fkRCE/dBEJE9RI5tqDvp7ujDx/myD8fn/ImW0ocyBvlEHdie9qK+tAnnwsIdgyBuMxl9SGkL1iHfjGKnDTg2zykncXS9EEIIkWtILsVZ/fm4BWOmIEPIZbqEeCWDvLFcdNFFZ6wnWpkpnAsDYEoD0eNcU50vAslCP83SYL5LFsQ3GQSRAT1lgXAit0IIIURtQuERIYQQQgiRNRS5FEKUSVPbbUPs6RrSSsXWxA5UdyWEEEKUgeRSCFEmbW29XWHfUCsJIYRIC6XFhRBCCCFE1pBcCiESPhHqmV15JSOucqNVGPh16aXVXQshhBAJSC6FEH+B+TV/8hOzr37VnzJNfY2+0/i//qvZ979f7bd+FEII8RfU51IIcTaXXWbFM2f63ZCYMqklc3vWxHYaMaK6ayCEECIJyaUQ4mw6dDCbNMlO7dnzwcTz7dpV+727hRBC5AbKJQkhhBBCiKwhuRRCCCGEEFlDcimEEEIIIbKG5FIIIYQQQmQNyaUQQgghhMgakkshhBBCCJE1JJdCCCGEECJrSC6FEEIIIUTWkFwKIYQQQoisIbkUQgghhBBZQ3IphBBCCCGyhuRSCCGEEEJkDcmlEEIIIYTIGpJLIYQQQgiRNSSXQgghhBAia0guhRBCCCFE1pBcCiGEEEKIrCG5FEIIIYQQWUNyKYQQQgghskZ+9ooSQtQ2GqxcaXb0qFmrVtVdlRpP3smT1uDQIcujrRo0qO7q5AT1Tp2yBgcPWj212dl07GjWt281vCtCVB7JpRAiJXnFxdbq7//e7J13LE9tVC4Nzay92ikjUHC1WSncf7/ZL36hK0rkJJJLIcTZzJlj9p//aXmrVpkVF6uF0kACnjlqszKYPt3sox81+973zHr00N+gyCnU51IIcTZbtpg98YTZvn1qHSGqg/XrzZ580uzgQbW/yDkkl0IIIYQQImsoLS6ESIvH7mhva/s1UWsJcY6YMPuQXfqGIpUi95FcCiHSYtYlreytSzRqXIhzRYvDhZJLUStQWlwIIYQQQmQNRS7rOCdOnLBDhw7ZihUr7PDhw3bs2DHr1auXtW/f3vr06WN5eWeO5zx58qQtXbrU8vPzrXHjxr4N/68JHDhwwA4ePGibNm2y4uJiq1evni+nT5+2goIC69ixo7Vp08Z69uxZ3VUVQgghai01wwpEtYF07d27195++23btm2b7dq1yy677DIbPHiwi2MyiNqyZcusUaNG1qpVKxe16pZLRLKwsNDPY+PGjbZgwQJf16BBA6tfv36JQPfr18/PSXIphBBCnDskl3WcFi1aWP/+/e2iiy6y9evX26JFi+ySSy5xEUsFUnn11Vd7RBCpROCqG6Kp1JsFuXzggQesZcuWXjcir0ePHnXx/P3vf+/RzUmTJlV3lYUQQohai+SyjoMkImANGzb0hUgfAsmSDCnzI0eO2JIlS1zcmjZtaiNGjChJRe/cudPXde/e3fbt2+fSR6Szb9++XvaWLVu8DKKKPXr0sHbt2nn0E9iWCOOGDRv8dcSV56TeO3Xq5NuVJrIhl0RhOXbr1q2tWbNmJRFVHlkGDBjg0kn527dvt/3799vmzZu9Hhwnzo8o6PDhw30d7UGdohzq1KRJE0+xJ9aJc2Nf6kJ7cgyWLl26WNu2bb2NduzY4Uvz5s29XLZjH8qlzr179/Z6CyGEELmM5FKkDSKElM2YMcPFi36ZpM+3bt1qM2fOtDlz5ljnzp3t8ssvt5UrV7pQsc+NN97oIvbGG2+4gBYVFdmll15qI0eOdNkDxG7Pnj02a9Ysfx3J4jniN2bMGD9eyGJiP1AEDql85513bPTo0TZq1CgX3MRUPaKM3E6YMKFkPVFa+pm+8sorLpIch+MhiQjkZz/7WRc+9qNOHIdyiYBy3tQJyaQ8Xlu9erXvS5Q05PLUqVMeEUYmabd3333Xux907dq1pE7ILeWQrkdCOUbyOQohhBC5hORSpA3yg+RdcMEFLllIHSCY3bp18wgfIoVIfuxjH/N+ji+//LLNmzfP973vvvt8HdG73/72t74tUU2gnyTSevPNN1uHDh184A0p7OXLl9vPf/5z+9KXvuTpeyJ+iRApROh2797tryG3RGNTQWQwOO+88zz6iBCyH/t87nOfK4loUoeFCxfa4sWLS+qEbPIafU5/9rOf2Ve+8hUXzTVr1tjatWtdCO+66y5/ZHDU008/batWrXLJvvDCC/24iCQiPGzYMLvlllu8DRkg9fDDD/s2nHeqqLEQQgiRK0guRfoXS36+R9sQJNLBIZeRPuZ1xAhBQrp4jmiyHcIVkTkik0gaEULgddLoRPFYT1msI5qJjPLItkQCk+WSCCHlkcqGxNd5LUbAI3jHjx/3upOSp57UhUeipNST+rE//0c2kVbqhOTynDpEWVEnyidyS/3ZlwFRwOuIL5Fb2of24tj0cY1HjkfdEVzOjXPmsSy5JPKLnBMppctBMuxPFwEgmszxGf1PtDSixOlQ/+RJa5j21kKIc0Hxh5+PxcePn/E3Dny+iPSIz0q1WXrwvVRZJJciq0SfSyQUoUI0kTzEBkFD5IhYIl98SPIaAoRUImZEMJGxAMEjYsiHAvskvpYKykv8P5FI+oMSbUQUibDefvvtHokMiGCyPgQYuaQ+fKhTp/nz558hfNSXOsVI+3Xr1nnklD/IqVOn+jb8n7oj2NQ74Bj0IWV/ZDT6uCKbtAcCTPuUBv1dp0+fbj/+8Y+9/LL493//d4/k3nPPPTZlyhQbNGiQpUvjo0etbdpbCyHOCcXF/gP79P79Z73E3395nwFCbVZRKjsLjORSZBXkKfmiDIkqD7a57rrrPOoZ2yNcRAgRQCJ+ySCxCCv7EL1E8ojSxYAZph1CsOhX+YMf/MCjjiG1AdJbWv1Yj5ghycl1QhIjUolQI6aMpI8+l/xa5v+UnzgYifZJPl5pqfxkxo0bZwMHDnRBTvXrEgmn7+vf//3f249+9CO7+OKLvV7IbHlifkZ9WrRIe1shxDkiL++DH+jt25es4vOHzzF+sPP5J8qHz2IyUPyIV7ej8uEHTWWjl5JLUS58mDEHJoJS3q8ZZCqWeJ74mArEiz945AeB5EMzRk1zkUdaOtWxWc8HLBKJ0BGdHDp0aEk/Ssqj3IgG8iETI7mT65z4POoU+yfWiQ/2qBPb8BoRR54jwewfqf9UqetUx4vnifVKBcdiIbWfTAxuQrCBSCWDnCpEDZkYX4i6DJ8KDfhbTJDI+IzgM05yWbGuXaJssjGgVLd/FOUSg1MYXR39JLN5ESNLRNdIVZPCjmggkUhGdf/617/2foaliRfyd9VVV/nrjOymvtEvKXGSdYSvPHlLrhMRUebODGGjHAbvUCfqSTcAIonIZtwZCJC89957z5f3338/pWQKIYQQtRGFJ+o4McE4AkTUD4l67bXXfJR0QJ9BRoITHSSSx4ARonekYBFOZCwijAgcfQKZqod1lENUD1GjDMpnAAuSxnRFr7/+uqduSVtTNuuQNEZQI2j80rzmmmt8/9J+TRFlZL5N9mdeSfo9xuAiHhFNzpOR6aTIEcboixlTD1EvIrO8HnNvMq0REU/OkW05F86ZMq+99lpPVxHNpO5MY4Rs/ulPf/J6EMWkPRhJzyh1/k/fTNqO9ubXM6PMaUfOmbZiqiKeT548uSStL4QQQuQakss6TkT1kB2idfRXRGpiJDjwOkJGhJDXkKcYpR0LAsegGIQuooQIFnIWA1ZYj5yxL9MK8Voch3kmkTYEl30RPrYlMsi2HLM02ULEED36PXJMBC7qgHjGBO2MmkY+o/6UR7SUenD+sU8cJ0a8I5ZAXSkLoeQORjEKHPGN22AimTEpPeVSL84NoeR1zifmzCSaSbtFWj+xL1DUTwghhMg18orTyROKWkvy6GpIJTXJspNq23TXlXes0ihv24pcyqnqkW7/x0y3Le14sT55XaZyGX0uidzeeuutPkE83QUqxOOPm9155xmrvvhf/eytSz6I6gohss+nf73D/von2/6ygv6WCxaYDR9esipmqeCHa6pBjuJsCArww19tlh5cXwRbCL5UNMihyGUdJ5VUlbddadumu668Y1WUipSZyTln49hV2R5CCCFEdaABPUIIIYQQImtILoUQQgghRNZQWlwIkRa3PbnHLppzSK0lxDli6LK/3M1LiFxGcimESItL3ziolhJCCFEuSosLIYQQQoisIbkUQpzNkCFmX/+6Wbduah0hqoMxY8z+6Z/MOnRQ+4ucQ2lxIcTZDB9uxd/6ltmsWWYHDmiqpDTwe9Z/eD9oTS2VQZt9OMer2iyJiy82+9d/1aeTyEkkl0KI1OTl2b6f/czyTp2yNtx+U+1UJgUnTvhtPrljE3ddEuVzsqDA9u/f75NbJ96hSphZ06ZqBpGzSC6FEKVS1K7dBxGldu1cNkUZnDhhRdxalLaSKKVFMW3WuLEVt21r1rixLi8hagnqcymEEEIIIbKG5FIIIYQQQmQNyaUQQgghhMgakkshhBBCCJE1JJdCCCGEECJrSC6FEEIIIUTWkFwKIYQQQoisIbkUQgghhBBZQ3IphBBCCCGyhuRSCCGEEEJkDcmlEEIIIYTIGpJLIYQQQgiRNSSXQgghhBAia0guhRBCCCFE1pBcCiGEEEKIrCG5FEIIIYQQWUNyKYQQQgghskZ+9ooSQtQ28goKLK+42OzYsequSs2HtqKdmjQxO306u2XXq2fWuLFZXl52yxVCiHOA5FIIkZriYmvz+c+bLVjwgdyIMmlkZh0KC61+/frZb6lRo8yefVZyKYTICSSXQoizWb/e8l591eovW2a2dataKA3yzuUHKsL661+bXX65Wb9+ej+EEDUahSOEEGczb57Z/febrVun1qkJbNhg9sADZu++W901EUKIcpFcCiGEEEKIrKG0uBAiLd6+0GxnJzVWVdFht9mEOWpvIUTuIbkUQqTF//1nsz9PUWNVFZOnmU299oO+nEIIkUsoLS6EEEIIIbKGIpei1lBQUGAnTpyww4cPW3FxseXl5flSVFRkhYWF1rRpU2vcuLG1bNmyuqsqhBBC1Fokl6LWsHPnTtu4caPNmjXL5bJBgwZWr149l85Dhw7Z8OHDrW/fvjZhwoTqrqoQQghRa5Fcipzn1KlTtmbNGlu6dKnL5VVXXeVRyoYNG3rk8tixY7Zv3z5766237OTJk5JLIYQQ4hwiuRS1Qi7Xrl1rO3bscJEkOknqm8glHD9+3Pbv329z5szxbYlqsh2ieeTIEU+Vc1eV06dPl7zepk0by8/PdzklzQ5EQdmG9U2aNHF5ZR0cPXrU9yUFH1AOktuoUSM/FvXguNQrUvbswyPbNG/evKTOQgghRK4iuRQ5D9L2/PPP24gRI+yKK66wFi1auAAGyGOXLl3slltuKZG3BQsW2MqVK23GjBmeLm/Xrp2n1bdu3er9Nj/72c9a27ZtXfpeeumlElHcs2ePdezY0caOHWv9+vXzdTBv3jzbsmWLp9+RRUBEScEPHTrUI6tz5861t99+27p37+5iitBu3rzZy+jfv79NmTLFOnfuXE2tKIQQQmQHyaXIaYj8RWSSKCKSyGMIHvB/5BDBjEgjModorlixomS766+/3rZt2+aRylatWtn69etd/gYNGuSRUBaOQ4T0hRdesHvvvdcHCm3fvt2llL6dkyZN8uNRJ9Lw7A89evSwAQMGeIST1H3v3r1dPDkWUkpUlecIbUQ2hRBCiFxEcilyGuQOwSTdjJA1a9asRMwQSqKHsQ3wGs87derkj8goEUSEbsyYMR5VPHDggEcsd+/e7RHO888/36OVrVu39qjo3r177f333/coJftt2rTJI5r8H4nkGLxGipz1QHQUuUVOSeFTDpFWtiGi+fjjj7t4Ut+yUuNEVVlI53N+ifCc9Hsck/ojvbQJ0dtMUu55RUWap6wGwvVSXFhotYXoRhIzOgi1ma6z6if5u6UiSC5Frf2j4P8RfSRCiWh17drVbr31Vmvfvn3Jdghlt27dXAqRSF5DAok+su/MmTNdzgLEESnldaKYS5Ys8eglX46/+93vfBv+f/DgQf8/ohr1InKKgHbo0MGlloX+m4grkU8Ek+elQVr91VdftZ/97Ge+bSriS/q+++7z873zzjvt2muvtYEDB6bdjo0PHrQ2aW8tqgquqRO7dtWaBo+/C37QKVqfWZtxLfBZJNRm5+IaS+xaVhEklyKn4Q8AeSMSSPSDD1yECviyQgKJ2PH6hg0b/PXkgTcIXvwhIX8xR2aUMXLkSE+JR0o9pjbiOBGhZAAQEcJx48aVpOGJMNK3MgYMJdaZ54nHiLLL+8VIOv3yyy/384lobCJEPlevXm2///3v7Z577rFRo0bZsGHDfD8GDKXdrmUIrqg+uJbyM3gfazpcr/xI4wdVZb/M6gr8eCRTozbLvM0yzeDUVY4fP17pMvTXLGqFXNJXEckjZc0HScgbcslrvXr1sieeeML/aHg9UeIQu5A7iJHcLJTPgBwijfGhhNQRNUTW+HLkWPTRJOpJCj2kke14nWMlyiX/Tz5eJnIZgpkM+yK+U6dOdbm8++67fVqmCpEQqRU1B49qt2hhtQV+gIVcJmYHROnwNx6iVFaWQ/wFuguFkKvN0muvynZT0e0fRc7DaGtGgiNXL7/8skcTE6N60ffS+6ul0ZcE2SNNjSwyeps+kqS9gT+45cuX23/+53/6OqKV9KdkHk22i/L50mQydwb1vPvuu358IYQQoi6gyKXIeYguMrclv7b4P4NtYh7KmL8S2SP6SPqaiCPpcaYeom8lfTERT6KbRCDZl0giz0lzM5qbX71si7TSP6xPnz4eMWVbIomMAGfkN4NzOG4M5mHgEJJKpJMBNvTh5JFo6q5duzxqwwh1HukfSnSUeoL6oAkhhMhFJJci50HImHOSR/pGzp4929cjeSykkRhdzfRDDKYhKsm8k0glwkg0ErlDGJHTmLuSMtn2ySef9G0RSCQVYRw/frz3e2RbtkNA6dP5+uuvezQT8YTBgwf7cRFZFrZBQpFcpBIBZV+klb6SSC2j1hP7ZAohhBC5hORS1BqY6oeoH2lqiH6TpKqJJCKfyCPCyZyTRBwvvPBCF7oYtZ3Y2Tvk8f777z9jsA/bIo+JAxAuuOACO++88zxKmjjPZmxHep3+j5dccklJXTgeYkt09KabbvJ6RR2FEEKIXEXfYqLWgJiFtJVHRDWJMpZGDPQhylge5R0TYWQp7Xik44UQQojagAb0CCGEEEKIrCG5FEIIIYQQWUNpcSFEWpw/z6xIP0erjLHvVd2xhBAim0guhRBp8a/fVEMJIYQoH8UhhBBCCCFE1pBcCiHOpm1bswsvNKtF97HOaZhlgPejXbvqrokQQpSL5FIIcTZXXGH21ltmw4apdWoCQ4Z88H5cfXV110QIIcpFfS6FEGfD5PP16tnhr33N8vbts+YtWpjuF1Q2J0+d8jtBMfl+g2xPhM9cq/Xq+fsihBA1HcmlEKJUCi6+2O821Jx0rMSmTIpOnLAT+/ZZM9rqw9t/CiFEXURpcSGEEEIIkTUkl0IIIYQQImtILoUQQgghRNaQXAohhBBCiKwhuRRCCCGEEFlDcimEEEIIIbKG5FIIIYQQQmQNyaUQQgghhMgakkshhBBCCJE1JJdCCCGEECJrSC6FEEIIIUTWkFwKIYQQQoisIbkUQgghhBBZQ3IphBBCCCGyhuRSCCGEEEJkDcmlEEIIIYTIGpJLIYQQQgiRNSSXQgghhBAia+RnryghRG2jxfe/b3lr15o1alTdVanxNCgstNYnT1o+bVVPv9vTarOiImtdUGANGjY0q1/fag3jx5v9zd9Udy2EqDYkl0KIszl82PK2b7fG06aZLVqkFkoD1KipWiojam2bHTxodu21Zj16mDVuXN21EaLK0c9rIcTZvPyy2YgRZu+/r9YRIlNeesls5EizxYvVdqJOosilEOJsiorMTp5UywhR0b+fgoIPHoWog0guhRBpcaCRWYE+MYRISdNTZi30e0wIR18VQoi0+OxNZi/3U2MJkYoH3jP73itqGyEkl0KItDnawOygxiYIkZLjDdQwQgSKXIqzKC4utqKiIjt9+rT/H+rXr+9LvQ+nWDl16pQVFhZagwYNLC8vz5fYj/XAtvn5H1xivJ4K9uE47MfSqFGjkvIyhf0pL46ffBzqw8J5CCGEEOLcILkUZ0nYoUOHbOvWrfbMM8/Yrl27XMguv/xyGzFihPXu3du3mzZtms2YMcPuuece6969u3Xu3Nl2795tq1atsldffdWaN29uvXr1sptvvtllrjRZLCgosGeffdZWrFhhGzZssO9+97vWrl27Csnl9u3bbcuWLTZ37lwXTcSXunOMI0eO2ODBg61nz552/vnn610XQgghzhGSS3EWSFmzZs1cxLZt22bHjx+3Dh06WNOmTV3ajh49avv373eZROhatGjhctm4cWNryGTIZtatWzfr2rWry11ZosjrPXr0sPXr19u+ffu8/EwhUkld1q5daxs3bvRjcw7UhWNT/wMHDrh4guRSCCGEOHdILsUZIGNIZJcuXezKK6+01atXu0AOHz7c5RH527Nnj0cCT548aZs2bSqJNLZq1cratm1rHTt2tIkTJ/oj8hjp8kidQ6TXEcAJEybY5s2b7Z133ilJj8d2iduWJqmk6ImYvv/++17O3/3d33ldQnSR4b1799pPf/pT3xZCYqNeQWL9Yn1sG/VPTNsnb5NY73g9tklsh2Riu4pEbIUQQoiahORSpITIH9FKxJGoH5JJhJF09/Lly61NmzZ29dVXezqbqGWAQCFwyBkRRUSUNDVRSfY9fPiwv3bhhRdap06dvJyA7efMmeOCxfYIIdtcdNFFfuwmTZqkrOuxY8fsueee85Q9QkwklfoH7Ecdb731Vu/TSR0XLFhg69at8+MNHDjQWrdu7XXduXOnS/Odd97p6xDU119/3ctBronY0ibIdmKd5s2bZzt27HCRTTyfMWPGWP/+/T2iunjxYlu4cKHXhfrRXQBxpwy6EFx22WXWvn17XZFCCCFyGt2hR6QEwWMwDhHAli1bujghcUTeECzS5kgTMoUw0q+R1xmcgywhTryGUCFrbI9IRkSRKCP9OZOjlDzndQQOSaTcRYsW+THYLjkyiMBRPlJInYmWJvfxRGaRuegbCkRnqWdENRFoZJo6IsEch3NetmyZ78s6ZJP6czwkkX2pH1LKtrQL+0cZCDL1YuGcYvAT/VnZN6K81Bdh5xw5n+RzFEIIIXIJRS5FmSBjpMDpz4icIURIE5G2YcOG2a9+9SsXM8QoZAtJQ0wRrscff9zuvvtuGzJkSElZyNW3vvUtjwT27dv3jBHllN+vXz/v70nKHYl79NFHfX9eSx7pTZSUPpWIHRKJlEYaPVnS6AMaMLgHaV6yZIk/Z5/bb7/d68z5IcOzZs2yd999177whS943ZFGzpV1nDcDnAABJR2PQE6ePNnP4+DBg96PlIgl7XLNNde4OPLayy+/bAMGDLAbbrjBZZrI7ve+9z27/vrrS/qulkam4lkZUVWCXojK4X995/DHon6Iqs1qKpJLUSYIJcKIEA0dOtSfk1pGpHhEMiPyRuSSiCAiSAQTSUPWSBkzMIjIHYKFDBIBjJHpkRpH8JDKSA2H0LE90UUEsry0ceKHLf9H+ogcInpEShHfK664wqOQAf1LEU/Ej9epG0J44sQJF2EkE9lEgqk/5SC61IuyOXfS24BMh/RybpSJLEa9eM6AI86D8ljP6xwzor9lyeV7773ncvvEE0/48VOdPwIMX/ziF13eEd6LL77Y2zZdGh06ZC3T3loIcdbfopkdPHDATu3Zk9XGic8SPl/4sS7UZtmG7+/KTtknuRRlgoQhUghLCB4pXwSIiy/SusgVQoUQsj3wHEFDKhHRmPeS7YkcpppyKEacs5592JfoHqnoGIyTSMxbyT586CJoiYJJObENkVCEjDoljkrnmEgxUA7bxjYcl3rE/JvUn3pTf/ahToho4rnFMRFxtkEcEwcAkY6Pc2RhnxDNVHN0Jp8v20bf0WRiCqY4l2jD8kbtJ6OBRUJkgXMwSC/xh6r+TjN9O9RmVYXkUpQJ8oiwkfZeuXKliw0DZxBIhIUUNmLJa0T3WE9ULqJnMH78eJ/+J9LfMegnJmbPxrRJCF9MSUQ0NXGaI5bzzjvPI3782ufYiXJZVj1YT0qbc4pt2JcyOHZMb0TkE7G+6aabzhgdTp0ShQ9CQoMQzNinLBggxPLAAw+kfJ33aurUqT546fvf/74PcKoQLVpUbD8hhMOnAD8srV27rLYIP3j5oU+f9LKyHOIv8HlN33i1WXqQdSwv0FEeGtAjygTpIdLWp08fTweTlkXWSFcjb6RdiZDRJzO2B4SPqCdyygch6emQJ/oj/v73v/e+islpbNLnbM//STkjqXyAIq2Jqewg0s5M8s4+s2fP9lRRRDlj+qAYKJNOHyXOiw+hEGXqzgcTIIqMMv/tb3/rIkvbMLAJaY1zhBj0w6h0+nVW9g818XxLWzLdvswlK7UVom6TV5m/wTT+zrNddm1d1GZ5FW6viqLIpSiTGGnNlED0PyQtzkCYSBMTMeT/CF2kj4F9EDSklNeQRvZDspBLRDVGnyNm8X/EklQyx0XWiJjSJ5KyouyzLuL8fBs0aJALHQNokFLKi9RzYnqblD514zkpciJ9pLWpI8/ZJtLsnBsiTXkcg4W+KEgl9UdgOSf6UK5Zs8ZT6bEt5dNecUye83och4U60h4cn3KjDxVCHvNpCiGEELmG5FKUC4LEyHAeEaEQMECEiPAhhEQxEcEA6SJ9y60iX3vtNZ9+CCFD3BgZzes8f/HFF23p0qUuWNwCklQzx0FIKe8zn/lMmXf7oTzS3sgg+z/99NMl9ea1SOsznyUpc+qMDBJtZXuEmWMiiqT8GdQDY8eO9e0ZPEP9Ymok9r/lllv8eEQuOTbCTFkPPfSQy2T0iaRLAG2HdDLRO4ObkMjok0lElLqwPwOHkGsG3pR1y0whhBCiJiO5FOVC2pl+fvSvRABjvsaACcWRSOQSAYvXEDvSykwOHlFBooiIFZFQxIwoH3foYYAMgoVw8TrHIbLHNogldSgr9QscK1LoEAN5iA5GlJF0PfVHbHmOIFJP9kNkEcMoD2GmnlOmTPHnMdqdOnGMiIwCI+SJcnKeiX0qEVX+TzcCJJTzoy70xaKPJuWzH+fPOhaJpRBCiFxGcinKBalCgEoD+UucQzJAkpA5IoZlgbSyVBbEkCXxjkGlEZOdlzU9D/LIEvNZlkVixDYVtANLDDZKhLZDLoUQQojagAb0CCGEEEKIrCG5FEIIIYQQWUNpcSFEWrQsMGt3TI0lRCqanVS7CBFILoUQafGL581OVm7OeyFqLY1PV3cNhKg5SC6FEGnRQpEZIYQQaaA+l0KIs2EqJe63Xk8fEUJU+O+nkre3FSJX0TeHEOJsrr3WbNkys5Ej1TpCZMr113/w95PGNGZC1EaUFhdCnE3Tplbcs6cV3HCD2dCh1ohJ7NVOZXK6sNBOFhSccQcrUTbclKCgNrbZuHFmZcyhK0RtR3IphCiVw1/8ot+FqFG7dtwKSS1VBqdPnLAD+/b5XZ/qN2qktkqDUx+2GXe8qt+4sdpMiFqC0uJCCCGEEKJ2yyX3Z960aZM/CiGEEEKI3OGcyWVxcXGFl3379tmMGTP8UQghhBBC5A7nrM/lzp07bffu3TZ//nwXxnQpKiry7eNRCCGEEELkDudMLvfv32/bt2+3HTt2uCQyKCAdSIU3btzYunXrZvU0x54QQgghRE5xzuRy8+bNtn79eh8FmJ+fn7Yosh/TUvTs2dMlUwghhBBC5A7nTC6bNWtmXbt2teHDh7tYphu5XLZsmc931qtXL2vSpMm5qp4QQgghhMgluWzZsqVHLJHEdKKW0b/y2LFj/v82bdr4/kIIIYQQInc4Z/ZGxDKTvpbBoEGDzlWVhBBCCCFErsolUlmaWDISnME+27Ztsw0bNtjevXute/fuNmHCBFuzZo2/Tl9NBvWQXhdCCCGEELlBleedT58+bSdPnrQtW7a4SNLHct26dTZq1CgbO3asC+cJbgl24ICnxps2ber7ZRoBFUIIIYQQdUAuiVgyivz555/36OSIESOsoKDAOnXq5AvRy5UrV9qjjz7qA4Jat26tvpdCCCGEEDlClcvlnj17bOPGjTZp0iSPTCKPRC4ZGU50skWLFi6diCajxol0amCPEEIIIURuUGVyGbd2ZHJ1Jla/8cYbrXnz5lZYWOiCGdMOMbclI807duzoUsnrQgghhBAiN6gyuWSQDreDJDrZoUMHa9iwod+Nh8E8RCoRzIA+mUgocqkBPUIIIYQQuUOVpsWZ7/Lw4cM+aAfRJOWNXCKQDRo0sIMHD/rocVLnCCh36tFAHiGEEEKI3KHK5BJJDIGkjyX9Lkl5Myqc9DivM9hn9uzZvp75LnX7RyGEEEKI3KJK5ZK+lAMGDHCh/N///V8fJY5IEtFEPJHJ8ePH2+DBg/2RyKUQQgghhMgdqlQuGf3duXNnv3sP6fGjR4+6YLIesWSkOPLJ5OkxelwIUX00fvVVs717zZo319tQDvVPnbImR49aPdoqm7euveoqs65d1f5CiJyhyqci6t27t/Xs2dOGDh3qg3b27dtXMkIc8eT/yCZU5PaRQogswN9eYaG1+M//NHv3XTVpGjQwszbnoqVeesmsc2d+oX+wCCFEDafK5RIQRua4JGq5c+dOn1T91KlTLpMM5GEaIiZXZ0R5iKYQogqZPt3sq181W7VKzV7d/PVfm40fb/bb30ouhRA5QZXLJVMSIZIIJQN4Nm/e7CPGmX6IhUgmI8nZbuDAgdaqVSvvk6kIphBVyIEDZgsXqslrAmvXmrU5JzFRIYSoHXKJWDJi/KGHHnKJpN8l6XDmtEQoly5d6lMUTZ8+3b70pS95BFMDe4SofoqruwJ1DCXAhRC5SpXLJfcNRyDpc0n6u3v37mfMZ3ns2DGfpuill17yKCZ38+nVq1dVV1MIkcT+T022gsE91S7nmuJia//jZ63B1j1qayFETlLlcsk0RFu3brWxY8f6wJ6+ffv6euSSPpdMTcS0RMx9Cbr9oxA1g5N9u9iJ0f2quxq1n6JiK2qqadiEELlLlcslaXDS4ueff36JQCbCAB6mIYqBPYm3hRRCCCGEEDWbKpdL+laSBiciSR/L5NHg3PoR+WQgD0sqARVV/4Pg3Xff9VtzMvgqujLwXvIaEWfexyuuuMLfMyLP2Yx0r1271t5//30/3sUXX2ydOnWqFfecp91oVwa10V3k7rvvth49evh5agCbEEKIXCX/XA7cYaEPZSLHjx/3L1XuL87cltHfMlLifNHGLSGJYGowT/XDjwDmJF2xYoULJu8TE97z/hw6dMgFk/d51KhRLpYIZrZgcBcT7i9fvtwFlr66bdu2tdoA1zw/pOhjPGvWLLv22mv9BgJCCCFELnPO5BJ5pG/lzJkzXU4CROTIkSP2b//2by6XpL8REua8RCKIXDJ6/MYbb5RY1hAQ/ZtvvtlFkvfoyiuv9Ogl7x288cYb9uSTT3oUjumjLrzwwqwdu127djZp0iQXW66d2gQ/qq666ioXdf5OFK0UQghRGzhncsnk6Mgl6cvEeSoRFYSB/pRIJdEvXicaRv9KolM8sk7UDOLWnfEe8t7Ewg8H3jt+HBBlZuJ7InILFy70kf5EOqdMmWJdunTx6CcRSFLrXbt29VkAuBZmz57t1wuzA4wZM8bnO2WbXbt2ucRec801Z9SHbYlwz507168nJuQnXX7ixAkX4Lffftujp/xI4RokWs4yevRov+5Iq7/22mu+PX1/kTsipEgy58I5kOJnHRFZzgU4P57zo4i6t2/f3rcF0tqcHwKc2FZ9+vTxaCRtxb5E5efPn+/txrVPPdetW1fl76kQQgiRc3JJuo8veqJbfNmmK4t8KTdt2tTFU4JZM0HKEKW4Nzz/531D9HjvAKlbtmyZvfnmm3bBBRe40LF9pNYHDRrkksYPCeSK6anWrFnjP0boToGYsj/3ob/66qtdWAMi38gnMkiKHHkbN26c14P1yCrrEDjKYD5VRJVrkduL8ogwco0yYwHXGsdcsGCBHwfZJFpKlBaRpQz6QbIeAY5BZpwv1zYSyjlxzpRDebQH58vxqCPnxd8DUsyx4y5VCCp1Szw/IYQQIpc5Z3JJRIbozsSJE9OWRL5gGbgB7BuiImoOyCRRP2QJcWKwDdE70uEIXvSHvPzyy/3/yCWwDe8pfSaJ2AWUce+999rzzz/vIsd73r9/f5dP+iEicMl3aCIayD3qkTJEk7LZLxbqMmTIEBdE+oES4XziiSd8PRFTBBRJZH+iiBH9pEyOjXASpeQ8X3nlFbv99ts9gsq+RCeR0P/5n/+xf/iHf3A5RIoXL17sovn5z3/e64tI/vGPf/RILedF9JX9OM877rjDj8HgnU2bNpW0a2L3ESGEECJXOWdySeSICBFf/On2JUMu+RLnS5Yvd8SBL2wiXOqPVjPg/ejXr5+nsyM9HCnsJUuW+PuHoLEd0b6A948lMZ0e6+Me8qwnwknZSCcymCqCzXP2GTx4sL3zzju2ZcsWjxgidEQpETfS3xwfaaSebE8kkT69REXZBkEm4sicq0QjiXyyHT+MSKOTwubcuI4ph7pQFnJM+pzXOQ8Ekf3iONSP+lMHJJZoJVFQ6oecco6RUucxk1ucEuVF6Dlvug8kQ72QXXj44YddaLnLFbJOu6ZLg+PH7S8/AUR1U1hUZEcPH6519xaPeYz5e0t1PYuy24zPPVE+8X2jNksPsnGVda5zKpelESlAHmMJ+LKNPnykLfnS5Utb1AwQNqQvcUDPokWLfEAK6V4EDbkMMkn3cjEjZMgW/487M1FG8oXOj48BAwZ4CpzBYxwXaUQ0EUdEin0QSBaEEBnkukIGiVISWZ02bZr/iIn+lSGGSGAIIWJJdJPyKIfXaQde5wuR40f0M+qJLNM+RC1ZYiAbjxyXFDsgtVzf6Ub3EdW33nrLfv7zn581E0O0FecCTz31lEsokVIiutQ7XRoXFEguaxB8Jh49coRfVlZbu9qIzOCzjEVkdp0pUFU+fI8kBodyYp7LgC9AvuyJNPEFnngnHi4AIkwx+AdZEDUX3iPS3S+88EKJwJT2BxwDgEqDCzod0WIbBA1JRLJIfSNxXEuXXnrpGfNgUj8GCiGVHJttGGTEdYaAMRUQMsh2iSn7TKiqD6zx48fbeeedZ5/73OdSijuy++qrr9p9991nDz30kF122WX+nsS8pOmSpx90NQqi5vzwqm1yyfXKDzl+ZMXgOJFem/EjXFP1pQcRXrJItFkmP7LrKvv37690N6386hoMQl83IpNEf4joeGXy8/0Ph4UIT2l38RE1gxAqhI33lfcvBAZZi1HTvM6PCZ7z3vOeR+SurHLLOzYLI8KRRfo88kEbk7gnTs6PaPIDhUFDfMgkpq9jRDkRAPpUsi3l8gHE/7n+uE6RTv4f0QLOidc5D9Lc/DGyXURZeZ2UekhBYp9QflTxSD1intB0/5A5R5ZU7cexqRsRVCBC6kJSEWqZxOQ6/EX4NV3L3pf4W48ZKUT5xI9vtVn6RECDttN1VjXBkiqXS+Ri+/bt9uyzz7pU8qWKmMT9xPmC5kLgImB6GdLkonpBWnifIlIW0cf4g+U95VchwhPp4xDN+MHAe4ygIZZsi5gllhsLzxOPFcdLfD2xKwXpecT1ueee88E79MNMjnxSL+5hP336dJdLhDL6hLKePoykm7neIiVP/YimIGhE15FN6s81S78d6hGjvTknrmnqQZtQN86ZND0SyfEQScqmTNYjiBwDAY1fiXHXKiGEECKXqXK5ZNDHvHnz7NOf/rR/GccgDPqnMfCAyAuRJFJ7RJskl9UPQjVjxgyfRggx5L1BlhAnZI3XeR+vu+66M/ra8t7dcMMNnrLmPScySOoa+SOKGNE33m9GVVPOSy+95IJIGht5I8rHtgxkQeLilqFIIbJGZI7yeGQ/Rqwn334yIpesRxJHjhxZEhHnOAge0UPm4kxMM1EWdZ4zZ47PYsA5I4LU+8EHH/TR3pTNeupO30sG0SSmn6nTsGHD/NjMs0mdmUKJ9iANz/E4fyKprKcu3KlHCCGEyFWqTC4jQomMEBnii5wvdKJAMbE1jzGYB4HgC7mynUpF5eG9IIJHv0reJwQSSUOI+IHAazwSRYw5IAGBQ6yI1PG+I1PIWAzWIqKHoLIPg3MoD2FDKuP+2jwib5TD9cOxIjoao0ujfpQTryWCfHItIZVsy3UWk70jj/yooexIlQcxS0EMLIroJcdBbmNgDwvyyrkg2THyPdL2USfEkj6iyGS0D2WwH3XhtUhpCyGEELlKlZkbX55EffiSRyz5giYSxRQ2fFHHiPDop8eXfVkDP0TVgfwwZyRLJiBTDEApD+atZKL1VHCdEF1kCRDVuOc41wqyGlJaWgd3ZO+jH/1oymOzpCL6SHIr0vJAfssDmWS56667yt1WCCGEyFWqNHKJXCZOBUDkKdLiSAECSnqU/m/JUSQhAmSSaOhjjz1WMjBmwoQJHiUUQgghRPVSpTnniEjSj45BIMgkUskUMUShkAb61pEqJ8WqKQNEaddR3I6RNHWM2E6cfkgIIYQQtVwuEQIiTDFA46KLLvL1pDN/+tOf+kARIpWkUrmfNAMmEvvvCREQraQf5F//9V+fdY0JIYQQoo7IZdyx5KqrrvJRuEQmgUcmfI7IJdLAdohl8qhfIUASWT20efgVa/nMbF2E55xia7B1j9pZCJGzVGnkkjQ3o3NZAlLjRCpJhZMyZ9Rt3FovJrsWQlQ/jdZuq+4qCCGEyAFqxDw/ibIJzBf4yiuv2NVXX13mPcqFEEIIIUQdkUtGgNOPctmyZSnvgVwabBtTzWSynxAiizA11O9+Z/bNb5qtXaumrU7+4R/MLruM9I/eByFE3ZZLBu7EnVcygemJGEHOtDLqWydENdGrlxX36GFFTz7JPGJWj/ln9WaUSRG3Jy0sLJmrN2tMmWI2caJaXwiRM5wzudywYYOtX7/eB+fwYZvOzeKJVG7ZssX7ZjKxNdPMCCGqibw82/+Tn7hUtm3XTm9DOZw8ccKzNXFbz6yhgY1CiBzjnMklgsi9pbmtX7q/5JFLpiJilDj9MLP6AS2EyJhixIa/XQbWKS1bTmMVm/GZFYsQQtRRzplcxv2UuS1eunfaQS65kw+PRDwTR4qzLl6nPN29RwghhBCiDsnliBEjXAYz7Xs0ZMgQ3w95TNyXvpgs3IuctJMmWBdCCCGEqENyyVyVmYJMltY388iRI74gmEQvhRBCCCFEzSO9fHUN4ODBg7Z3714rLCzUFEVCCCGEEDWUnJHLPXv2eEqc20Ny5x4hhBBCCFHzyBm5ZGJ1UuIM8klnWiMhhBBCCFH15Ixckg5noS+nRooLIYQQQtRMckYuhRBCCCFEHR4tni0YGU5KnGglk6sLIYQQQoiaS42PXJIKP3z4sKfDmZhdCCGEEELUXGp85JJBPBs3brSmTZv65OmZTsouhBBCCCFqsVzGnXb279/v9x9v0aKFRyWPHj1qu3fvtoKCAn/OPcbbtGnjMsk9xolaIpiSSyGEEEKImkuVy+WBAwds+/btNmPGDOvTp4+df/75LpjLli2zp59+2qOU3Npx0qRJdsUVV1iXLl38/uSB5FIIIYQQouZS5XK5fv16W7hwoQtj9+7dPTr5yiuvuHA2adLEbrjhBh/As2TJErvgggskk0IIIYQQOUSVDegpLi52aeT+4EQvu3btam3btvX1a9assX379pVEKbkLD9sxmEcIIYQQQuQO+VU5pRC3cOQOO71797b+/fvbsWPHPJK5bt06GzhwoH3iE5/wfpibNm1yweT/QgghhBAid6hSuWQQz+nTp10aiUpu2LDBZs2aZUOGDHG5ZOAOr7Mwp6XuxCNE9dLihz80W7vWrFEjOjzr7SiDBoWF1poBibSVblGbUZs1qG1tdsEFZl/4QnXXQojaL5ekv2OkOCPCd+3a5RHKtWvX2uTJk73/JVKJgJISb9asme4hLkR1cfSo5e3caY3//GezhQv1PqQBatRULZURtbbN9u41u/56sy5dPvhhJkQdo8rksn79+tatWzebP3++vfzyy/bUU0/5qHD6WTJwB/nktWnTprlYTpkyxV8XQlQD06aZ3Xuv2YkTan4hMuWll8yY5WTmTLNx49R+os5RZXJJipu5KseMGePyyLyWjBTv3LmzT0V04sQJn8dy5MiR/jrrSZMLIaoBBtMdP66mF6Iyfz9FRWo/USepMrlkfkqmGqJ/JfNbMmIcqeSuO0BKnOfDhw93yWQkuea0FKLmUNggz4rrq9+lEKnIO11s9U8Xq3GEqI55LolGMmIckUyUx7gDTyCxFKJmsfWytnaku2ZwECIVbZYftS5vH1DjCFEdcok0phJH1tEvEw4dOmSrV6+2AQMGWMuWLfVGCVEDKGpQzwob16IRvUJkkaJ8RfWFOOdyyQCdSHfT3zKEkimJWMqCe4zPnj3bOnToILkUQgghhMghzmnk8uDBg/biiy/a4MGDfaohpiFiRPj7779fppQyxyWDfZQaF0IIIYTILc6ZXBKd5HaPzFuJVPKciCSjxBFIBvek4vDhwy6XTEOUn1/lWXtRAXh/Ge2/ZcsWf8/5UUC0mvec1+hPy8ItP/nBQbcH5jhlMBcLEeqaMmE+9WceVuZfpe4watQo7yecLpwfc7Xu2LHDp9/q1KnTOayxEEIIUcfkEukA+lNu27bNxRLJ6Nix41mTpPMat4Nk0A/b8BjpdUUxax7x3hw/ftx/OLz66qsuVYgiPxB4/5kVgFt59uzZ0+c05RpA3J599lk777zzXNyYGaCmyCVCyX3uibgjiZzjoEGDMpJLbhCwceNGe/311+2aa66RXAohhKhTnDO5JOpIROqTn/ykz1uJHJLq5r7iyESsS4b5LflCR0SASCfbipoH7xMiNnfuXJsxY4Z95CMf8R8NrVq18vcWuSQS/fjjj3sU79JLL/X3n6g0XSNq4mAtIupct1dddZUtWrTI1qxZU91VEkIIIXKKcyaXyAXRK76oAdFo3769R4B4jXuLc4/xxOmHkBXkkrRkpNSJXkouaya8X6TC9+zZU/L+kgJmmqnEuUtZd+zYMX/feT95z3nkGkA+mRmASDfbE7HmddLoEUkkGko6Pe45zyNRb7blR0xEwCPlHulsjse1RFlch1x7PI/6Uv+ImFIOKWz24f8IMtdn8vmuW7fO601Z1DlmOaB8ziluYUokl3PeuXOnR+NpB84LeaWeRHv54cSxKJf6cO3zOusUqRdCCJGrVFmnRqSA9OKGDRs8LcpzvkxJlybCFzxfzosXL/YvYMSAdaLmgUi988473vWB95aoZYglIEm8fxMnTnThS5YmRJB9iXzGPeVvv/1269u3r09DhXSxbuXKlT4QDFkj6omc8YPjtttu8+hnCCLit2TJEpdH1nE8IqaURXqaiDmRVtLVpOsRuuh6gUzecccdfl2WBlL5wgsveD0oi/05DtJIpJPrmfquWrXKI7OI5bx58/yRQW1EbbnekU36nBIVpX1oR87phhtusB49eui2p0IIIXKaKh8xw5c7kSq+3LkbD0ISX/B8yc6ZM8e/dN9++2279dZbS9LjouZB5G7r1q0uevwASO5DGyBMvL+8niiXyBkyd/fdd7toIoLvvfeeRxf79+/vUU1E7bHHHrNbbrnFZxxA5Lh+6NdIuv3yyy/3bVesWGHLli2zzZs325133ukRQOo3c+ZMF1CuNyRv+/btvj/3rifyiRxyrVHeG2+84RKIJKaCbblmiVr269fPz4nyXn75ZT8urxPBHDp0qF/T7777rl100UU2duzYkgg91/9LL73k7YVIc/7UjfNERBHPm2666Ry9Y0IIIUQtlEsEkigWkoFQ8GWKYCIUfPEyEIJBH0SySEsmRsJEzYPoMu8TMlVaKjex60MiRBaRQKJ5pIgph76byBYgl1wTiB/9dZFUZIz1HBcZ5F71XFNcM6wHfpAgvEQaGUzEPiyRwkcKSeEjq0DUcu/evR5VR/pKk0ugXCSZMqJ7B9cxdWbkO8fmmqW+nA8RTiQWiE5yXSOkRCyRUcqJskilU15ZcBwWyki1LcK+fPly/z9RXMQa4aU+pc3QkIp6dEFIe2shRDIMd+SzqaigIKuNQ5nxyPemUJtlm/LmIq+xt3/ky5yIDunOX//613bxxRd7VGnWrFl+33EiQ9yDHJlAAkTtBBlD5pAsxIfnSCapcoSL1DFyiRwhdQgiEkYfTtLPRLiRNbbnWuJ1ZDIiqJRLSh4o76233vLtSU8n9qfkxw3lvfnmmx51LAtS4kRYEVuuZeqLmCKtiGRZcGxS94gxdX/qqad8PZKIFCKp5Q1yIrL7yiuv2I9//GM/dll8+ctfdlG+5557PFJLVDZdGh8+bGWfjRCiPLz7zd6956Sh4se0UJudCyo7FWSVyWVEaPiyQx75Eo0R49OnT/fnSOa4ceM8qoM5E/HRwIaaC+9NRPkQrNKibkTseI33NfGCjcEz8f94r0ubfqq0a6GsW4oGUWZZ5ZT3JRFpe6KAN954o0ss65BbRDOdX3scm8gmqfxrr722pG7si3SWF10cOXKktzl/KxHBSARJXbBggX3nO9+xb37zm3bBBRd4hJZ9YpBUOtTXDA1CVBq+14ratMlqS/J3j1jy91xWH3HxFyLDhHNkMq1cXeXIkSNnfGfW+Mgl6XDeZCodESciSESn+CPkS5u0IpHNGE0uuay5EBnk/eK95D2M9zcihwgTz4lKIz3RT7E0KeT/iWLJhwDyyb5x29CY4ogPWK6PGCTE/zkWaaIoIwYEAdtRHh/GERkNKI8lRmqngn0QaFL0XKvIYYwUZ7/EeTqTz4tjEWWkfkgo21IGEdRIjfMabVje9U4Ul2XYsGFnvUY5nH98eCKgDDSqEPoAFqJS8JfciL+jDLqjpEOkwvksy6SrS10mZhDhs1FtVj5k6MrrolVj5BIZYNAD9wxnoANf1ERUSH8zoIP+cEQweeNZ+GV2ySWXaALqGgwidsUVV3h3BkZRE8VjHT8S4g+adDHpXz4Qv/a1r2X0Y4EUdwgdkkh5yBnHYR0j1KNvI9fR0qVLvd9k/FEgo4wM5wOFa40FmWOEO388AeWxUEZpqW3kk30oK7F/Kdc1UkgXjoBjIJ0cP6YZ4pqnbAQbGaddOCeiDzFx+7Rp07z8j33sYxV+T4QQQojqpsrkki9aIlh8oSIg119/vfe34ws/5kZEKhn1yxc360sbfSxqBrxPRJlHjBjh7ymjsOlTiHzx3kX6hr5+SCDbMGiFEebIHMJJRI/XkUWmqOI5g1VIPxMdRDAnT57sZfMDhOuE1xE2onJcJ/yCZ7oh0sock/6QrEPySMkTXWWhTyeDixj8w2AXBpNRT+rEtceobs6H9AmpZV5HBNkWMaQ+jOhme2SaFAvyy3GRWuo0cOBAL4u+wkgjI9ijHynrmEoJIaeeyCR14m+DdmIKJp4LIYQQuUyVyiVf1MAXKH3BGEgRkSIiOKxnfkC+pJEIyWXNl0tEiqgdaV4GmiBS0ZeSqB1SNWnSpJKoIdE/RIr/xwTpSCZCh2ByHbA/P0Ri7kykj7vlIHUcJ+7axK0j2Z7rhD6FiB5lI6FxC8qYtD2iqdSJ0ekx0Xn0WeJ1BpNx7SGkRBL5f3TbQAo5BilpXkeEWReTtEdkk/PleLzGNcz5UR9+QBGV5DXqzawI/JCKyeXZD0kva6S6EEIIkQvkFVe212aaIARPP/20R3+IVPHFiwAkD+Igbc7/iUTxBY0ciJpNDNaK/rSQ+L4if9EnMQavROo6UURjffRlTOy7GSnmxLR64mAgiOMnX9KRpk4uK5E4ZtSRyGKUFf06KSfWJx43BvLEuUTfUYQz+l/G/jzG8aMPaZA4D2hF+hpHn8upU6f6HLHIfoX7XD7+uNmdd56xasP1HexwL/XxEiIVbRcftm6zPgigOPwNz5ljduGFWW0w/sb5IZ3p9GJ1meiipTZLjxigSzClouNeqixySdRm9OjRHp0k6pQolhBfyAxy4EuXiBFRH1KOca9qUTNJlKd0to275ySDXKUa/ZgommWRzjYcu7x6xmCiVKQ7OjNudVnRegohhBC5SpXe/pG7m0BEflJFkUiDxqhfUqXRr08IIYQQQtR8qnwS9YCUIXMHEqqOeRAD+p/RH47UOYMgGNQhhBBCCCFqPlUul4gj/S8ZDYxUMgAjcS5C+kawMNCBCdV1+0chagYt1x+zRgdOVXc1hKiRNN2uWzEKUW1yiVgyDc3zzz/v/yctjnCSNmfUbUQxSYczz6WmZhGiZtB2edm3mxRCCCGqRS6Z6Hru3Ll23333ldySiRQ4o5KYioW+lsyDyITqpMN1b3EhhBBCiNyh/OG9WYIIJalu+loyWpZJrZlqiJG7iCXzACKSzPPH3JdsQ5o8pnYRQlQh9HP++MfN2rdXswuRKb176+9H1GmqLHIZ9xMn/Y1Axp1QmDibO5NE38qY649UeWXvbSmEqCAXXGDFv/mN2SWXmHHPczVkuSTOnKr2quNtdtFFZg8/XN21EKLu3KEHaYxIJAN3GNDDiHHmtURAuV0e9yBnnsF05k0UQpwj8vLswA9+YHnHjn0w16waukz4PDt08KC1at3aGqY5H2pdx++IdeBA7WuzD+8IJkRdpUr7XCKVTIqOZJIiRyaRSm6Fx0Ae1nE/ZwSUW/TxmhCi+jjdt+8HPwa557m6p5RJ8YkTdmrfPiumrXRnsbQo+rDNirgNsD7vhag1VJlc8gXFfaGRSKKTDNoB7jn905/+1O/fTKSSfpjDhg2zBx980P8vhBBCCCFyhyqTS/pSMnDn8ssvt5EjR3qajdvj9ejRw+6//35PjzNSnNs/MrCHe4CmukWgEEIIIYSouVRp5JI0N9FIRJMboyOQiOTQoUM9Fc6CbDZp0kSjxIUQQgghcpAqDw0yOnzt2rU+3+WQIUM8gsm0RMnTDWn6ISGEEEKI3KPK5ZLph7hDD3NZbtu2zf70pz/5HJcs/fv3936ZSocLIYQQQuQmVS6XjBAH+l+SGt+yZYvPZ8nSrFkz73dJ+pzUuKYjEkIIIYTILapcLpkwvWPHjh6pZHQ481+uWrXK1q1bZ0888YSnw3l9woQJ1qdPn5LJ1YUQQgghRM2nSu/QA4wQRyAZ1INc8v+mTZta8+bNPSWOZBLRPHLkiAso6fNBgwb5/yWaQgghhBA1myqNXJ4+fdojlSykv3nkDg1MrM7/kUzS40ePHrUNGzb4nXuQS4SUNDlL3B5SCCGEEELUYblEGrmtI5FJHkl9M5H6ypUrfWAPUxQxoOeOO+7w0ePcoYepibZv325PPfWU74+EklaXXAohhBBC1EyqVC53797t0xCtWLHCevXq5VFI+lXGpOoIJ3fsIf0dUUqimaTPI4UuhBBCCCFqLlUml6S9kUuilaS8GQmOWNKfcsyYMT5SvEGDBmfsE30zSYvzGosEUwghhBCi5lKlkcuNGzfauHHj7KMf/ah17drVZZE5LUuTRubDZCGqyfYsQgghhBCi5lJlcolEcptHRn0jiYwMJ9VdFkQzmQ9z+PDhPrBHk6sLIYQQQtRsqkwuSW1PnDixpP9kOrRr184X0udCCCGEEKLmU6VTEdF/UgghhBBC1F6qTC41EEcIIYQQovZT5bd/FELkEB/eWcsf4/+lwaA8TRcmhBB1HsmlEKJUWn/lK5a3ZAkj8spupdatzZ54wqxVK7WmEELUcSSXQoiz2bnT8hYtsgbz5pmtWFF+C7VsaTZ9utnIkWYDBqhFhRCiDpPesG0hRN3ijTfMrrkmPbGEQ4fMbr/d7Fe/Otc1E0IIUcORXAohhBBCiKyhtLgQIi32tuxrJxq1LHlev7DAOu1bYXlWzkAfIYQQdQrJpRAiLf588f+zlT2vLnne5tBG++JjE6xBYYFaUAghRAmSSyFEWhQbUw0l9KRJ/L8QQghR1+WyqKjICgsL7ciRI3by5En/P/c7b9iwoS/JnD592o4fP27Hjh2z4uJia9y4sTVt2jTltulAGdTh6NGjdurUqZLjUy5Qr4KCAmvRooXf2agm3N2I86dOPEaduJVnnEuDBg18oV2yBW1Dm8fxaJ/KTMhfmfI4z7heTpw4Ye3bt/f3P3n/uLYOHz7s/+f1Nm3apH3bUyGEECKXqbNyidTt2bPHnn76aVu5cqXt3r3b7r33XhsyZIgvyezatcveeustmz59ugvWBRdcYNdcc43169evQsdHPqjDs88+a2vXrrX9+/fbJz7xCTv//PP99RkzZtj8+fPtYx/7mHXo0MHlpLpZtGiRLVy40F577TUXq86dO7v8IpuIVO/evW3QoEF26aWXZu2Y27Zt87Zo27atH+/CCy+sVHk7d+60l19+2cvr2LGjXXTRRWnviyi+9NJLtmzZMps3b55997vf9fNFGhMFE3nlenr00UddRhHuf/iHf8iqdAshhBA1lTorl40aNXJhQ+aQAeQOcWrevLkNHDiwRBiIViGChw4dstWrV3vEqlWrVjZhwgRr165dhY9P+UTN+vfv7/+fPXu2y0swYMAAlxGO0aRJE6sJ9OrVyx+pa5cuXWzEiBHWrVs3bx8E8w2mrzGz7t27+/qIwlYGorkjR470tuC9qSzIcJTXrFmzjPblehg9erRHLt955x2/NlJBNJNrhPZZtWqV7du3r9L1FkIIIXKFOiuXCABpUaKU69evt3Xr1vkjskdkMjFdGpG5vXv3ugAiKKNGjSqRT4jUeuI6pDE/P98X4HXS66Rm4/VOnTr58QL25XUigwgQYkk92RexjbIjCkZ5sT91jvQ5dWYftkekI1XL80hfU2fWR0qbevJYGgglx6BORP0QYBaOSVnPP/+812fz5s1ef8pjfeK5cc5sz3GiPah/pKmjPrxGvSmja9euvn10QeDc2I/tWBdtzLFYoh14L9g2pJ1tKSe5PI5Pm1Mm69mX/0dbc77Um4UfHjt27PCyE3988N5wnGhD3h/ahoh3olyyfdSdx+hWEO9T/KipTOpfCCGEqE7qrFwmgmwQzVq+fLmnTefMmeORyYgYzp071yOXpHtfeeWVM/ZFChALIllEqRCbkJWePXt62nzo0KG+LanSxYsXe0oVCULAOAb7B/yfdDjH3Lhxo91www1eP6KspFlJpSMgDzzwgAsIdSZVi9DcfvvtHl2k7D/+8Y+e7keKb7rpJj8vpIj9OVfSy6+++qrLD90DJk6c6HUdO3Zsxu1HPZAqzgdp4jikgymX9kKagHVIKULN8ajfihUrbNq0aX6Offr08Xqy3/bt2+26665zcWM7yubcrr/+envqqaf8vJH9iy++2IYPH+5RQros0HXhnnvu8WMQ9XzooYc8Kk29rr32Wo9Ssx3l8f7ceuut3g7vv/++vffeezZu3DivB+XTVhyftqberbnFYRLI69atW+3JJ5/0ug8ePNjbtkePHikjm9SDsrds2eI/aIieIplcX9SPiC9RTyGEECJXkVwyX1/9+i5ARDH58kc0kCwiWzw/cOCACwBykzyABxmkL+LBgwc9oknkk31YT5odEaSvIPKFhLz77rvWt29fFwhkhT6FiZFLtkMw6IeJ+CE3lIGEsh5xQ74QF6JjrOO1xMgkz8eMGeOyQ905P4SJ+iNQRNIWLFjgUTgEi+ebNm3y41dELiMtjiBxbMSNKDBtQB05BhLFedK1AKEcNmyYr6OfJm1BvRFhIsKUQ1vRbuzDc9qfJc4FgUa+KZ/jcXzOlbbhXCI1TX14b9kGQeQYRGCpc0SQKY+yeW+AHwgIInWgvTkXSCWX1I/tkFn6xiK6/D+EOtVgIn488DrnyrGQbupM23Cu48ePz/g9EEIIIWoKkssPIfJH1Gnp0qUuXkgAX/xIBxEsXqf/Y3LaGIEiEol4IBdE0BAg9n/mmWd8e9KjSA7RKsSCSCISSvlvvvmmi2liPRAuRAO5JCrIOvobsg8ShkABcoYYUS+OF7CeiN6SJUtcjtiXOiBXRASRTsT37/7u71zOOD6DU0K20iHSujHSHWlj4TyRQiKvCCCixbFpG+pO+xLhJYqL5LGeqCXbUhYRYx6Rbs6Dtmc/2g6iKwPHYaAP7c4xaBPagPcD6aRNkHheRzKJ1vJ/BJQ2i/KA950o55/+9CcvlygxckmEkR8aGzZs8HZCxhOJa4OyOBbtizTznnE+yalt1tHWXF9sh8jzY4IILGXxI4XzKEsu2S7EOFVkFNmNSDjCHQOKYmR/uuQV+8RDGUONihP6Dtcl4v2I2RNEZm2nNsvsOgO1mf42ayqSy2iI/Hw777zz/MsY8YroEkKAfJQ2qIYvcyQuJIb+hkgFf/Tsz/+RRGQAsUCkiHBGn04ij5RBRPGcvMH5+S4+CBPHQ7p4RKaQDurBY0wxlC7IL+fDeSM8tNOVV17pUUokDLFGYpFIInsRyWMdsotE0V4RCSaySNtQX6SSNoq2i6hqwH6cB9tRByKLa9ascclE3EmNI3rIGzLJe8fo8HTkiv1oL7alfOQXQU/VNqTTaT9kloFhyfKZDBJJuyHBpPr/8Ic/+Hraj3WcS3mDlt5++23/QfLrX//6jB8UiYRcfvrTn/b0PKl/3ptMZjZozHtrmXPs6FE7vGuX1eUvfa45kRm0mfoZq83ONXzGkh0SZRPjByqD5DIBRAeZ4EsYYeE58oA0ELlKJRgxAAcZQhRZYqAHAoTUIE5E4njDIoIUH6Q8z/RNTI5YxSCYVHCcGLzE/+N4CCXPEweUZPIrmPMl8ojQAdE0xDKiu5HOj21CzpG3eEycmie6JkSdQgRTze/Ja2wbaXPkldQ+corsIn18iCBz7B/nnw60TQhvDD6iXVJFCWPAEdcFx6IOcX5lRXspn+uCCGriIB+ioOVNOcW1xI8d+qMmdqcIaHd+4DDdEhFQ+vsS6WW/TEbvN6jg/K318/OzMktALkLb855EpFik32aZ/I3WddRmmRNd1WLgqiibVN8tmaJWTgCxQYaIeDH/JB94CBPCUppcxn5IJX3oIi0e0gmRyg6hDJlLfJ4OyaOIY7+y5BJCLKOMkKbKRAoQOaJ1pLyTuwpEvRBQ2oO5IGOQSqR1ow7RpvE8XXhv6CbABwYDY4g4cxzqQ/kM4iHiyfuWyfySIbbR1vFDIdV7hDTzQcXxSJ1Tf36clAXlRXeGK6644ozXEgd2lQZiyUI0MhnqyIfC1KlTXS6/9KUv2VVXXWUVooJzcjZu1Mgap+ibWhfg/aP9iT6n6nMrSm8z/ibq6o+STKG9WGI2EVE+ceMLrjO1WfkQLOF7rTLoliFJIJeMGOYReWFUc1nzIfIlQnSIC5e+hCF5iOXjjz9ur7/+ur9RpCcRLCKY9E3kwwEZ4Hli/7+ypARZQ3xIIcXgHWQNceUYNQlSy0TL6LeI+AWzZs3ykdWkmktL66YDHxDMOUmEkr6KcbckZI9BNaynDyU/DljOBQgik7Dfd999LrKMjEdqE6dfSoRoJVFxtuH9ol24XrgWSP+/8MILPnJeCCGEyGXqbOQy5iZECmJUNZJGlJLIAwMuIvUbI5mRQIQIgSFtTuQKoSFixr4IDaO8eR3pi0gUkb0YRY1kkrZEQOj3SJ/EkE2EA9lke+rDeqQDKeFY1AvR5XUiZbweczJyPuxL5IzjIzBRLsdjG/blGNQzBpdQR9KxPCeKSLmkm1NFEaJ+lEn9+D/nRL2So4MMSqIM2pY2pt0Q5Bh5T7tx7JhDlNfYnnrTLpQX/RBpI9Yj1qSe45aYnCv7UQ7pePZhG6KqlEm6HKFne95DjhXlUQ/WcU78EEB2Q9R5n6kL21J/yuL/vEYZMVqfulA+7w/tz3MGAMUIfo7PcdiH8jkvtqdteA8ZNR99VtmO9y0bE8ULIYQQ1UmdlcuQK+4qg0AgAETZiCwRdYu0IxKB2CAcDBRBLJAA+vUxSILpfUhvzpw500dCE3mKvo3cqSZGRANlT5482efR5Pi8RuSKCBZ1YZAHooFgIK8ck3ohYvTlQ/p4pF8ex0NgYnocjslUOhwLWWKAEHJD52UGgJCeRmxj7kvOC+njeDzGnI6Uy20tqVsyDEYhSkh9qR/HoQ6UmxwdJPrLQBe6FzAIJdLN1I92QUqRXlLaSGrMt8k5UhbtynPKYMAUx2QhOozMx+0gEcoYkc862p3/855RNtKJ1EXXBM41yqMdKY9tY9AO7cN7Qv04NrLI9YGgIoO8JwweYhvamPeNCCrXBG342GOP+bnzY4CBYZwbx2KEOBFu+u/SX5IynnvuOd8uJntnDk/aRgghhMhl8orT7fBXy4jBFQgHksRzZIOIVWLULvEOLBGFgohCxd1vkDgibTEQJQbSUFZE9RBKtgm5i76KcZ9xyqQ8BAkh4ZgRzWKhPLaLkZXRTzHuDsP/OQfKZf+IXCJG1IGyidpFXwoEKvrpRWSQOiCsyfN5AuVRf44fd7iJEd+JfcyijyLlEs1L7CsadwfiONF3iOhhCDnHpizKjGgqAkedaQvOD6GNTtmIH20SUWTWU8eQUUSV41Gf6HcT3QqivJhSibpSNu8Z66MNQ6JpxyiD95tzZ1siwlxHnAvnwXvFMSMiHNcW7wHbs55teYx2Zpto94r2h03sc8mPI9L0Fe5z+fjjZnfeecaq3173R1vVa3LJ8zaHNtoX/zTeGhQmdP7+h38w+853rC7CdcE1xA8a9bnMrM34Yag+l+kRn5nxWSjKh89hPqPVZpn1uYzsYEWos5FLRIovclKo6dx9JgQvFSF15Y305XgsqSbjTqa0u7SUVY9E+HJLde/z0vofljcQBZArlhghXhohkzHxe2mEyJd2rpwDS1ntlaouyB5L4mvUJ8or7XjJI735wmNJh1QRx9Kuh3gPK3NveiGEEKKmogE9QgghhBAia0guhRBCCCFE1qizaXEhRGa0ObzROu9ZUvK85dHtfptIIYQQIhHJpRAiLabM+hqdV/+yotgsz3QPbSGEEGciuRRCpEU9bFKRSiGEEOWgPpdCiLPhrlS9ejHFQXqtwxRcPXowRF6tKYQQdRxFLoUQZzN5stnSpWaXX242d275LYRUzpnDfE5qTSGEqONILoUQKT4Z8q24fn07ev/9lnfDDT4BfJlT6TKZM3OCfnhjACGEEHUXyaUQolSO33qrT0DflAnfK3inBiGEEHUL9bkUQgghhBBZQ3IphBBCCCGyhuRSCCGEEEJkDcmlEEIIIYTIGpJLIYQQQgiRNSSXQgghhBAia0guhRBCCCFE1pBcCiGEEEKIrCG5FEIIIYQQWUNyKYQQQgghsobkUgghhBBCZA3JpRBCCCGEyBqSSyGEEEIIkTUkl0IIIYQQImtILoUQQgghRNaQXAohhBBCiKyRn72ihBC1jXp79ljeyZNmx49Xd1VqPHkFBVbvwAHLo60aNsy8gM6dzRo0OBdVE0KIKkVyKYRITXGxtf38583mzrU8tVG5oJMdi4stL68CrdWokbez9eunlhZC5DySSyHE2SxebHl/+IPZ6tVmx46phdIApaywhBcUmH3/+2aXXWZ2111qbyFETiO5FEKczYoVZt/5jlqmqigsNPvZz8wOHZJcCiFyHg3oEUIIIYQQWUORSyFEWsy+/DLb0a2rWitLNDh1yq5+9jlrfKJAbSqEqFVILoUQaTH1tlts7sRL1FpZotnhw3bJK9Mll0KIWofS4kIIIYQQImsocvkhRUVFdvDgQTtw4IDt3bvX/9++fXvr37+/NW7c2OrXr39W461bt872799vJ06csDZt2lirVq2sS5cuVq9exZz96NGjduzYMduwYYMfs2nTpta7d29/7dSpU/b+++9b27Ztrd+H05VUaMqTLLFr1y5faLfgyJEjVlxc7OffpEkTr19hYaE1a9bMl27dulVrnbMF53z69GlbtmyZ5efn27Bhw3x9bTg3IYQQorJILhOEYcuWLbZ48WJ77733bOXKlXb++efbpz/9aRfGRLlEoGDOnDm2cOFCl6zRo0fbkCFDrFOnThWWS0R18+bN9thjj1mHDh2se/fuvsDhw4ftD3/4g40aNapELquTVatW2ezZs+3kyZMlUrV+/XqXyQYNGnibIV6IN+fQo0cPl8vaAOd4/Phxe/rpp12ahw4dKrEUQgghPkRy+SHII1FKHhs2bOiRS5apU6fa7bffbu3atYtNraCgwLZv327btm2zQ4cOWc+ePe28886zMWPGpIxwpkvHjh2tUaNGLqpIW4CstW7d2u677z6PjtYEaCPqcuWVV3qUEp566imXyZYtW9qkSZM88koUmHbivGoLSHPz5s3tox/9qL/filgKIYQQf0Fy+SEIApJEJAo5IspGdIrUN1HDFi1auFAB4keEkX3YFnFCNvh/pLBZiGgCAsI+bIeQIV0R3WQbUuG8jrTwyGuJwkK6HNHdt2+fv0bZCC7r9+zZU1ImKXO2IT1NuaTUSe0TaWM7XuP/1IPtOS+Ow3HZl9eInlIHzrVr166enuf1ZJBdyidCyTZA21E/2oLIK+3BcTgGZW7atMmPSeSXVDKpZWR069atfjzan8hvnBfnjFgj9qzjnGkrIrccg9cpj7KjDpTNeo5Lu3Bs9uG8+BHAeo7FjwPWc8681/HesY460T2Cc4n25nh0faA+vE5bIs4cl9dpIx53797tZVIPjs058v9evXqV/PCgzlxbHIt1vM52/LiI9pawCiGEyFUklylAKMaNG2crVqyw119/3Xbs2OFygaghAsjb3LlzXciQKNLpielypAE5+vOf/+zrEBqed+7c2caOHetyhEiRiie1vnbtWhcVBCdkBQEMmd24caOn6l988UW74IILXOioE6npadOmeZlEXS+77DJP6y9ZssSef/55+/KXv2yTJ092GXrrrbfsjTfe8LojjX369LGlS5f6uUakEeEh1Y0gIXQf+9jHzhCvRAYOHOhLgFAlQ/1pHxbKfOKJJ7wbAdv+9Kc/dQkkqvm73/3O2xJZvfnmm73PKRFj2ph6EB2lmwLnvGbNGvv617/ucjpv3jw/h507d5Z0H6DtWD9gwADv1oCo0b5vvvmm/dVf/ZX17dvXy3zllVf8hwPv1cc//nHvbgCUhQS//fbb/h7wPiGmgwcPtksuucSlGnGnvOnTp7sM05b8+KBtX3vtNS+TetC2IdNf+MIX/DoA6sMxOBeuK8SStrjhhhu8+wDHEEIIIXIVyWUKiBohC3zRk+5mIA3igOQgiUS1kAqiWIhBMgjUO++8YxdffHHJQB8EBZn5/e9/b5///Od9HZKBOHI8+nZSHhG6J5988ox+m0gX9Zk1a5YLG9tTNyQtBhwFSBIRxBdeeKHkXBAkBJS6/OIXv/Bjjx8/3uuHQM+YMcPrhnR+6lOfckGlvhyPc04ll5lCGddcc42LGVFfoB5E7hC3EHNAAO+44w4XsIhoIp1ELhFH2oJoJ/KO8F177bVeFudAm3KeCPyECRP8/GlXzolj0a60F+3EPkg3IPqIILLPQJ277rrLxQ855f3nPed9YT3vPe2yaNGiknQ/MkmbsT+SOHz4cD8WUoywUg8kH/HkBwFt/ZGPfMTrhljyQ4EfEIj1jTfeWOn2FkIIIaoLyWUp8KWPpCBvDFRBIiLtiQwQhUQUkMFE2AaZWL16tYsPcoJkxP5EOSMdyv8RJiQGGUJAEBSOndh3MyQH0QrpRCCRLJbEbakzEdZIq/LI60QGOT4ga9Q/pBdJRZKpI1E4zg+QJ4QoG8Qgn+ifCZwP0TzEk3ZIPF+2Y+G8OUdS2sB2rEP2oksAbYcwIoeso9xIzQPbhJQDbUg7UUbybAHRfYBIKMdlH95z1iHiHJ/yaD+OmfgjgHakDrQZ5fEe8V5Eej3S7Ygx5x3vM6/xiHin+rGSSPQFJoqbOFI/oIsAogrLly8vuR6Ihia2fXnUO31aHw7VQGFRkRUm9Leu7cT1zmNiP3NRfpvxeaM203V2LkgM9lQUyWUZEF0iAvWtb33LU8aIx/z58104brvtNv9/olzyZc8AH7ZDIIj8JQ5kQTyQPMpCNBDQmL4oxAfhQPAQ0GwTfUQRDaQDqB9pYs4VCQHqhFhR3xDS6oJ6DBo0yMWItiEaSWQYgSeCSF0jcst5EOWNaGQm8CFNmpoPbNqB40V/SMQWseT94r3jfU6eEYC6IYx0IyBlTlqd6DDpeQZ6UUfkkcgqZfBIJBQ4Ju3MtVNelJjILen4H/3oR6VeI/HB8MUvftGvrXvuucemTJni7ZgujblW095aZAt+vBzYs6fONSjXvlCbnWv4TmMR5ZNqrEUmSC7LgGgXIsaXMh9+zz77rMtYpMTLGnSBmFx66aUlqd8QGGQUAaKPZTIVHcSBTIRQ8Ij8lPbLgwsmeYRzRDeTR7pn49dLOpRV3xhwxGNiNDbVYybtxDGTI3/J5fA8kzZAbhE5flzEjwy6HFDG3Xff7T8oKJOoKhFxuglEvagL0lledJEfOwz8oe9tqignkop8f+9737N//ud/9r7DyDGSiainS/1mzdLeVmT3Myd++NUFuF7pcsTfBJ+ponz4u0eQ1GaZtxnZpBjLIEon5qyuDJLLMkC2iDgx0pe+cESv+LLmwz95RDfwnPWRwuYLPaYXghi1zIcCbx5lJ6Y2Qn54zvryfjmEFIacJI5UL41U9U5eH4/ZlsvEaF+ca5wvf/ylnW+qKCEL50k7ce4xMjtVmijaKVEok9uJbXifopxE4aVM/s/rpc1hyuvUnx8ORKdJXfMeE6EkrY5sxkh96sKPDvqWUh77xkj98kSZHzYsI0aMSFkHIl8xcIhBWldddZVVCH0AVwv59etbfgbdF3KduN75vEzsOy5KJ7oQ8RmYSVeXugyf4chl9OEXZRMzqVQG3f4xjQ8/+k4y8hgYCEKas7RtiXTS1w8BQCzoGwe8UfSB+6//+i9fxy8oBrLQB4+BK4nSw37R77EskBkkhYgYIgNEyyi/qqKO6ULb8IcdUUiidCFxdCFI53wDpJ30M9MJ0X6UBfSL5EdA8h8FH8K0E9tFNwaEj9R6QN1IYSN+vJZYvyiT94sPplSCyR8j7U6kMrZlHkzS+HQ5oEzqQf9QJJL3ifeM8vmyIGXOICwG+wghhBC5jCKXH8KXPF/4jN5GApENfunEXI2IB5OpIwqIG4NxGOjDCGXEgMdId5JGpzxeJ/1NmfxyYrnwwgt9O8pEQCgH2UAsEBeEBvlCtpAOxDNGIiMjiBgjkidOnOjlMB0QUwxxrJkzZ7r4cB5AH0Km80GGqQPT9hBBY/ofRk9zPEZusz1RWerHQBXOn/IQN8SK4xBlKy2qRt0ok7ohZTxnP84FyU5MaSNXrH/55ZddxKN7AefGvrQH58D5U1fOnemRRo4c6RHBuJUk5dIGCCJtR0o65o9MFmv2Y2J66sT2vCc8IoScI+8dbcEIfNLORBfpL8s6/s9+/P+KK67w943zo215BN4PpkbiuLxfPNJ+EIOOYoAQck13Ca4P+k5StxipTtQzcbJ+IYQQIheRXH5IzF+J0LAQwUJ+iHTFoBsWQEoi7Rn96GKkMvKESCAhzDXJtmyHKJIiJ52JHCEtbEcEDtlC6JAPZAuhjcnBkR/qgMCSNmJbBIzXkD6EiH3YHkliMArb8Mhx2RYxixHGMY8mcsXxqB8yxzlHFJAIIP8PweY5g4xKk0vKIDLHcWNidI5H+yGBidD/j20Y0Uz3As4hBg9x7EgfU16M8EaAkdvoM0jbsS/TRNFuTPdD2yaOCE+E9w/hR/yoV4zOju4LcY78gIiR5wyciVQddeI8EFSex2062R8x5P/sy/a8z7RtjESPAUIs7Mt1Rr0RVuoeAxnYj9tIxjUmhBBC5Cp5xTUtf1pNRP+/6MMHISGJkbfYlm1iW54nTikT20SfvsS+jDEtTZBYRmyTOPAEcYznEdWMfp1RLseJO8Ikros6sS3HiWMl15Nyo88l28ZdZdg2BvqU1lcToi9j4gCTqF/yIKGoQ/STjDrEY/L5QmIdEtsosSxeIyKJQDMpO+loIs2J71eUl3gelJH43iW+t4n1S7wW4tjJ9eM12j1VOyUOVog6J7ZBlJN4jpkSfS6ZgP7WW2/1ieIr3Ofy8cfN7rzzjFX/8uMf2tyJl1SsPHEWzQ4ftv+96SPWZt8HEXDnnnvMHnmkzrRW3O2KCL76XKYHf+N81vEDW/0H04NgDMEftVl6cH3xHUcXv4oONFbk8kNCzEobsJFIaaOrk7dJ537amQz3L200ZarRb8nbcpzSjpW8baaj6UKY0zmX8tqtrHolEiKcKFVEDEnvE4lEMvk/EU/OJ93jJsp7edukql8673kmbSCEEELkGhrQI3KeGHGOXNI1gIhi3BGpvEnJhRBCCJFdFLkUOU/MHclAGdLhkeomsphOJFEIIYQQ2UNyKWpNlwb6bKnf1rnjwplvWJfNW87hEeoWDQsKrNGJv9z2VAghaguSSyFEWkx54im1lBBCiHJRn0shhBBCCJE1JJdCiLPp0cPsrru4YbpapypgloopU8zGj1d7CyFyHqXFhRBng+T84Q9WfPHF3FfTKjbTWd0iccLgjNuL6b9+8AOzAQOyWykhhKgGJJdCiJQU5+XZgf/4D8vjLlWtW0swy+FkQYHfcYm2aljGHK0pYaJiosVCCFELkFwKIUrl9IABH9yhgfR4Be/UUFcoPnHCTu3bZ8W0labAEkLUYdTnUgghhBBCZA3JpRBCCCGEyBqSSyGEEEIIkTUkl0IIIYQQImtILoUQQgghRNaQXAohhBBCiKwhuRRCCCGEEFlDcimEEEIIIbKG5FIIIYQQQmQNyaUQQgghhMgakkshhBBCCJE1JJdCCCGEECJrSC6FEEIIIUTWkFwKIYQQQoisIbkUQgghhBBZQ3IphBBCCCGyhuRSCCGEEEJkjfzsFSWEqNUUF1d3DWp++yQuolzyot0SH0V615naTH+b5ZHnf2HVguRSCFEqrf/+782WLjXL10dFeTQsKrL2p09bfoMG1fqhnks0KC629qdOqc0q0mb8TdZT8jEd8utam/XoYfbII2Z8FlUT+sYQQpzNrl2Wt2SJNXj3XbPly9VCacBXVkO1VEaozTJHbaY2K5fNm81ee81s6FCz7t2tOqgDCi+EyJjXXze78kqJpRBC5Bpbt5pdc43Z009XWxUkl0IIIYQQImsoLS6ESIt1bdrY4caN1VpCCFHDaHrqlPXfs+eDQXI1AMmlECIt/s8tt9ifBw9WawkhRA1j3JYtNvtHP5JcCiFyi6K8PCuqCyMthRAixyisYTNUKHIp0ubEiRN28uRJf6xXr57Vr1/fH4uLi33h/w0aNLDGjRtbXl6eL9mAsgsKCuzUqVN+7KZNm/pxWDI9RmFhoZfDeRQVFZ2xP88pk+kqGjVqlLX6CyGEEHUJyaVIm4ULF9qiRYts5syZ1q5dO+vcubOLXggn6/r162eXXHKJNWvWzOUzm8detWqVvfrqq3bjjTfasGHDbNCgQRmXc/jwYVu5cqXNnz/fDhw4YE2aNCmRziNHjtjAgQOtT58+dv75538wJ5oQQgghMkLfniJtevbs6VHEt956yzp16uSC16VLF3+NaODGjRtt165d9swzz9jVV19t7du3d0HLRgSQYyOxSCsRUqKMmUC9t27d6su8efNcIIcPH+5R1qg/ryGcS5YssfPOO6/SdRZCCCHqIpJLkTZdu3b1SB8LcknkcMCAAZ5KRvZIXRMVfO+992zUqFHWokULl8tIQSN4Af+PFDScPn3aBY/HSK8TTWQ/Hjt27OjR0ZYtW5bsE+ly9kFgWU+0lCWV0G7evNnWr19v69ats8suu8z69+9vDRs29G0pp1WrVi7OW7Zs8Tpz3KgPZbMt61h4nTpG1wDqTl2jm4D/ceXn+3OWKIvtEiO6kZpnHeWzrRBCCJHLSC5FVkCQJk2a5JHF999/39PYR48etYsuuqhE2HiOkCFQpKDHjx9vI0aM8P6NpNvZjqgiUcoLLrjAVqxY4ZHQTZs22b/8y7/4dolSRor7hRde8H3btm1rQ4YM8bQ2wpuc0kb4ZsyY4XJ33XXXecQVmQv4P7KM5G3fvt2WL1/udUGUqQ+RTISU6Cb1euWVV+ziiy+2Hj16eBR0+vTpXlek+9ixY94eI0eOtN69e1uHDh1s9erVXtbcuXOtW7duJWJKeXQt6Nu3r02ePNn3F0IIIXIZyaXICsgUgoZc0vfy4MGDtm/fPn8NKWzdurWLFtJHBI8I5/79+z2KiNQRmSTNjtDxOpC2pgz2J1qaGPlkmz179riokn4nUoowtmnT5qyoZQzi4Xgcn+2TBwNF5BMRjAFJiB79SiMiyj5EY1kQQiK51Jt6sR1RVdYR1UQw6ddJWZRJvSiP1zknHhHr7t272969e23p0qUu27RdaZFXIYQQIheQXIqsgggib0Qm6b8IyBjrkSmkiQgmUT5kj/+TniY6iKg9/fTTLmTI5IQJE/x15Aw5RVgBmUPgtm3b5jKLnF555ZWlDsAhysn2RDrZHtErbVvkjgXYnv2oK3VCnqkH9SH6SJSUiClyyEAmpBBZ5Hjs8+ijj1qvXr38vBFLzoXUPlFPRHTixIkuvkQzX3zxRTt06NBZafNkIi2PXCfKdkB6nyX+j+SGHGcirHnFxTVmvjQhhBCZ4zO5ZDg+IVtILsU5B1FENB966CGP/nHB0/8RYUP0kgfnIHCkuCNieemll7rYIV9AtJO+kwy8ufXWW+3CCy/M6sj0ADFERr/zne94pJJU/YIFC1zsOGbz5s1d3OirSeSRdHr00Tx+/LjLKQv15pwAwSOVjqBG/1DOkdeRQQQ0Bhml4u2337Y333zTfvOb37g4poJjw3333efHuvnmm12+EeB0aUSdM24xIYQQNYXDR47Y8d27M96PAEZlZ0uRXIqsQuQNmUK4EDJki/6G0R8x0tsIUAzgSQbhitR0yBdE5A0ZZT3lE82k3yJyVppgxoAcyuGRqCrR1UQiCkhkkTohjtSB8yDyyjqOQ7SU5/SRRHg5jw0bNniqm22QOY6HVMZgIf5QA54jzYlp+ZgzlDqUNwoeGSfSe/nll3tUNRmORf9W+pfSTzT6obJfYh/T8migaZiEECKnyf9wIGqmRParUseudAlCJMgZsrVz505PcyM0yNqsWbNcAr/xjW94OhiB4oJnoA6il0zIVmkgZkQUBw8ebDt27PCy+T/7pUr9hqwioMgXaWzS2lHn2IfniDHRQ8qP4xDBZBuik9QZseT8gH6fc+bM8T9GUuRECNl29+7d9vzzz5dIY3J9EkeFs308T5XqTmTo0KG+3H777We9FqPnp06d6nL5la98xa666qqKXZ/NmlVsPyGEEDWCpk2aWNM2bTLej+/IxKBIRdC8JyIrIDazZ8/2kdsIDiOlGaATUwXxOpFDxIqLlv6WiGdFQAzpx0hKnAgjaXJGqBMdLQ0E7oorrvD+mfR5RICJnAbU5d133/UJ4l9//fWSiCr1ZcQ7j4xMpz9mzO0JnEuMguf8IlLJeSPOqaKLQgghRG1GkUuRNqR+SQsjTPSh5P8xUAQZo88hIJUMziF9zLakoNmGO+wggyGXRAnj/5SDpLE9kUgihEzxg7AhbjH6nH6GidFFwv6IHFFFZBGJjf6MyZCyBsSSiCd1jumNKIN17IdAJqaskck1a9a4gJLajwE/QASWkeLUjfNYu3ZtSUQzzo10OudBvVnPufB/2pDzZV8eqRdpeOoPGjEuhBAiF5FcirRBDpm/kv6EDKghBY7gIXVIH2lh+gPecccdJeKHVI0ePdrl7JFHHnFRo68kIodcIXiUi9whWUgXd/ohrXv99de7zJFeR9qYvgg5YyAPghbzUiKAjLZmkBDH4u5AyXKJqJHORnQROKKsHI+6xETmiCK3riTtTN0RVdYzbRACyfnxWmLkklQ7810+8cQTHkHlnBBWZJF6sQ7JRKpps8WLF3v7kabnNc6Hc2Md82AizXFekkshhBC5iORSpA1iRV9DJksnmoiMIUHIGUvIZPJ9xblPN9FMZDT2Qb4iXU6kjkcklfkqY7AOMsdxgEEpRB7HjBnjZSBnRBCvueYalzvkFIGLvpKlQbkIMJHVGNkdEsmCeLJ/3E2HJQbhEEnlGInlUxfqj1BzTnGXHdqDurEfdeVckGTkl7KpB2Iat6GkTVnHIrEUQgiRy0guRdowGCcmCs8EpIolHZC+VMTk5cmvE9nM5K42CDCCyFIayGZM0s6CMPIcsUYWEwfj8H/kkfktywPxTh6lDrRNpm0qhBBC1FQkl0KkkEvS/O+8844P8CFCygAlJj2PaZGEEEIIkRrJpRBJkAYnSsodgkjHE7kkYkvKPDFqKYQQQoizkVwKkUQM7mHKIxbxAT3377dhO3aoOYQQoobRd+9eq0lILoUQafHjZ56xogzuTy6EEKJqyGNgqtUcJJdCiLSoX1zsixBCCFEW6kAmhDibpk3NGAFfgfvSCiGEqEby8z/4/C5jVpRzjeRSCHE211xjtmyZ2ciRah0hhMglevUyW7TI7N57q60KSosLIVJ8MuRbcfPmduzTn3bRZHL3mtSfpyZy6vRpv1EAbZWf4vaj4mxOFxb6tF9qs8zbzG+NS4RKlAt3STtal9qsbVsmpv4ggllN1IFWFkJUlGN33OGj55tyP3UN5imTwhMn7Mi+fdaoXTvL//Ce9aJsTn/YZg3btrX8xo3VXGlQWFBgR/butQZt2lgDzbubFoUnT9qRPXvUZlWI0uJCCCGEECJrSC6FEEIIIUTWkFwKIYQQQoisIbkUQgghhBBZQ3IphBBCCCGyhuRSCCGEEEJkDcmlEEIIIYTIGpJLIYQQQgiRNSSXQgghhBAia0guhRBCCCFE1pBcCiGEEEKIrCG5FEIIIYQQWUNyKYQQQgghsobkUgghhBBCZA3JpRBCCCGEyBqSSyGEEEIIkTUkl0IIIYQQImtILoUQQgghRNbIz15RQojaRtNHHrG8rVvNmjSp7qrUePILC63F8eNWn7aqX7+6q5NTbZb/2c+aDR5c3dURQmQJyaUQ4mxOnbK8o0et2SOPmM2bpxZK88O0hVqqYm02caJZ9+5mzZqZ5eWpFYXIcZQWF0KczdSpZkOGmC1apNYR557PfMbsttvMiovV2kLUAhS5FEKczYkTZjt2qGVE1bB/v9nevWptIWoJkkshRFoU1qtnRXlKdogsffkUnjYlwIWonUguhRBp8duPf8JWDNKgC1F58qzY/uonP7EeW7eoOYWohUguhRBpsb91G9vZubNaS1SavKIiO9WggVpSiFqK5FKUSXGGHezzKjjSs7TjZFJechll7Zu4bfy/InWv6PkKIYQQtRXJpSiTkydP2sGDB23mzJlWUFBghYWF1rBhQ/8/r7Vp08Z69eplgwcPtubNm1v9Cs7vd+DAAdu9e7e98sorlp+fbx07drQrr7zSWrZsmXYZS5cutdWrV3s9qNPAgQNTbodMnjhxwo/32muv2dq1a+348eM2ZswYf/306dO2d+9ea9WqlXXo0MGuvvpq337Hjh2+PULZrVs3u+SSS/z8hRBCCPEXJJeiVAFj2bp1q+3cudOOHj3q0te4cWNr8GE6K15v1KiRde3a1Zo2bVphuaxXr54vR44c8XIROCQvE6gjwoj0IoVlQfksHHP79u0u0BdeeKGv4xwQaAST8saPH+/7sJ76Idic86lTpyp0rkIIIURtRnIpSqWoqMimT5/ukb1rr73WI4FIZGL073vf+55t27bNOnfubO3bty8Rz0whStisWTMbNmyY7d+/3yOJ5woEEjmkzpwX0U6E8ZZbbnGB5Nw4/h//+Ed75plnPILas2dP69u3rw0dOtTrJ7EUQgghUiO5FCk5duyYrVq1ykWKiOXw4cOtRYsWZ/QxRCQnT57sUb62bdv6dqSO33//fZczJI3XkFBS1ZMmTfJ9iBbyGmnsNWvWeNSQ7YiKsj+vJUoqzxcsWGD79u07QzqR35EjR7rwEn1ct26dl9ekSRPbs2ePbdq0yV9v3bq1L+n0lWQ95XL+RE6RTSKy1C8VRDbffvttbyu2e/DBB/18WD9jxgxr166dderUySZMmODnRNnUk9eJ+lJXxJaoKxFSIq5ItvpyCiGEyFUklyIlpJYRNh6J8tG3EHkMIn3cp0+fDy6k/HyXRvpiInbAc2QKkSKdjBxSDqJ2+PBhlytEi/KRLECyKDfkEsFDKNkW0Y3tWE+5iBsyxvPEhXpHH1HqUB5sR3nUmf8TjSU6iewhjaVFZCmb+iGXyHGs4/hbtmxxsUaOWRfr169fb4cOHfL9aEfqGbIJnI8QQgiRq0guRUoQng0bNrgIJkcsA9Yhd4kgf927d7fRo0f7fjBr1izvt/nmm296v0YG67z33nsuZET5vvrVr7rAIXM//OEP/ZFIZwz0Wb58udeF1Pntt9/u6xHYRx55xFauXOnSyaAb1hFxJEo5aNAgGzVqVFrvLvKH7D711FMlAsgxBwwY4Kly0ucIcCpJpSvADTfcYIsXL3ZhBKK4tBvR3sR+o4gmdX3xxRdtxIgR9olPfMJFmnqz/zvvvON1v++++3RVCiGEyFkkl6LCpBJOZIkI3pw5czwCSMSPPptEJBFPxA3h2rhxo0cJSWkT9YzBNV26dPFtA2SR/REw5G3atGm+nqgfryFxPEZ9EuuUbmqZ7ZDbK664oiRyiQQTVV24cKHXiXqWNkgo+TilHZf6b9682SWTlD0j4zke58L5Ed0NqS4NuhIgoi+//LL/AEiGuhNxhm9/+9v29NNPe0oe2Y/+sunQ4OhRK7smQmSX04WFdpjbQNbTXaDKgr9x4HOSzxJRPhEYUJulBwEevpsqg+RSpARBQgyJ6pU2ajvSvYn7cFESBURw2A+hRJoiPcw69iEiiYQSjQwpZCHaGdFD4JFR2zyyP30ygW0QsbL6Q2YCZRCpRHQ5DudBlHH+/PkuhNS1vBHo5UEbcN6RSt+1a1fJucT5lCeXRHqpz7x581IOeqLuIecrVqzwbYgk9+vXr6RN06FehiP1hagsXLt+jUouy20n4LM0RFOozapzfutUSC5FSkgD058SmSOqlupiYx3ROMQoZHTJkiX2k5/8xL72ta/56HLmqST6R/9D0uAVmbCcbZm3krklr7vuujOOz4crjxWdAqk0OBdkkjaIuTNJtZdFchul6u/JuZD6JmV/1113nfEakcjy2oVBPxdccIF98YtfLPXLmejunXfeab/85S89Gkvb8Cs0o0FCGcwvKkQ2iPltJZdlEz+4+WEe/bxFem3G91H02xelw/iIyv5wkVyKlPAH2L9/f5dFImykiOlfyQcacOEhQ0xVRL9DxCvkhoVIIIIag3wS0zd8iSCKlIu8ImAxryYDW9g2PjSpR48ePXwQDOWFRFImdaIelMfxI7UekUcieEQfKYs6pktIGPUgUohklvYhzvFiBDxw7jynXkg5+8W+CCr9N6kX0VzqyDnFaHHamnMhJV/efKCJg6uS5TYGH/FI+RVCdx4SVUxeXHe69tJvM7VVRu2U3HVKnDvUuUWkBDkkncpUOsgRqVh++SFB9HHkkRQv/f/oPxhROv5w2ZeUTUglIsUSI7mRIPr/IUnIH69FufxiIq0e20Y94k5BbEeql20QTkZYI6SUiXDFsdmOshDYGGgThMhSZ8qK6CfHj4X9o05EGpFcykUIEx9DbmNyedok6hgjwmPbxNR6pMgpn/OnbelbSl9UIYQQIpdR5FKUClFCRksjPkQoGUEd/SiRI/5P2pXIIpFIoN8iqes///nPJRFKopOIFqLHgBQYN25ciaT9/Oc/9zJZIuJIn00ieaTDzz//fJdQpgf62c9+5hFARI79L774Yk+/x2AgZO+5557zFPzcuXNt4sSJKacRQvqo1/PPP+8pe2SV0ecR+aS+iDJlMok65VLmokWLXAp5zqTqtAOpc9LVyC71QyA5F0QX8eU4Q4YMcaEm7Xfvvfe6kP/qV7/y5xwHyaQtMxl0I4QQQtREJJciJZE6QJKIXtJHkOgh0UmkMSKVyB+p8kgLsy0ySNSQMujjgnwRxUQa+T9ChfDxf6J5RO54zhL3LOeRu+IQNeR4CCRpebZF2iI9HmUBg4GQWSZrB9bzPNX9yXmNeo8dO9a34ZjUhzrH3YfiNpCUG/1PuJ84ryWeO7AvdSXKGvKLwMa21J31tBP7USap+pgwHamOOTuFEEKIXEZyKcq+QPLzXYSINKYDk6SzpAOSxZIO9P8sjxhtXV70LwYfIcLIYrpQNpHMVPTu3duXdKB+LMyDKYQQQtQ21OdSCCGEEEJkDcmlEEIIIYTIGkqLCyHSol5RkdXX5OoiC+QVF1ueVX6iZiFEzURyKYRIi4///ndW0LiC82YKkUT7PXvUJkLUUiSXQoi0aLd/n1pKCCFEuajPpRBCiOpHd04RotYguRRCnM0VV5i99ZbZsGFqHXHu+cEPzH71KwmmELUEpcWFEGfTrp0VX3SRnbroIstjIvsGDT6497MoFSbLP3X69Af3mlcULrM2u+giqzdypK4uIWoJkkshRKkc/Pd/90nnmXBelM3JEyf8zlTt2re3Rg0bqrnS4GRBge3bu9fatmtnjdViQtQaJJdCiPRQNK789ok2Ululj9pKiFqH+lwKIYQQQoisIbkUQgghhBBZQ3IphBBCCCGyhuRSCFEqR48etWPHjqmF0uDUqVN28OBBO61bZKZNYWGh2ixD1GYVbzP+RkXVILkUQpTKiy++aNOmTVMLpcHmzZvt4Ycftp07d6q90mTbtm3eZjyK9NixY4e3GdebSI89e/Z4m61fv15NVkVILoUQpTJ37lybP3++WijNL7AZM2bY/v371V5pwtRN06dP90eRHgcOHPDrbPfu3WqyNCFqSZvph1/VoamIhKhlMC9lfn6+HT582IWnohQXF9uSJUusSZMmtnfv3qzWsTayadMmmzdvnm3ZssV69epV3dXJCYi+vffee/7Yv3//6q5OTrB161a/zrjeKvP3XZcgMs51tnHjRrVZmt2h6tWrXOwxr5hvECFEzsOfMn2K5syZY3/3d39n27dvt+PHj1f6Fz+y2rJly6zVs7Zy8uRJO3LkiLVo0cLv0iPKh+uVH0Fqs8zbrHnz5tZQk/WnBf2gDx06ZM2aNbNGjRrpT7McrrvuOhs/frx94QtfqLBkKnIpRC2CD4IePXrYxz/+cdu1a5f3MfrDH/5gU6ZMsUGDBmVcHvsiSnfccUdGH+QPPfSQR+8mT56c8THfeustW7hwod13330eNc00Zfib3/zGLr30UhszZkzGx37mmWf8i/vee+91qc6EdevW+f58MHfv3j3jAQf0CevcubNdf/31Gdba7O233/YuDJ/+9KddOjKBL13abMKECXb++ednfOznn3/eI9uf+MQnMv4iIpL05JNP+nWSabSXW0f+9re/tbZt29pNN92UYa3NI1mzZs3yNsv0xxORnV//+tc2btw4/xLOlJdeesmjaZ/61Kesfv36Ge1LZPyxxx6zK6+80vr165fxD9BHHnnEmjZtah/5yEcyrLX53+XMmTPtk5/8pLVp0yajffmhS5uNHDnSJk6cmPGxX375Zb9eaLNMf7zRT5XPsssuu6zKPgcDsj+vvPKKfya3b9/eMqGgoMDbbMiQIV73THnttdds5cqV/lmayQ+RESNGWJ8+fTL+DExEkUshahl86SJ4fJEgHJMmTfIv4Uw/GNmfffm1P3Xq1LT3Y3T5qFGj7IorrrCf//znGdf/G9/4hu+3ePFi69ChQ0b7rl692saOHWvf+c53/Fd3ptx6662ediT6m+mXPoOfbrvtNv8SpN0y/RI577zzXFYQvUz59re/bd///ve9zbp27ZrRvqRXeb/++Z//2f72b/8242N/9KMfteXLl3uqNtMvffrB8cMHQb366qszjuDRXsjCn/70pwxrbfbDH/7QvvnNb9qiRYsyFlvEEEn68pe/bF//+tczPjZCyw8CZC3TSNqbb77pbfX444/bjTfemPGPGH5E8CPm2WefzbDWZv/zP/9jX/3qV13MBw4cmNG+pPCHDx9u999/v/3bv/1bxsf+3Oc+5/1zeb/4TMqE6vgcDPh7/qu/+it75513/Pwz/bHMPvyN8fedKVyf/Hjjc6FVq1Zp78ePxFgqKpiKXApRy+DDIL7k4xFRyjSFxodqfLhksm9M98G+FUnbhdRR90z3r8z5QuL5ZiqX9HONOlSkrTluZdos3vfqbLNM5bIybcYxK9tmFT12bF+ZNqvosaONabtM90Uuo90qUu/KvF/sw3Er2mbxfrFvVV7jFf0cTG6zirxf2WizqHdVd6GQXApRy0j1SzO+UDIhumPHfunun7h9pdIqFdi/Oo+dqh4V2T7X2qwyda+ufZPLqej+2di3Kt+vxH2q6zqrjmNXx+dgTWqzbOyfKZqKSIhaTER2qvyDpRLHjDpX5tiV2beyoyRzTXKq+/2qDNVV72xco1X9N1kTzruy13iu/m3Wq6ZrpaI/YLKBIpdC1GI6duxoDz74YMYd/ysD6R8GxAwePLhC+19wwQV24sSJjAfzQOvWre2BBx7wDukVgcE4zFNZHTJ+zz33VHgKI/qZfuYzn8m4LxowAIh+cPS7rAgMxqG9M+1GkI02u+uuu6xTp04V2p/z5bwZqZ4pDIihvSsyAAroj9y7d+8qbzOu69tvv73Csz/Q/++zn/2s/51lSuPGjb2v6YUXXlihYzOghc+zSDNXZZsx+KmiaeXBgwd7m7Vr1y7jfemPy+Ap+hZXhEsuucSv1eqYVUByKUQthi9ORmZmOjCmMvCFiSBW9EufL136bVZkOh+ElA/UTAe1BMOGDfMBSdUhl4hKRb6AoGfPnnbxxRdX6EuEL332zXSEe8BI1m7dulV5m3E8pLqiosT5cq1UZGoa9mFgDO1eERiExHtd1ZE42oyBY7znFYG/K9qsIj/8+HumzRiFXBEGDBjgn2dVLeQwevToCh+3c+fO/hlckR9+iDSzEVT0RydBhYr0H88GGi0uhCh11DlfBnwoMkqzutJ4ucJzzz1nN998s0//UZFpQ+oiTNFC5JNRuNdcc011VycneOONN3yqLaa94noT5cNI7YsuusinFGLktTj3KHIphEgJMnnDDTdoouY0IYpF2o9IhUg/Esa8hUQ+RXqQEeA6q2jUtC5C5obrrKJRU5E5kkshRJn90qq6j1OuwmTepAwzmU+urkPfPVKGmU7IXZfh+uI643oTNbd7UF1HaXEhRNrTcIjy20rtlT5qs8xRm6nNcgHJpRBCCCGEyBqa51IIIYQQQmQNyaUQQgghhMgakkshhBBCCJE1JJdCCCGEECJrSC6FEEIIIUTWkFwKIYQQQoisIbkUQgghhBBZQ3IphBBCCCGyhu7rJoQ44+4fJ06csP3799uGDRtK7iteUFBgffv29VvPNWnSpM7dsefgwYO+7Nixw+rVq2cNGjSw48ePW6NGjfwWhtwbO9oKeG3Tpk129OhRO3XqlK+j3Zo2bertSBl1icLCQm+H2bNn++1Eu3TpYj169LDGjRuXbMN1F2128uTJkjZjoc3q169vdeVvcM+ePXb48GH/O6S9Tp8+7dcU11nLli391o/8DfJ3uXHjxjPajDblOuM+2nXh1q1FRUV+fS1btszbgL+t+HyiLfv37++3f2QdC9vw2Xbs2DFvP+DvOP4260KbVQVqRSHEGRw6dMjWrVtnM2bMcJnkA/rAgQN2zTXX+IcvX/Z1Db7saZMFCxa4RDZr1sx27drl7dOrVy//skc4+fKivRADtmUbvsRYz/2z27dvbz179izZtq6AHNEmTz/9tMvPRRdd5G0RckmbIUjz58+33bt3+/9pH8Q92ixRGmortAOytHXrVtuyZYtfc7QR4s21xD3F43pjW64trrOQUdqHa7Jdu3bWvXt3F/La3maIJe3z1ltv+XWDKHKt0I78oOEaQhyRRtoMSV+4cKFfZ9FmCDtthrzXhTarCiSXQogS+EB+5pln/P+TJk2yQYMG+bq1a9f6BzLRgfvuu6/OffjyRb98+XK7+eabS6K3fKG9++679uSTT1rXrl2td+/e/qWPGBAZmTdvnt12223ehjB16lRbvHixP+/cubN/mdUVVq9e7V/+fMETRUpm27ZtHoF777337KabbrJhw4b5+unTp9v7779vAwcO9Ggnolmb4ZpCeN544w2XyE984hP+t4YkHTlyxKUphHz79u22efNmv86uu+46Gz16tK+fOXOmC2e0WceOHa02QzusWrXKfwATraUtaDOup+eee84WLVpk+/bts/PPP9927tzpf8u02dVXX21jx471Mrg233777ZI269SpU3WfVs4juRRClEQASBPx4cuvfSIfESEhlcSHL6+zEL2rK2lKQGpIr/FFTRSE8+cxJJOICY/AFxhREaKbiCgRS+D/iAFCwH51QS75YbJ3714XJq4j2iQxFR4QlWNJ1Wa0Fdckj7VdLskacK78LRJh4zqiDSEiuVx3wGtca6najG34kUNb13a55LqivfiMisgtRMSXdoz0NxFeZJQ2I1qZ2Gaso82IfEouK4/kUgjhEB1BkuIDlihACCRROT6kEQAiKESf6pJcDh061BeI1DdRONoJ6QnpBqKW9M3s16+ff2FFlLdDhw6edluxYoV/qdHFoC6keNesWeNyyRc211cquSTKxHVHmzRv3rykzZBJ+mYSmUIGEPzaDLJIdJvrhjZ78803/bqizWiLCRMmlFxT9E9l4e+Utok240cL3QiIFrNtRM5rK3Qx4TzjbzBknM8zug3wPNqGH3Zca3yeIZSxnh/RRIrJ0PD3PGTIkGo9p9qA5FII4fDBTPqIqBxfZonyyIcw63iNSFRsU5eJiBySyRcT6bSIPiFRiCRffAFfWnwJ8qWPqNd2iCTxQ4S0JF/mdLMgaoR0JkObsW1ym3GNRZshCrUdrhvaCNEeOXKk93Pm+kKI6CLA3yHiOGLECG8vrr9UbYagI/V1oc340RbXCKnx//7v//buA1xn/E2OGTPG2wxoM6615AF4/EjkBzNyyXsgKo/kUgjh8AufgRd8MKcaPBEd3YkIpBKE2kxiW3DutBNf+KTdBgwY4FEQvqCAFB1L8sAA2pR17BvRldoMX/SIEqJDOpc2og1om2QS2yxxJH1dazPOk2uK8ya1TbQScUSIuL6IbPIcuYw2Qz5La7NUbV1bMy78XdI2SCNtwPkjkxCfV6VdZ/yd1qU2qwokl0KIlNQ1gcykfxdR3ldffdVTvR/96Ec9zR3RkrpOtAGRJAZOMAgq+pcmSzpLXRscVhZcWwgOkXAGfcUPFtLew4cP9wFPMeWQ+AB+wNCVgEFhdAG4/fbbfT1RyMcff9xT4RCDxETVILkUQjgxZyNfXkRPiBTFr/uYwoMoAf2TElNKdQXagPOnzyRfZuPGjXMBYMBE4tx4ROpIR5KyRBSCGPgTA3tqKzGtEPOC0s1i1qxZJdPD0HeS64rBKLQHEkU/Qtos+hnGvKCAxEeb1YUpsGiniPAmEpG1mNMRaC/arbQ2Q0jrQptxjXFdMQAxuqZE+9CHd/369R5FRy5ZR/qbiGaipEcXDtosBkyJyiG5FEJ88GGQn+8frHzB8WXGlxZfXoBYsi5GSde1iYbjS50oCSNOaQ++zJBxoK348ufLi3XIJV9oiV0IWMcXGFG82v4FxjnzJU5kN+YXpC1ox2hLnocoIVS0IW3GF31im7GeHzS0bW0HGSQKjjAlXju0GTJO2jeimbQZMkSbIZSxLdcmaXTaLP5+60JXAq6zxPlj4/OKayg+r2iv0tqMH0O0fV1os6qgbn1DCCFKhQ9mhIDRp3wor1y50n/t88VGZIAv95j2pK6lMmMScNJsjAKfPHmyz23JlxLCyWTXtAvz5pGa48uM+UKJygWk7diOtB371la4NriOJk6c6EuASPIFziMRpssuu8y/zNme+QW5/p566imfjzCgbRmYcscdd/ggjNoOkfBRo0bZo48+ekYUjkgk107MOACMnOc645pkn4CZCuiSwHXGD6DaTvRNRciRxgB55PqJzzWIOz099thjZ6TJiaTzGUebMTuBqDySSyGEw5c86bhLL73Uv6C4WwpChFwyBRECwJdf3EatLsEE6kuWLPGUOPMQLl261KNMSCdfYrRNRNZIkyNQTGfCdsgR7YUgIASkgmtzdCTVtUG/N9qQQVC0DRKAjCM/tB3SxHU2ePBg/5Jnih3KQUajzVJNvl7bIOqN/MSAHX6gRPSNKBvr44cJQsU6rjPEE5GizYhaRpsRpavtINvcuej111/3acBefPFFX8+PQa4fuq/EaPHo+8t1xrXIDRAiSxNtFtkIUTkkl0KIEvigJTKHZNJXiXsbxyTqiEB8SNc1iFAiRPSVRChJjScOSiEKEt0JkEy+xIgAExHhyz7xVoY81rVuBXG/etoo+vIi2zFVTrQZkSXajCXxVoa0WeJ0O7UVri+uDdqBa4x2YF3cPhSxjAm+idiR+uY6i23jVoZsR5tFCr02wzWCgHMnJ/5O42+Tv1N+xBGJjGgvbcb1l9i+EWnnhzNtXJv7Q1clecUa3iiE+JD4OAhpOuPDIiFiWdcil3whpWqT5LZJHABVVhvWtfaLCdUT2yPaSm12dluVdq1FW8X1o+vsL59ZpU1VlTzlkNqsapBcCiGEEEKIrHHmfAdCCCGEEEJUAsmlEEIIIYTIGpJLIYQQQgiRNSSXQgghhBAia0guhRBCCCFE1pBcCiGEEEKIrCG5FEIIIYQQWUNyKYQQQgghsobkUgghhBBCZA3JpRBCCCGEyBqSSyGEEEIIkTUkl0IIIYQQImtILoUQQgghRNaQXAohhBBCiKwhuRRCCCGEEFlDcimEEEIIIbJGfvaKEkIIIc49q1atsrfffttGjhxpHTt2tK5du2a1/OLiYlu3bp3t2LHDFi9ebM2bN7f27dvb5MmTrV69zGIyhw8ftvXr19uyZcvsyJEj1rJlS7vwwgutV69eWavvli1bbPv27bZw4UJr1KiRH+O6667z/wtRHUguhRBC5BQHDhywlStXWvfu3V38zgVHjx61nTt32nvvvWft2rWzHj16uHRmyunTp+3gwYO2fPly2717t3Xq1MkGDx6c1boeO3bM9u7d63WlPRDuq6++WnIpqg3JpRBCiJwCqUSehg8ffk7kMi8vz8tu3bq1vf/++y6EFY2OUsbFF19sGzZscNk7F0Lcv39/69Chg8tlixYtvL7169fP6jGEyAT1uRRCCJFTtGrVygYMGOCS1qBBg3NyDNLfRB2JNjZp0sTT4khnprAPZRG9JC3euXNnLy/bdSWqSl2RSiKXmabvhcgmilwKIYQ4C2SF5dSpU1ZQUGBFRUUuSsgcETheO378uD+yvmHDhpafn+9Sc/LkSSssLCzZJ9LJvI78hBCyzYkTJ1zi2IbXKJtHymA9ZbA96yg76hJiyXr2ZR3lsV9IIOvYh6Vx48Zpy2HiuZNupk5t27YtKZPXqHeq/RBHjhfHirIOHTrkcokYUwb/p75xXiGciXXn/KlDtHGcD20d+8Ux2Hbfvn2+jjS+5FJUJ5JLIYQQpfZtXLRokb344ou2efNmHygyZswYu+GGG1xmfvazn7nMNW3a1C699FIbNmyYR/jeeOMNH2Sya9cuFyEECRk777zzrHfv3jZixAgvn22eeOIJW7JkiYsq/Ro/8pGPWJ8+fWzq1Kk+cIdo3NixY32/Ll262FNPPWX79+/38r75zW+WpKu3bt3qdXzzzTf9mAgX9SdNTMr43nvvzSjKSZ9L9kfY2rRp4+lsBI/1rHv22Wf93EP8QqY/+tGP+vGaNWvm5dBOiCR1Zr89e/bYggUL/Ly2bdvmkcxu3brZ3Xff7YIZconUMhBo9uzZfq6cE/WhLnQJ6Nmzp78f0eeSyCjH4L2grSSXojqRXAohhEgJ0T7E56KLLvKR04gUEUMkCmFEYIYOHeqChNBEX0KECuljRDRCF9HPpUuX+v+HDBnikTfk6Pzzz/eBM4gokc2IfiJkHLtv375+DCKHMWqb40NE81jmzp3r8oW4RvQQEVyzZo2LXKaDcSiLaCPHRNhi5DX1Z0GEWcdrwDGQZfpWcv70gwQElNcioso+AwcOtH79+rlosv3q1att06ZN3leSPpqUg1gyUp125Xx4LzZu3OgiiUBfe+21JXLJiPQQS5ZMorRCnAskl0IIIc4COUFUiCIijwgNgob8IFfIEv8fP368y1LIFxLJvkTW2BfJQ/5Y/8wzz3gZRPlYTxSOiCcRSp4T7UMuYxsioZSNZCKjHJcIIttwvNiW9cglx5kyZYrXKyKmSCKCmSnIGnJJWcgd5QFlUjfkkPQzC3AORA8RQM4lUS6RZ/ahDGSV15Bl5Pf3v/+9R4eRTF5HGNeuXetTF7Ge6Y84Z+rA4KIVK1Z4O44bN87FE6gnkU725T2LugpRXUguhRBClP4lkZ/v0odEEk17/vnnfT5FInf33HOPy1XifIrR/3HOnDn2wgsvlMglUoZkEc1M7JMIlI3E/e53v/OIJdLEOgSVFHNi30IifEBEM6KiMViGCB5pZFL3RAERsltuucUjiZkO/GHeSIQNQY4Ud7QHzJo1y4WZskNGOT+OjUgGpPuZM5OIK/I3evRorwvnT7msI3XPvgzE4XyffPJJl0/qjtgTiQTaCDklvY5QUjbnSASUFDttyzZCVDeSSyGEEOWOdkb4EDgihJECR4AQyxBFBIf0OWLGeiJ0yFj0U0SmWJ/cHxCpIsIYg4FY6F+JdIXMhVxSDuuR2hgghHwR4UTQEGBSxwycITVP1C8G42QCwkq9kT3qjCDT95EIJVFG6oAwhlgjkJw3kcPE0eDIL2lxJBLhjfZK7KuJoHIulM+2tAXnRR3oShDHQHZpX9qR6GS0I1LNtrRJpOmFqE4kl0IIIUol+ioSKUTsEEykilQ1kpM4GhzxIpWLZF122WU2adIkFy2e06+Qic+R0uQ5GBG4uHsNUT0WxDBxu4iIIl/IJBG96KOJSDKXJOnv119/3aOmQP9LBr8gXOnOLRnngsgRHSRyyfGQQKSPshmQ88ADD/hrtAPMnDnTU9aILOIZ5SDKCCH9RpPnyozuAsgwbUkkksgskkkklPQ4IhvyTlm8FgOGIv2NWFJfBj4lRlmFqC4kl0IIIUol+j++9tprPiIbgUHiEB0G+sQ2POcuNPPnz/eRz0QSI52LlCFKRO4Qo2TeffddH+lNH0sigAxkiZHeEbUL4UKkkLoYLBTTGXHXGyKlCC0DYpA0RpYTzSMyiHxmMrE4UVDqEGlxxO+tt95yCSaqmjiBO69RNyQa6U08R16jHybpcvqYJkY0Y7ARksm5I7NsS7lsT7eDxO4DnEdMt0S0N3FkOQJLNwKlxUVNQLOsCiGEOIuYn5GUK2JIhBBpQqqQG0Z3E8nk/4D0IFJE4ZCjSP/yOuKF8CGLLAFRO4SMY5DipWyikOyDHLI+QCARS+qBtMa0PQggkUTEi8gncod4EiWMumUyLQ/nQTqcc0H6EEIihPyf40cKm+Mjt6zn3BA82ovzi9Q0daY9WGLezsS2IpLL/kQ/kcLoNkA5HJNjx6ChGABEm1B+DGaibMpCVtk+hF6I6kRyKYQQ4gwipcsj4jRt2jSP4E2cONFHLxMBJFJGGhzZiUm8kSaWxP0RMqKSRCORHyQpcWLxefPmuRghhdddd53feQdBeuedd1w8EyWX50gYAop8IZdI6MMPP+yRxjgu25C6R/44HmWXNzVPHCemDkIMkdIYUMNryHDiYJ04b+pKxBHpC0mEmNuSMpFgljgG/3/11Ve9jhMmTPBzoq5EJGkPhDEENzF6zHtB31ZeizsIIZ1sw75Ki4uagNLiQgghzgApIjLJZOgxByVTBiE9MVclsscE6AgnQkganD6OSNBzzz3nKfAYwEKEjggbk6UjS4gfqXDElb6YV155pa9jMA7lIksxeThiioAhb6SRqRvbIWak6IngIYBM9E40EblCAoHR1qNGjSqZAL08mP6H4zEanhHYCCyTpZP+p36cK306OZ+f/vSnHqVEPOkXiURz7qTOo08kg58iXU2dkHGOEZOvUzeitaTzOceIPF5zzTXeDr/85S9dVuP2jtGtgLamnpSN2HJ8ymR0Pul0uggIUZ1ILoUQQpwBIsaCuJFqRngQKWQrRoGTqo1bQSI/bIvEIVEIVKRueR35Q6Loq0iELspGBom2URbrKYd0NmUgVxybKCkL5bEd0oZkRf9JUvDIVsyvSbkILMcdNGiQy1i6qeI4D46BMMctLaNczoMILnIdr9EGnBf7EHnknOLWjNSZ41Nv5JT1RDL9yzc/3+fKpM1irsy4rSP1RhyJUMak8sBxaC/KjVtfclzqRBQzcQS5ENVJXnGmty0QQghRq6nI10LiqPGaRib3FK9OEu9HXt52ZW2ju/OI6kZyKYQQQgghsobS4kIIIWodEdmjr2f0wSwN0suR8ldaWYjKI7kUQghRa2FwDgOBykoj01eSuw7RzzLx7jpCiIqhtLgQQohaR8gkU/Uw5VFZcknEkoFBDCBKvN2kEKJiSC6FEEIIIUTW0JwFQgghhBAia0guhRBCCCFE1pBcCiGEEEKIrCG5FEIIIYQQWUNyKYQQQgghsobkUgghhBBCZA3JpRBCCCGEyBqSSyGEEEIIkTUkl0IIIYQQImtILoUQQgghRNaQXAohhBBCiKwhuRRCCCGEEFlDcimEEEIIISxb/P96uViNeCS3FQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cv2\n", + "import os\n", + "import random\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def test_yolo_labels(img_dir, label_dir, num_samples=3):\n", + " # Get all images in the directory\n", + " if not os.path.exists(img_dir):\n", + " print(f\"Error: Directory {img_dir} not found.\")\n", + " return\n", + " \n", + " images = [f for f in os.listdir(img_dir) if f.endswith(('.png', '.jpg'))]\n", + " \n", + " if not images:\n", + " print(\"No images found to test.\")\n", + " return\n", + " \n", + " # Pick random samples\n", + " samples = random.sample(images, min(num_samples, len(images)))\n", + " \n", + " for sample_img in samples:\n", + " sample_label = sample_img.rsplit('.', 1)[0] + '.txt'\n", + " img_path = os.path.join(img_dir, sample_img)\n", + " label_path = os.path.join(label_dir, sample_label)\n", + " \n", + " if not os.path.exists(label_path):\n", + " print(f\"Skipping {sample_img} - No label found\")\n", + " continue\n", + "\n", + " # Read image and convert color for matplotlib\n", + " img = cv2.imread(img_path)\n", + " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + " h, w, _ = img.shape\n", + "\n", + " # Read label and draw boxes\n", + " with open(label_path, 'r') as f:\n", + " for line in f.readlines():\n", + " parts = line.split()\n", + " if len(parts) < 5: continue\n", + " \n", + " # YOLO format: class cx cy nw nh\n", + " cx, cy, nw, nh = map(float, parts[1:5])\n", + " \n", + " # Convert normalized YOLO coordinates back to exact pixels\n", + " x1 = int((cx - nw/2) * w)\n", + " y1 = int((cy - nh/2) * h)\n", + " x2 = int((cx + nw/2) * w)\n", + " y2 = int((cy + nh/2) * h)\n", + " \n", + " # Draw a bright red box with a thickness of 2\n", + " cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)\n", + "\n", + " # Show the image\n", + " plt.figure(figsize=(10, 8))\n", + " plt.imshow(img)\n", + " plt.title(f\"Testing: {sample_img}\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + "# Set paths to your clean dataset\n", + "images_path = './datasets/yolo_dataset_bar/images/train'\n", + "labels_path = './datasets/yolo_dataset_bar/labels/train'\n", + "\n", + "# Run the test! (Change num_samples to see more images)\n", + "test_yolo_labels(images_path, labels_path, num_samples=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c193ea80-c417-4bd5-9953-aad32121c5f1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🔍 Testing Model on: 32916.png\n", + "\n", + "image 1/1 /Users/aryangahlot/Desktop/Coding/AI-ML/Spectra/notebooks/datasets/yolo_dataset_bar/images/val/32916.png: 672x1024 4 bars, 48.9ms\n", + "Speed: 2.0ms preprocess, 48.9ms inference, 0.3ms postprocess per image at shape (1, 3, 672, 1024)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🔍 Testing Model on: 8817.png\n", + "\n", + "image 1/1 /Users/aryangahlot/Desktop/Coding/AI-ML/Spectra/notebooks/datasets/yolo_dataset_bar/images/val/8817.png: 704x1024 8 bars, 51.1ms\n", + "Speed: 1.8ms preprocess, 51.1ms inference, 0.3ms postprocess per image at shape (1, 3, 704, 1024)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🔍 Testing Model on: 4260.png\n", + "\n", + "image 1/1 /Users/aryangahlot/Desktop/Coding/AI-ML/Spectra/notebooks/datasets/yolo_dataset_bar/images/val/4260.png: 896x1024 4 bars, 65.4ms\n", + "Speed: 1.9ms preprocess, 65.4ms inference, 0.4ms postprocess per image at shape (1, 3, 896, 1024)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "import random\n", + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "from ultralytics import YOLO\n", + "\n", + "# 1. Load your newly trained \"best\" weights\n", + "# Update this path to wherever your downloaded best.pt is saved\n", + "model_path = \"./train2/weights/best.pt\" \n", + "model = YOLO(model_path)\n", + "\n", + "# 2. Point this to your clean validation images (or any random charts you download from Google)\n", + "test_images_dir = \"./datasets/yolo_dataset_bar/images/val\"\n", + "\n", + "def test_random_chart(num_tests=3):\n", + " all_images = [f for f in os.listdir(test_images_dir) if f.endswith(('.png', '.jpg', '.jpeg'))]\n", + " \n", + " if not all_images:\n", + " print(\"❌ No images found in the directory!\")\n", + " return\n", + " \n", + " # Pick a few random samples\n", + " samples = random.sample(all_images, min(num_tests, len(all_images)))\n", + " \n", + " for sample_img in samples:\n", + " img_path = os.path.join(test_images_dir, sample_img)\n", + " print(f\"\\n🔍 Testing Model on: {sample_img}\")\n", + " \n", + " # --- THE INFERENCE STEP ---\n", + " # conf=0.5 means the model only draws boxes it is 50%+ confident about\n", + " results = model(img_path, conf=0.8, imgsz=1024)\n", + " \n", + " # YOLO automatically draws the predicted bounding boxes and confidences!\n", + " annotated_img = results[0].plot() \n", + " \n", + " # Convert BGR (OpenCV format) to RGB (Matplotlib format)\n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " # Display the result\n", + " plt.figure(figsize=(12, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " plt.title(f\"STEM Sight Predictions: {sample_img}\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + "# Run the test! \n", + "test_random_chart(num_tests=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e6ac6b24-fa53-463b-95d6-f6f24340aecb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🔍 Analyzing: ./Real_Test_Graph/hbar2.png\n", + "\n", + "image 1/1 /Users/aryangahlot/Desktop/Coding/AI-ML/Spectra/notebooks/Real_Test_Graph/hbar2.png: 896x1024 15 bars, 68.0ms\n", + "Speed: 2.7ms preprocess, 68.0ms inference, 0.5ms postprocess per image at shape (1, 3, 896, 1024)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtUAAAKSCAYAAAAd7ie/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYHMXRhr9TzjnnnANKICQUUCTnnJPBBhtnY/+2wTaOOGEwBpMR2eQMIgoBAiSBsoRyzjnH2/95u6/vVqu9u5V0gpu5eh+tdnd2prurZ27365rq6qxEIpGQYRiGYRiGYRiHTKlDP9QwDMMwDMMwDBPVhmEYhmEYhlEEmKfaMAzDMAzDMA4TE9WGYRiGYRiGcZiYqDYMwzAMwzCMw8REtWEYhmEYhmEcJiaqDcMwDMMwDOMwMVFtGIZhGIZhGIeJiWrDMAzDMAzDOExMVBuGYRwkCxcuVFZWlh5++OFDPvZvf/tb7Pr9gw8+cLbxHLjiiivUokWLIquDPqcO+tEwDKM4YaLaMIzDZurUqTrnnHPUvHlzVahQQY0bN9bw4cN15513us9/85vfOCFU2GPw4MG5Qiy/fSg/VcTxeOyxx9K2rX///u7zLl26ZGTLK6+8okGDBqlevXqqVKmSWrVqpfPOO09vvvnm136lvP76667vMoX+S+6rWrVqqU+fPnrwwQeVnZ2tKPHHP/5RL7744jfdDMMwjIwpk/muhmEYB/LJJ5/o+OOPV7NmzfStb31LDRo00JIlS/Tpp5/qX//6l773ve/prLPOUps2bXKP2bp1q77zne/ozDPPdJ8F6tevn/u6fPnyuv/++w+or3Tp0gdsQ2g/8cQTuuSSS/bbjjeT9iUL8YLAe/zTn/7Uiepf/OIXTlTPnTtX77zzjp566imdcMIJbj8GDzt27FDZsmWPuKi+6667DkpYN2nSRH/605/c6zVr1mjUqFG6+uqrNXv2bP35z3/W18199913SIIeUc1A7Ywzzthv+6WXXqoLLrjAXR+GYRjFCRPVhmEcFn/4wx9UvXp1jR8/XjVq1Njvs9WrV7vnbt26uUdg7dq1TlSzLVUI5345lSmT72epnHTSSXr55ZdduXXq1MndjtBGqLdt21YbNmwosIy9e/fq1ltvdR720aNHH/B5sAVSPebFCc5Fcr9dd911at++vf797387+9INBBC9u3fvPiI2FfXAg0FVuoGVYRjGN42FfxiGcVjMmzdPnTt3PkBQAyEUXwenn36681w+88wz+21HVBO6kYkIQ5Bv3rzZhYukI9mW/GKqqb9Tp05OnBJu8sILLxQYU3zvvfeqdevWru2EaTAwCXAcXmpIDuk4WPC29+3bV9u2bXOe61Ded7/7XT3++OPu3FF/CG9ZtmyZrrrqKjcYYTufEz6SytKlS50XuXLlyq5vfvjDH2rXrl0H7JfOfkQ8dzG6du3q+qpu3bruLsCECRNy20d7H3nkkVy7KaegmOr//Oc/ubY0atRIN9xwgzZu3HhAeAznZcaMGe7uCn1DqNJtt9120P1qGIaRinmqDcM4LAiFGDdunKZNm5Zx3HKmIHRTKVeunKpVq7bfNsQRwvrJJ590HnCYPHmypk+f7kJIpkyZUmhdCMOKFSu6mGpCVohHPhhee+01nX/++U4oEn6BZ5ywC0RbOhD8W7ZscZ5kRCLCjlCY+fPnO+8u25cvX663335bjz76qA4HymRgkTzwee+99/S///3PiWu8+wjfVatWOQEeRDdi94033nB2MOD4wQ9+4I4l9GXo0KFavHixbrzxRidiaSNlZgLlIY5PPPFEXXPNNe4uwdixY13IUO/evV1ZbD/66KN17bXXumMYfOQH4TG//e1vNWzYMHf+v/rqK919991ukPLxxx/v5y3nvCDg6WsGXM8++6xuuukmd95oj2EYxiGTMAzDOAxGjx6dKF26tHsce+yxiZ/97GeJt956K7F79+58j1mzZk2Cr59bbrkl7eeXX365+zzdY+TIkbn7vf/++27bM888k3j11VcTWVlZicWLF7vPfvrTnyZatWrlXg8aNCjRuXPnQm25+eabXXmVK1dOnHjiiYk//OEPiYkTJx6w34IFC9x+Dz30UO62rl27Jpo0aZLYsmVL7rYPPvjA7de8efMDjq1du3Zi/fr1udtfeuklt/2VV17J3XbDDTe4bZmCnR06dHD9y2PmzJmJG2+80ZVx6qmn5u7H+1KlSiWmT5++3/FXX311omHDhom1a9fut/2CCy5IVK9ePbF9+3b3/vbbb3dl/O9//8vdZ9u2bYk2bdq47ZyX5HOZbP97773n9qFdqWRnZ+e+5hxwbCr0OcfTj7B69epEuXLlEiNGjEjs27cvd79///vfbr8HH3xwv/5h26hRo3K37dq1K9GgQYPE2WefXUjvGoZhFIyFfxiGcVgQg4yn+rTTTnPeYTyuI0eOdB5a4pwPFcIC8NKmPvKbbDdixAjnXWZCIbqR5wsvvPCg6sTbiQe5R48eeuutt/TLX/5SvXr1Us+ePTVz5sx8j8OjTAaUyy67TFWqVMndzoRHPKDpwKtds2bN3PcDBgzI9SofDrNmzXIeZh4dO3Z0GVhOPvnkA0I4aBuhKgH67LnnntOpp57qXnOXIDw4n5s2bdIXX3yRO4GyYcOGbiJh8t2C4FUuCOrAE37LLbcc8NmhhLcwiZR4cLzopUrl/aQxaZY7GtxBSIbzkxxzzp0PPOKH2++GYRgW/mEYxmFDPPDzzz/vxA3Cmljif/7zn050TZo0aT/xlimEK3A7P1O4xX/uuec6UYxIIgPJRRdddND1IsR5EO7w2WefuTAFykRsEuKSbjLfokWL3HNyhpMA24IYTYZsKckEgV3YhMrCIIyDjBthMiWTNNPFtrds2XK/98RbE4NMnDePdITJmtiLXakimAmRmcTgEy5ysOE1+RH6PrVuxDLpEMPnydlRUttN32cSImQYhlEQJqoNwygyEDIIbB7t2rXTlVde6SbvpfNKHgkQ0ffcc4+Lse3evfshifkAXk688DwQ7EyaQ2Tj4S0K8ps86aMzDh0mDmYyGCF+PJmQ9g4v7uWXX572mOQMLlHlSPW7YRiGiWrDMI4ITDiDFStWfG09fNxxxzkPMIvC/OUvfylSWxDV+dnCZE0gp3Uq6bZlyqGEQxwqhItUrVpV+/btK1SUYy9ee4RochuZIFgYTDgktGb9+vUFeqsztT30PXXjmQ5w12TBggUHdbfDMAzjcLCYasMwDov3338/rZePuNtMQwKKCoTYHXfc4TzjLBJyMGzfvt3FhqeDDBgF2UI4A5lPWGiFhW0CY8aMcbHWh+N1htTUcEfKg3v22We7mGcEcyohHV/IC04cOZkzkvsvv7CRZKiD64X49VSSryNsz8RuRDN3SDjvycc/8MADLg6ceHLDMIyvA/NUG4ZxWJB+DkHF6ogdOnRwHkJWMXz66addfC8hIIcCadbyW3qcuoLgTIXUejwOFmzo16+fSylHyrWmTZs6UcdS2aR7IyczExgLWgGQeslzjc3ERrPgCmI7WWgfDEySBNLWMVkQ4ctqgkcKJoEySDrmmGPcRD/CZ/AoExPOhEBeA59hGxMzJ06c6CYtkgaPyYqFQX5oBjyI4Dlz5ri+JvSEPuYzUvkF26nzH//4hxu0EANOu9J52Fn9EpFOWUyYxWtN3mrCkDJdQMgwDONwMVFtGMZhwdLexE3jmcZTiagmBOP666/Xr371q7SLwmQCC4nk523mtn5+ovpQoZ1M8CNbxEMPPaSVK1c6EYt3+q9//asTtgXBREbyZBPP/fOf/9xNEGSSI2Ej5Ms+FMilzKCFTCYMMPDEHklRzYIvn3/+uX73u9+5iacI09q1a7tFVZLDaRDP7777rmsb2UV4f/HFF7s8z2Ep94Kgf4nPxpvMsvCsAkmIDYOaAGKabCJcQ+TFJs47nagG+hxxjdBnERrCSjiWgc6RXkreMAwjkEVevdx3hmEYRpFy1FFHOcFHOkDDMAwjvlhMtWEYRhGwZ88eF7KSDBMmSTHI8tiGYRhGvDFPtWEYRhGwcOFCN2mOGF5igFmEhfR+hDYw8Y8wCsMwDCO+WEy1YRhGEcACIkyuu//++12mDGK+yTzB5D8T1IZhGPHHPNWGYRiGYRiGcZhYTLVhGIZhGIZhHCYmqg3DMAzDMAzjMDFRbRiGYRiGYRiHiU1UNIwYkpp+nuW740Bc7YqzbWZXtLDzFS3SLTUSh++ORI5dPAd7omCXeaoNI6bwZbRv3z7FzSZyQcfNrjjbFuxKzeEdB4JdcVtDjWvQ7IoOcT5f+/bti5Rd5qk2jJgSpS+ig7EpjnYF4mpbOq9T1InztZidna04Es5Z3M5bsl1x+fuKql3mqTYMIzJE5YvVSH/u4nb+4mgTxNGmkmBf3OzKiqA95qk2jJgSxS+kTChVqlQsbcOmONqGPaVLl1Zcz1d4HSewK0rewYO1K27E1a6sCH4nmqg2jJgSRy9aFL9kD4a42hbEZ9wwu6JF3AcLZtc3Tzy/6QzDcMTRexFnu+JqWxzjWMHsihZxvAbjblciYraZp9owYkp2dkLbdmRr957SsctoEseQglzblKXSZUrHzC4/8a0M5ywuTsKEtDfHLq7FODk/9+4NdsXrzgnXIdejP1/xtqtUllS1Cn9z3OFTZCfMJnI88FE5XyaqDSOmTJop/ejPpbRqneJDIkuJnK+tiHzHZk5cbXN2+UGCMysutiX4Z3ZFiUSi5NjF0ynHS7d8V6pcMZrfKYkIZv/ISkTNt24YRqGs25jQGddLn06OxhdRJpQtI1Uoj/dC2r6TL9zDK4/vaMpDHO3c5Z4MwzBi9Z35559I373Ee66jmN8+keOBj8p8E/NUG0YMKV0qS5u2+td8D/XtJnVqKz32srRrtyIDPwStmknD+kknD5Ia15d27ZJmzJNeHyO9/5m0ftPBlVmtijT4aGnkcVKPThJ38D/+Qnr7Y+mTL6Qduwr/oTr3RKldC+nBZ6XFK9LvV7HiLtWtu1FZpUyuG4bx9bFje3mtXl1De/Zmue/L4i9F44OJasOIKeGLtHMb6f4/Sg3rStWrSv94SJGhfSvpgT9Ivbvsf/uyd1fpgpOlJ1+Tvv97aduOzMqrUU269fvSVWdJ5crlbT+mm3Td+dJf7pVuH+U91+kgPvGKM6Xf/UCqXkU6upt0/g+kLdsO3Ld581W65LJ3VKZsvFZINAyjeDNjenONeni4f2OK+mvFRLVhxBw8s43qSVUqeU9vVKC9v7vRC2rYuFlaulIqV1Zq1kgqX0664CRp6izp308wWafg8urXlv7yU+m8E7043r3Hl4fnuWE9H3f4i29LVSpLf7pX2rY971h+l1o1lX50la+zamUv8tlGO9KJ6lKlslW+/B6VLWei2jCMr4+y5fbGortLRTBVoKXUM4wSRJRmUJw13IdowIRp0pnflYZd6R83/FbasMkLbIRu17aFl4c4P32IF9SLl0vX/FIafqU0/CrpJ3/2YSSVKkgXnSI1bbD/sRUrSL+6Xrr6HC+oA3v2SNkR6lPDMIworUlQKieWOirC2jzVhlGCQIR2aCXVqekn/K1cKy1c5l8XdEybZlLtGtKuPdKKNdKK1d5TSzxy8rEuE1wWKbl8HS2b+MmAazdIsxf4/TOBcs4c4Y8lBvwPd0sfTcz7/PFXpO4dpe9dItWrLR3dVZo0q+DyThggVa7k2/aX+33oSOCuJ6S2LaXvXCjVryN1bC3Nmp/3Od7riuX9savX+XJqVc/MFsMwDOPgSM2hERWPtYlqwyhBjBwgnTbEh4MgcOctlh59SXrkRWnlmgP3b9tc+vaFPmSC8AkE7vwl0lOvSU0bSs+PlsaMl/bslWpUlS47w3t15y6SbrjYe4cRxnMWSRf8UJo6O/PQjyY53uJ5S6SJ0/f/nLa/9I70rXN9+UzCZFJjfl5j9unfyw8EmMD5zicH7jP6I+lb50hly/qJjC+8nfcZQvq7t0pPvy4tWSnd/ksfh20YhmEcGfbt2xe5vOImqg2jBNGycd7r0qV8Bovf3ij17yld+2vvuQYEaofW0qO3SV3b+W18pxE/jBeXY4CsHIRjEE4x4jjpbzf51HSJbOLh8o4jlntQH5+1o7DYZ2jcQGpYx7/Gw50uwwfidu1GH6rRpZ0XwwVlNsHL7OwunZNKLwVsdmuTZEnd2vtYawYLAbztL7zjJ3ta/j3DMIwjSyKCeapNVBtGzCH0AQEdQAB/8qUXoQhdwjSIXb77N9KlP5O2bvdhGw/9MU9QL1pGzms/ma9fTx/6wHccwjnkPw0i2r0v7QUux8xe6L3b9z2TmaCGVk18pg5A6DOpMBViqles8qKakA3alp+oJq/1Wx9J3TpIVStJZwyT5ixkRTz/OYOF04fl2UA2kSjFnxuGYRjfPCaqDSPmIH7DIH/yLC+cEbqI32OPkv59s/c+D+gt9eoifTjee53x/sLbn0g//rM/BnE+sLf0wB+995ky0jkQduyUbrlTuu9/hyZQEbfhmDXr0++DF3lHENEJP0jID+K+x3wuXXu+VLOa9MPLvSf8ubd9rPSFJ3uhHWxJ9lAbhmEYRiZY9g/DiDkIxOCR/egLPwEPkcm2sROl/5COLtvHMQ/v55+JvSb8Yes26bb7846hLI4hzjm1bDdJMYfxU6V7n/Ze70Px+DoveI7ArZnPhEBCNcqVyXtdmBecBV7+9YhvE15wYsXfvF968S7pwlN8LHhoK7aYp9owDMM4GExUG0YJIp3wRGyy6hbe4Z6dvSe3c2svbIkjnjk3s3IQ4YAYRXhnuiBLOpaskLbk5ImuV2t/wR5g8RXCPoB2bi+kPlZK/OsDfpBA+QwI8LxnlfJhI+TBDkL6q4PIVGIYhmEUPckp9aKChX/ElBDcz+xZZs6GJOrZ2dnuOb/cjyGNDfvBkbqgKZ8HbQt1fl25KEN99A2EmcXJ28NnoQ/CPlH6486UkBLPpcjb59+HLBp8lKmjOSzvjeeaNH2HA3Hfq9b52O3WzfzkwHUb99+HBVtIpwd40ndmsPw6Qvqv9/vsJUyyJPxlN973CT4E5mdX+wmNX6RkGzEMwzC+XkpFcPEXE9UxhQtx7dq1+uijj3TUUUepVatW2rt3r6ZPn65NmzapQ4cOqlevXtpjN27cqHnz5ql69epq3br1IV/QyXkmU8tYv369JkyYoD59+jhxvW7dOjVr1kyVKlXS1wF9MHXqVCeWjz76aJUp4/8Utm7dqvHjx+vzzz9XxYoVXbvr1q2rY489Vk2bNnX7Hy4F9cuRhgl5yVD90GOl8uW9Z5Zczxu3SDPm+smKpNHr0VEa/fH+xwSv9JGCNixbJXVsJbVvKXVoKX385f5tOL6vn5zIIGDa7KTBAV9sZfIEfnIYBzY1byRN+Up64Bnp4ef9oKFsaenZO723nvCQBUuPrH2GYRhG/LDwj5iCcEMcf/DBB1q2zLsN8b7Onj1bX3zxhRO1iFmE9p49e9wj5IRkdIjIRECyT9gePN8cE7ze4Vi2Be9z2Cc80u2HmCxfvrx7P2fOHL3//vtOWCcfE+pMfh9sC9tT2566nUdqWWyjb7788ksnrNkW2LFjh2bMmOEeiGoGFlWqVHH9EewIZfBMvQXVk9y20N/hs/z6P3l7su2hrvBZss0FgVAM2T+O7uYzerCgCwL7mO7SNef6z4mffuNDLypfH+O9uojWn17t81VzTIVyUv8eUuumvjzGGCFjRlFC3e+N86KYhVZ+cIXUpH5OG8r7dl91lt930xZp0sy8Y9u2kG7/P+nfv/YDgjBuIY76Tz+Wnr1D+vX1PlabzyqV93m48VqH0A/ydxuGYRjfHNk5mqKw37jihHmqS0iOx9TtiDK82GvWrNHu3bu1efNmtWvXTj169HCibcOGDW4/PLbse8wxx6hcuXKaMmWK84D37t1bK1as0KRJk5x3t379+m4b4nPatGnu+F27djkvb506dTR58mTt3LlTtWrV0oABA1zZK1eudMchqD/55BNXTteuXbVt2zZ17txZLVu2dMKRdjZu3Fht2rRxQpxjae+nn36qxYsXu0FAp06d3DHUwaABu2g37aFdeOYZSEycOFGLFi1yZTDYaNGixQF9U6FCBVfWOeeco8qVK+eGhsydO9fVyefbt293dtF+BgW0s1+/fmrevLn7DG/30qVL3bFdunRR27ZtXX999dVXzj62Y+uSJUvcg/fdunVzdtC/wQbq6NWrl/OSjx071rUdbz6DAmzCtsK8+4jeICyP6ii9+l/p/c/8JL8hx/oQC7y8hEBMz1mchZhoMoX06iwNPFp6/T4fe02mjOOPyUt3l5xSr6hhURoycjAQOPV4H57x5Qw/oRABXLeWbzerK34+1R9TrbL0l59IJw3yNhM6cuGPpDUbvL2d20jVqvgsIH26+YwmzRr4WHImaBIHfvsj0up8Mo6kEqG7koZhGJEiO0dQRyn00kR1CQXh/NlnnzmhiDjDQ/vhhx867yzCFzFNOAYXNeKzSZMmql27thOlCOaaNWs6QY2AxKNNWMmWLVucgHz33XddeAWhHTxTRxDQQJkIxldffdWJ0BC3HTzjhJ5QFl5ihDnlDR8+3InqQIh75g+OOvDII6ARmK+//rorD4GKx5lBA+KUcBPEO2EvCNvly5c7G1OhL7Dt8ccfdyK+QYMG6tmzp2bOnKnnnntOw4YNc+IdsU8d1ElZ1DNy5Egnsqm3bNmybtubb77p2rZw4UK9+OKLbvCCmGc/POXUQfuwB1uwlz6nv2kHdQ0ZMsSJasodPHiwE+gMEtinY8eOBYal7NzpJ/GVK+dDIRrWlS4+1X/Gexz1LGrygz/61QaDt/aaX0r/+Y3Ut7vUorF/hGMQswjqLdvy0s/t2OFfE0ZCXujDhZjqX93u0/eRi5owEB5514AX/3+5T9qZE89NLHjyIII0e6F9TGa841HpDz/0kzFZETGsiohN5MJ+6Dm/UmOBJHz8OH1Avdn5ZR2Jxm+AYRiGUUSYqI4x6UZ2yV5rXiN0R4wY4bzQo0aNcsIPwRwmKiJkEYwISoQ1og8hzH4IWQR5tWrVnFcWoUwMNiKZfU499VS3/wsvvOBEJYKb8hCCeGOpA0HavXt3tx/7Uwdi+rXXXnPeYvbDW9ywYUPXxmAXgpXtlItHGs8wnm3qoH6e8TS/8sorrv0LFixwXuIaNWro4osvdmEwtLeg0W+ypz+EZWArwhmxjNeYQcgpp5ziBhV43PE+I4rxuhPHjiBGGBPXzjF4ufHUI9IZ1DAowQvdt29fdy4YfFAu+zOQGD16tBuU4JFHdNM/9BPvx4wZ4+xq3759gaJ6zpKdGvXmCg3sXVabtu5Wz3b1VdH1ZUJbtu/SB1+u0vNjd6t1e6l10k0NumbUW9KurIrq06G+KpQtq+xEtjZv36nxs9aocd2Keubt7Wreeo+atJC2JKQXP6ykcuWytH7nNvXtq8NmX1npkTezdPKAimrZoLYqVyivfdkJbdi6TTMXrdOTb+9Ri7ZSi5zxFoL6/Sll1KpVddf+d77Yos7ddudmK5m7WnpmTCkNOKqqmtatqfJlymrPvn1asX6jJs/dpPen7FOPXgW3iTqe+aC0qteqqsdHb1HHrvvcCpKptGi5UqXLWAoRwzCMkoKJ6pgShCdCLDXWFwGGGEV8IlbxkobsFnhpA3yORxWvNd5jQi74HLGL15f3iESOxfuK4KPOqlWrOg8wgpP3CEg83AhfhC1e15BdgzqTPdWUR528Dh5f6sNbHAQwNiCKCcWgHDy9iFgEKvsgnAk7QXQjghGqeHXZl89oH95qyqTuVGg3YTCXXXZZbvgHghhRz4CAB7ZTBmEplEc91I+IRqwzMKBsPsNe+hmxzDN3AqiDAQbimIHDG2+84TzOnBfsoQ4GHOw/f/5857mnT6gT2xiE0LfJ5ys/KlXeqj2Vxmjcwj3KTiS0YEsFVShbwYnqnbt3aeuuneo7KP+YtRlrS2nRhPLuGI7fvnuHduzerQVbS6leq306I8l7vDo7CxWukacUrZj8ZEGWvlxeQRXLlnfCftuuHdq1Z6+69E6oS+/99yUc5f05fpBRo1m2zmiyv2302PuzS6viovIqX6a89u7bo227dmr33r0aMDSz9nApjltUWk077FOT9un3KV06W6VKRScW0DAMwzg8TFTHFIQgogzhxQRAwh0QhnhtEZZMvgtCNjltXmr8NfviQWVSH95oBB3iGVGLKBw6dKjzlIYJdAjYMNGRMhGPxArjuUaI412lPMoJ7aQNyeIfgYqQRjRT3kknneREaiCIap7xGiNCKTu0nfKC5zaIZvbhNWIY8YvIRvwievPrv5BKL3lbGHyEekLWkBB3zftGjRo5r/kJJ5zg2o3g5zwQssFzKAPhjG0Ia0JEGLzg6SbkhZhpnmkj5XK+knN2BrvCHYWC2Ly5kt5+u4fKliVkRpEEc4l5rlLZh30wOZHc0oc6f4VTiLOe+Gq8zJu3+tR66fIHEkJSN59c2YFETpjNuk154SBNm61Wt+7zj8hETsMwjLhTylLqGcUJvKx4XBGgiLSQEQTPMWI5Ofg/vE59z0WNeCYWmThf0s8hlAn7wPP69ttvu7hg9sM7nVouIhYvNeIQIYtgRiAGYYkIJdwE0R9isZnUh6h+6aWXXGgEHuVkcUtdiHJCLj7++GP3GQOH5LYnw3vEM+EYiO9nnnnGCV2OYVvqvohZyiZ+GjEeUguGrCXJ+ya/DvXQR9j88ssvu4EN7SUlX3K/MIig/2bNmuW80JSNBxsv/apVq1yf0l/sQxvph9Sc4ZlO3ti+rZIq7euuHu2lO0ZJm7cpMnDae3fxExaHHSs1qCPt2iPNXSS9OVZ67i1pycqDK5MFY84d6fNUsxQ7MeATpvq0gS++4wV7gO69/iLppm8VnuWE7Cnfu1V69xP/vnPnhercZZFKlYroSMYwDOMbpJSJaqO4ELzETKobN26cE8RsI56XGGaELXG7iMaQjxkxiPcUYYzwJiyEixqvK8cRpoBIR8Qi9AhrwLuKYA5hIAhkyqWc4MXFo8w+wGfBG0vMMHVQN6ITQY0ID55ZBDhZRwh5SBaPeHvxfiOKEaDUefLJJzshjjAlIwbe9ND2EEaBMKUc4sHZj75JzT1NXxDKwmRMyqcMvPB42nn079/f7QOhHmxH+A8cONB5qSkTG4h3RrwzAKAvOJ62094giLGXuugH+h+vP8KceOvVq1e7AU2ItyYLSAjbCf3MuUoXwpJM9w7Sf26Ratf0wvB3dyky9OwkPfAHqV2L/TNtkGt6UB//uOqX0oZNmZXXqJ70j19Ipw/Jy2UNLRtLpw2VureXfvNv77mGOjWlM4d5MV/Y+IWVH399gzR+WtLqjBb9YRiGUWLISkQpAaBxUKTmeU4OaeB18oqCwH5hHz4L4QbhM8oIog5CPuWQ8iaEkiQfG/IrhzCF4J0OZSa/DpMBCYfAA01M9SWXXOIybCSL6mS7Qt08p6s/eeXG5KwhwYbk/gh/CiH/dCA5DCT0QbAruR7eh7CX5PzSIRwm2BfqS9d/ybnBeQ518xzyaSeXFc5fqscaUTfoEmnGPKlfD+m1e334BNkvfvznaPwhkUf66X9Ig4/x75evlr6a7/NU42GuWtnnsWaFxD/c47N3FESTBn5wMaK/H1yQEWXmPB8G0q6lVJ5MIXukUS9JN/0tT1gP7yd9+8L04R8scd6lrc9Owum45ynpJ3/xGUc6dVqoK69+S2XLmafaMIyvj6lTW+iBe090KYj++CPpJ1dFL/1nIoMVoIsjFlMdY8JFGLJmpBIEbQAvaiDV+5n8WSA5djmZ5GOT439TSW5XeI0Hm3CIkEYueJcPxq7k+lLbyGfpbAnlBlvz2yeUlWpXaj2FHZ/umMK2J5dZUL8WRJSG0BeeLPXv6V+/96n0wz9Ki1d4cUue6v/e6tMDfus8v2jNp5MLLo/0eXi26bbpc6Qf/dnn4qarj+sp/fP/pMb1pVMGS3c9Lk2b4497+xPpwwnpf5RYJv2Vu/1rvOUPPZ+Xws8wDMM4dCxPtWEcJghlwhpIiZc8EdAoGlg4ZUBv71nFyzt/iReWBQnBShWlo7v60AnyMxPPPHuBVKq09+xSToBVGtGexD0TosFiMxy/ZIU0bpLPiZ0JCOcTB/pJgjt2+lzUM+fnff7Wx36J8V9c5xevIUykIFHNZUR52I9H+7b7/QI4AfJ09+7qPTqEyXRumyeqgUmRqSCy8XqzwAz5sV96zy/vbhiGYZRMTLEYxYoQHmJi+shw2vHS2SO8EMVrTUjFy+9Jdz7mxfL+50Lq08UvEc6kPhZMQXyvXCO99oEPp3j2Lem50X4RlAZ1pe9f5lddRKxfebaPhWZpcTzMV9wkffRFZt7y6lV9+cCqh8kCFyiDiYrfv9wvpU44CB7o/JKh0KY+Xb1NhHV88uWB+3w4XvrBZT4cZOix0tOvF9xG+pCl0rGPyY0PPld4CIphGIYRX0xUG0bcSQpbQPgGUYvAJNyBeOEenaQrf+7FMB+XLuWXB3/4z1LLJn5/jsODjNjlGEDMfjRRWrRcGny09OMr8/YN4RK8rl5FatHEi9l9GYhq6qhf279G7BMjngoDgjXrpcqNpU6tvbgNKyumgtjeut23hf1IpZcKXuzSOd+IbZtLZcsU7MHH8901J0c14Sd4/A3DMIySi4lqw4g5COEwyQ5ROXW2NPoj75E9bYgP02Ap8ntvlc78rvfkshz4/b/3gtod85X0zjg/2fGkQV70IprDI5nwnomAr43xIRGIbjy/pK/LBJZED8KX5crTiVuENl5z9q1b23us8xPVhJDgXe/V2dtw8WnSzf/K8yyzjRhuFo6BIMDzo0Y16epzfLgLS7Xjpc6vbsMwDOPgyS9NbnHGRLVhxBy+joJA/OQL6aKfeC8v31MPPivdd6uPJ+7Z2WcKeesjaeQAqWVTfwzhHT/9i7RstQ+xuP9Z6X//9J+nE9VBlJKzmfCQdPHImRDavG5j+s+J5SZ2O3iiCwq/J+aZ8I71m3yavG+fL7VpKj3/tg8NOe8kP1kx2JIcJ56OoX19/mx4d5z0+ZSDt88wDMPIH+ZVhexYUcHW+jKMmIOXN3iIv5jpBXUQrdPnSv95wotIwh+G9/ehGoQ24N0mVvifD3tBHcQrnufFOQuuMPEwCFDCJQJMSjwcQQ3hexQRnA5EdIWcBDCI/cImQX42RfrV7dLajX7y5OnDpEf+It3zO2lIXz8pMgh5wl8Q4unAg37Nud5LvW2791Jv33nIZhqGYRgxwTzVhlGCSDeRb+J0L34JgSA2uVpVvxgKonbdBmnB0szKQYiGz4izPhxBTZ2EoSCoia1OF99co6qPEYfV66RtOwouk+MfecHbdd0FfhIlAwmENOKYAQQZTkixR4hMfpMeB/TKS/U3dqI0dkL6/bKzS2nX7rLKTpjvwjCMr489e+Ih7bJT8lRHgXj0vGEYhwyCNcQSE2O8L8mzzcS9IJYLY2eOiObYFX4BzUNm6Upp5Vovqts09wvBIJyTIa67bo4Xm7zTmWTeoG0PPOuXI2ci5jHdvdj++Avvrb7pGp8m8MsZ6Y+vXMnnxWYBGmLGCZ/JT8wvWlRf995zsrKyIpQc3DCMyLN9e3nFgewcUR2VhV/ARLVhxJB92QlVdRP99v8iwjObDGL65OOl8uVZbdLnel6/2XuvWzX1XuL+vaTnR+cdw3cboQ9HErzUCGtWK8Sj3L2d9Pa4/dvNhEnsod2k3AueZT5D9NJO8mone5y7tZM6t/PeZTJ28AAmOd78HR9GQt2Ll+e/gAxZTkI4ybuf5m/Djh3ltXhR/cPvDMMwjEN0mLBSLMP6aEjS6GOi2jBiCDmU//SjhC74IeEMLIHutyMIhx3rxTMCEu8s8cEIUcQ0uZ/JlPHGGJ8ZBHH6f9dJK1b7kAjirBGzHVr68ig3U0/2wUCc9qvv+/bRhp9fJ61eL81f6tswsI90+Rl+X2KkGQTk5tbuKv3fd6QypaR/jfJZSxDWeL3//gu/GiOeauKrSclHjPQlp/nJmvDlTGl2Ss5uYELjtef7eGy88sRSk/kjPypV8OEpmTtYEj4VoTMk978Y4O0C3xdmV/Emvucr51987VLefzydcrx0xVnxsTQKmKg2jJjSuW1C9Wpz28x/74b8y0/fLk2a5cVpj45etDLJj0Vg5iz0+7FIy5jxXoB3ay+9+B9p2mzvoe7eIc9TnV/2j6Lg6Tek04f6yZOsAvnafb59TE7s2NqLW0I3mGg5aaY/plpl6Zbv+sVqAG89thI6ksj2i8qQp/rcE7z4ZqVHlhpnVUS8Oiw1/rcH0ufF7tXFLwqDvaQYJC1hQRBactfN/i5AJiSyE9q7b5/7AXSLH8XklxC79nE7wYUTlY7MbdzC4Lb0vr3Fwy6u3ZA283BBUO/bt9fnpY/R+YK9e7ErodKly6hUiHmLlV2lXfwxcNpwGHBtxOgUFntMVBtGTFm1NsuFMvClSlq6hvW8x7ZqZWlgb78PP5x4ph94Tvr17XnxwQuXSdfdLN3xS+mEgd7zjXc4HEP8Mrpv1dq8WOqNm/LyOyNODxcmDv7qX1LjBn4CJaEoYUEYQFDjzb7r8bxJjHv2+fCN4GnDtp05mTlIp/eXe6V//p/UsK4Pb+ERbCKDx+2j8g/pIB82woX97n8mvfBOBs/+jX/I3JOfSGQpkfDKKKtUbDR1il3egxY7u1zM5zfXFvLJ/9+3/XV9uPC3EDLpcCcqR6NFHj9Y4JzF2S5/HcZFRGdFME91VoLhjWEYsWLjloQuv0l6fQyiLksjj/PeXib/XXyqVLeWTxlH3PK9T/v9NqQRiay4eN6JPjyiVg3/Y7tomfTU61LHVtLjr/hwCb5FEO+Xnu49wUW1ZDeCFE/5qUOk4f2kRvX9RMJZ8308NN715EmRfPcSN339xT6k5ZEXfW7ukB4PUTz4GB/aQn+QQYSBBOEweJ4pM7+QDsI5rr/IL/Iy6iUv3g2juHDBSdJ/fuMHzYcDkiDIgihNECuMkmJX8nOUSUTULhPVhhFDEMiDLpFmzsMjk60qVXaqVFbCRYEwKY8fXr6vEJCIyoJG1ohTd0wV7+nGg4ywxNPD++Rjwx3V/HI8HwoUyXcporZKZT8xkTbgnU7ks3/wDpPtI5Hmc9qOTaQRxNOOQKbcgprtjsvy+9B35o0wioO3fNvWCkokSrlsNm/cl7cS6aGXuf+VHQUhkwklxa642JaIqF0W/mEYMcQJ0ZzX9ept1OVXvqUKFYrAdWwYRrFKnfbAfSdq/fpq+/3NF0UqMwjxuXEhinmPM8HsKj6YqDaMmFO6zD7VqLlNFSsexmoshmEUO8qW26tSpYr+nkkU8wMfrPiME3G1K5FIONuidB3G6wwYhmEYhnFYxH2qVVzti5tdiQjaY6LaMAzDMAzDMA4TE9WGYRiGYRiGcZiYqDYMwzAMI5coxbAeCnG1LW52ZUXQHpuoaBiGYRhGLqzMF1VRUxBmV7QoVapU5DK1mKg2DMMwDCOXKImYg6Ek2BUnG7MiaIuJasMwDMMwSkSe6jjbFaWVBw9mVcUohSPF68oyDMMwDOOwRVrIfRwn4moX9uxjSdiYkZ2d7eyK0vkyT/XXMMratWuXtm/f7i4ORsjly5dXpUqV8o0VYv8dO3aoatWq7pjdu3e7/bnAtm7d6rZVqFBBFStWPOQRd0iqvnPnTpUpU0blypXLaCQY/ni3bdvmjqeNxKkd7igyuVzsBcqtXLlyvm2j/i1btrjPeezdu9cdczDtCeeHY6krk+OoN5zTkJg+nI/wxUaf5nduqJP6eGY/jsdmjsWOouhPwzCMQyVKIuZQf5fjRLAneHXjQiKC58lE9RFm06ZN+uyzz/TJJ5+41wivrl27aujQoapXr17aP4Bp06bprbfe0re+9S2tX79eM2fO1JAhQ7R582Y9+eSTTngec8wxOu6445yozeSCTFcPgpR2NW3aVF26dMnYpuXLl+vZZ591Av/yyy93xx/OH3IQmfPmzdM777yj+fPnu+30z7Bhw1zbEK2pMPB46KGHXH92797dHd+gQQM1a9Zsv7KTSdfO6dOnO5tGjBjhBjyFgd2c07FjxzphzTG9evVS//79tXr1aldHq1at3EAoHdiKjbS/RYsWqlKlir766itt3LhR7du3d3YbhmEYhhEtTFQfIYJQ/PTTT51w7dixoxNQwSOJGMPbyQNvJ95JBHfZsmWduEJkcXytWrXUtm1bV+acOXM0ZcoUnXbaaWrXrp3zhCLUKQ+PJ8dTDmUnL+8JPLMf2xCBiFSeEX/Vq1fP9VrTPo4N+yR708MIH0H4xRdfuO0MABo2bJjrbcXTSluoC9uwhzIQkNgTvLrsl+zJRYw+//zzzoaTTjrJCVLEa/Ak79mzxz04nrbxoI65c+c6Ebps2TK9//77TmDXrFnT1cvnweZQHzZSJp/TDtpav359Vy9l007qC/ZyXBDHoR+WLl2q0aNHq2fPnmrevLnbzn6UjdgGjmnUqJF7TXnhLgXb6afJkyc7m9nWunVr1alTx4lrPmffcC74PPRX6Ifg1ceGcM7j5J0wDMMwjChiovoIsmbNGs2aNcuJ1uHDhzvhhLBEuAGfvfHGG84DjXgePHiwevTokXs8wgkBh1DDC/rcc89p6tSpzjPMY8WKFc5birCmbMQoAhMvMnVwPO8RpwgynqkLzy8eYETZRx995AQ6IvW9997TpEmT3HGdOnXS8ccfr8aNG+9nE0JvyZIlzibEKF7eQYMGuW0TJkxwHmMGEIsWLXJl8x6xOGbMGLeNOnv37q0BAwa47YhBBCQDBkTmBRdc4MQqYjcIcep8/fXXNXv2bCcoKZO+QlAC+4wfP9559xGreJ0RtPQd5wDRSZ3U9fHHH7tysQvvP55h7gQgzmvUqOHKmThxYm79iPRTTz3VtTXAnYJVq1a5c4CtCF6EO57yd999Vxs2bHADjxNPPNGJYgZWa9eudeEleMM517SDAQmDJ/bDLurDdqAc2oSN3JHo06ePO4bzjx2U17JlS40cOdIN1kxUG4ZRVPB9EsVb75li35fGkcImKh4h+EJC0CEYEV8INv6QEZWEbCCwEMKIvX79+jnx9fbbbzsvcwChtm7dOie88FYeddRRzrOMwEYEv/nmm84ri+hi3w8++MAJSsTnwoULneDr1q2bCyFBwHMsYSMIZ8pEaCPcELO0C48pZSNaEbkIzDCrOED5tAlhjhhHpCMwEaGI+y+//NLZvHjxYudV5zXl8BkhEohZBgII3hB/TDsoF7GJ1zt4lemjatWquecOHTq4tlEvgwzaF7702RePcZs2bXT00Uc7GxHSeNMR3AMHDnRtbdKkifuMB33y4YcfOs8vgxP6DFFLuQsWLHDnhf5ApGNL8iSQ0M5HH31U9957r+t3+oG2ckwQ/YheBh6U1bdvX3cOaTthN7QXWxiQcCeC/mHQgSBHUHPtYC/1MFiZMWOG88ZzHrlusHPlypXuszhOUDEM45uD79Q43gE72Dk3UbMrbllNSkfwfJmn+giCoAMEayqIVcI88FYioPByIkwRZ+k8BIQFINgQWXiR8ZYiqs444wwnOPn8tddeU+fOnXMFMmKO7Yh4vJkIMTzMhEkgKlPbitBFiIZ2MRAIoSkh9IN24iVF8FEPn7EvwpV4ZkQ1Apmy6tat68rGU4uNtJd2IyAR4ohObA6hMqkhIQFEN4ITrzhtow6EMXYDxyBeEewMJHhQDwMO+gO7EZ4IUAYU2E5ZCG32S+5vBiv01bHHHutsRVDTVgQ7bQW84BdffLHzGtMuBje8PuWUU9xn9AnCmvoRwQwu6A9EcfDU016+KNiPQRftoh0MQhD1CG3i7qn/6aefdtsAG/FaczyfUW7qwMcwDONwiJs4C0QpNduh2hUn+7IiaJeJ6iMInksuBDy7eESDgEQEIdTw4CLqEKQIWIQeAjKT224hzUyIw0Y4U0cQwYR9hMl9fEHiXUVgh4l4yd5NXuMJRRwH0YbwDFk4Anhy8WwThoB3FxDQgGcWUR3CHRCbeKaxmQfCFs8sr2kvIjUMNngO9oesIvRbyLJBu3hwDIMC6g6x6QXN6qb/2Z+yQngK9SNWgf5KtZH+oS0howjvQ5x58j4IerzNDBY4j6+++qrzRifvR7gNXme2IdIRwYjvEBteUAqhUD9hJ/RpaCc28eDccp5DKJFhGEZREb5L4yauS4JdccoAkkjKUw1RsMtE9RGCk4/I5EFIAaIVUUh4B7f4EWN4fBG7xPXiFUU4ZeJ1DBPeEFYINcIjCF+oXbt27qS61HR9ya9TRTvvaQtijxARRCWkC/3Ay0y4CQISgUp4BLYgdPGi40FFSCLy8RgDYRfsy3vahxAMAw7ADvoGDzpeaD5jsECbENnYSBvx3oaBSRhABBCgQP+GePLkUS7tJuwCDz4PQlCCgE89b6l/uKn9hVjGQ4ytnD/6HYEbJj/yOWXznv2Ik8djTh/R7iDMec2+QbSHCY/Yz0AMzzax2XxGyAee/tRzaRiGUdQEh0XcPLshR7XZFa3zVbp0aUUFE9VHCP5oEbvES3NLn8mDbEMUEvZAfDReYby+CCg81yHnc8jkgTBOfR0ychBagbhFHBIbHLzFCD32QdCFL47g9QxCO3i3QyYOBB5tIkwBjysiEbEXJgICF3aILWZiHZ7n4BEnEwYebNpD+AMiGwGMEKTNhGqwz9133+3awEDjzDPPdM9AOYRAMHkSbzJCPeSoxsNL2/BUv/DCC24boSIhz3dof8ieQXwz4pnXbA95oBH8COBx48Y5oYrYZRtlBDEcXoe82LQhuYwAIShMnGRwFLKqEA6DDQj6l19+WY8//rjbRj8QUsOgJ+QEp0y83Hi4Ce3gvIXMKdjFcZzXe+65J3fSKF5+7h5wbDiP7J9JPPWO7eU1bUpLlS3nBX1UKVNaKldWyk5Iu3ZzTR5eeZxSyqMYxjr5lcd+FSv454Ig2msXXUw5WVKd2pvVuMnaQo8zjOJGXCcpBs9n3OxLtitOg6BEBO3KSsTt6ipGhFhhPJQIObyoiDbEHKIKcYYYhSC2Qjww4RMIKWKsOR5vNtsJYyD0ABGIGEesUS7eTfZBCLONeN4gWpm0iBBD8FIP4hlRjhClfvZFSIcMHAhSBCDHU2a4pYQQRUiSB5qwCkDA4lGlPYhKBgdk02DAgKBEmNLuMCGScqgPoZi82EpY2IY2IMqBduBVDp54+ot6EJIIbWzgDgDP2MaxeNNpG952hCpCmoEG54F+YGAQRDL7EVeNB5iyaS/tZ1/qpT2UR3sZPITRMucEG4Oops/Zn3aEzyiDNob+p80MmrCTergOiLdmf/qNstmHtvKaOxf0VxjwcM1w7rGJ/ud44qw5BhtSR/IbN0uDLpFmzHNXorp3kNq1kF56V9odIW3N5dGontS/p3TyYKlZQ2nHLmnabOmND6UJ06Qt2w6uzEoVpZ6dpBH9pd5d8MpJYydK746Tps4+sH9OGyL98AoGfwUUmpA2bpF+fbs0+Su/qUuXhbr8qtEqW9YmkhpHhq1bK+j2v5+ttWur65hu0hv3SVXzEhUdEuFOYGGLWEWN5EW3wgS4ONqV36JyUSMRUbtMVB9B4jJeOZz0SoUdm5wDu7hTnNua+mWTLKo7tJQe+5vUrJF0yx3S3U8qMrRqKt17qzSw94Gf4a1+4Fnp53+XdvrU4oVSpZL0i+uk710qVfARQ7ls2ird8i/p/mfzhHW92tJT/5CO61W4p5pIojc/ki79qbR5q9Sp00JdefVbKlvORLVxZDBRnTkmqqNFIqKi2sI/jiBRuAC+DlsyOTZKfRWltkKtGlLrZl5QtmmuyFCxvHTzDXmCetsOad0GvGdS3VpS+XLSlWdLU76SHn7Bi9qCqF1DuuW70lVn+7APPNRrN3gPNH1UvYr0+x96T9+dj0rbd0pr1kuPviQ1qMM8hQPL5FKoU1OqVsW/3rI1WncCDCMdlqfaMA4NE9WGUYIohk72fDnleOkMn6hFM+ZKv7pd+nKm9zDzGYK7amXp/74tfTrZ71MQvTpLF53iBfWqddJf7pXe/VQqX1Y6baj0/ct8edecIz0/WpqzyPfXIy/6sJl0orp6VenR26Q+XaVt272XO1OvuWEUV0Ia1ag5EEq6XXEJ1YmyXSaqDaMEgZe3SQMvBhPZ0rpN0pp1fvJfvseUlhrWlapV9ZPx1m2U1m/ynlm8w8lCvXTOd9++bO+9xcOLiN20RVq2quB6kqGc80708c979kq3/kd69YO8z+96QmrfUrrmXKlxPalvt4JFNeWNOM6LZjzUf71fuutxP6cQiIMmdhsvdsN6UodWXlQDNmJvOggL6dzG98F7n0njp2Rmn2EUZ+KWHaMk2RUX+7JS7ImKXSaqDaMEMeQYP0GvRWNp7z5p5lzp/mekZ0dLG9IIx8b1pSvPki47w4vxHTulmfOlR1/07195T5o4wwvVyhWlM4dLlSpIcxf5uOUBvb0wRvCe/0Np3uLM2lm5ko8BhwVLvSc6GcT9s29Jl57uw0A6tZFKZeUv2sneMfho723esFl67YM8QQ2IYrZRHoOAgX2kV94vuI3Bq03ZhIo88IwPUTGMqFMS8jnHiTjmqU4kZf6Ikl0mqg2jBIEHNtkD3aOT9K9fSoOOlr53qxecwHdX80bSqL9IR3fzYpRtZSpLR3f1oRSI2LNGSCdcIy1ZIZ0wULrvVn88gh2xG8oi8wihHLeP8gK8MPAa4x2Hrxb42OdUFi33HmT27dpeKlsmJ6VdGmhD+D7mOd3Ef9oc7CQrCF79nEVR00JGkv69/OuPv/AZRAwjDlie6mhBVqmwaFoUhGec7TJRbRgxBwEZwjKAyXfEJiNCEY94XM8e6cMcvn2L97o2bSA98Aep71F5x0ya6b3OpOdj0iPfcQjnUDblUZcT32V82AYe6vlLpLmLpXueykxQAxMra1bzr1eskVIWvnSs3+hDSoIAp235iWpsImVel7ZS1UrSCQN8m8LkRtrOtmALHvn9XNkp4JUn9IRnYqgffPbgU/sZRnGlOGY4KgrimKMagk1R8ebG2S4T1YYRc0oneWnx+n7rV15UIyCH9ZP++jOpZRNp5ACpWwfp00l++zHd/TG8/+lt0uRZXiwjPvFuk24ueHZTQQT/42HpjlE+fzNhGZkK6uBFD6xel17fkmXDid+khVzyg7o/+MzHTBPr/dOr/TMTEMkyQvz2Jafl2ZKfOA/06iIdf4x/Ta5sBLthGNEgjsLaKB6YqDaMmLN7rw9tACbTJccnEzeMV/hPP/Iic3g/aepXflIfIpUY4T/dK30WJuDt9sfccLEX1awREcpO9oZ/MVP62wM+9/OhQGhJCHukXemgviC+8ZAXNgly7ATp4eelay+Q6teRfvUd6SdXeyFNRhGe+a3lGc91fr+7FcpL3zrXe/jJlf3Q837gkMrOXeW0YmUtlSljeaqNI8OOHeW1d1+84oO/DqLi9TSih4lqw4ghCMJ0mjBnobT99ntvnLRzt59gSLgHOZtZcZDfHfJCfzH9wGMI7UglxFDzOQL2UAU1LF/jU9TVqCbVq+VFc6qnG1FLvmpgkuX2QiYJbtku/foOn5nk8jN9BhRsBgYG9A2CGbuZUMl+6eje3nv1gRUYXx+Tfr+FCxro3/86gyW2Ds54w8iURJZ27y5T4N/8oRBX0Rlnu6IUIhFnu0xUG0YMKV06oa7tEpo1v3AvFqEOwUPrvLNJv8yI5/zEZbq45SBQQzq6Q2XhUmn1ei+qWzTxAppVIpNpUNd7nGH2wszyQxMucvMd0hOv+mXPWdoZT/7HE336vx9c4cX7xJSBRADv/dXnSjWq+vATPN/5pdvLzi6l3bvNi2gcebir0639/neLDq88X1CUxEwmRCmLxMEQVhs0u755TFQbRgxBhN76/SyNn4pCzvsBKZsSd5yVk8WC8Acm7c2c50MZSIlH2j1CPDq29p7n3GOYiJgme0YyhxuySBaS5at81pCOraQ2TaUJKUKXdjNhknYTspK8omIIHUldZZEJjdiEJ/rP9+Z414n3zpae/IcXJVu3+cmV6aAtpx7vX8+a72Oy87OVdISD+qTPNJKe1ILi8sNvdh3p7mVOBCFZTNYtCuKWci4QR+EJlqe6+GCi2jBiSq3qPjsFv4/hN5LQhRaNpMUrvWRr11K6+hwv/LZul9740D8T0jD4GC/Of3C5NGeh9xzze8RiJ6TbA1f2EfiNIhTjoy+kAX18TPX1F0s//rO0mZCSLL/wC+12S4Nvk6bMzpNuiFkycyCQH33Ztx2w5Tffk04c6LN1/OV+HxPNAIHJl8f19PvNX5peVDNJ86pzfHgM3vhRL/k+yY+ubaU7f+1DSjIiQVx4wp2XrCPRqd8giZyAd7PryMC1nt+k4cOZyBc3AVoS7IqLJz6RlKklSnaZqDaMmJJwMjNrP+FLzPRr90qvjvGhDKcN8enz+O4i5OHLGf71mPFejOKlJkwCr/U7n3hPGJ5a0tgBYrxU6SPRdh9accYwnwbv/JO8kB43yQ8Uhh7rhT1tffEdadyX/jg812QzOWu4Fxjk077sJr8KJMfhOQ5hHj07S9Pnei8fi73UrO5F9n+ekFasPrBNeM1PH+b7cv4yv5R5QR75kA+7MK/+fj8i+/YpS1lued7i//ORGfTR3kSOXaVKF5nwKw527Uv4QP/Spcp8I3Yl518vSsgNzPVYhpFkjAh2ub+vuFyIZlexIl5/MYZh5LJ9R0K7dme52F8ehDogCNu2kH7UMk8Y4EQkJdz1v8nLYkF+6Wtvlv5zi9SlnY/X5BGOcVoyIe3albdACt5lynITGQtJSZcJi1dIt9wh3fM7qW5NvwgNjwChHQwCfndX3kqG/E4yATF45onJDllByLV93zM+6wfiG481j2AT3uen35CefDX9hK9+PfykSfZ79CVpeRrhncycnBCTjHVJIsvFYYNrf1x+87nGzK4ih8ujVVPp7BF+Vc8jtZpdnMRnnPNUx/l8JSJkl4lqw4ghTMj76wNZLpSBBVJ+f7dfnhxhSagDoRD8tODBffp16e4n/AqFAWKMP5/ihfYNl0gnDfSeXrazuiFhIm2bS3c/Ja1c449BmP/7MS/eX/+waOwY/bH0k79IF53iM5LgTUbUEm/9yZfeq5zcbjKA/OdxP5EQYcrnW3KykND2e5/2YuS0od4DTo5qJmrOXuC983c8mjfhMhVSCfbv4UX6qBcPjNdOhbh0RHXm0LIj4Pb/xjG7jhT8rS1eLv34qrzsO0VBHIVnSbLP+ObIStjVZRixg4wUgy7xk+mQz8T1li+XcB7klk19KrpEtrRqnbRgqfdk5wdp58Ix+/Z6kb50ld++dcf+S3kTHoKECp7jooK6mjbMy429ZKVfFCZdaj88w4hqIAY71bbgzSbshfhoJiYiTNZtKlgocxyrMVInKQjtd9n45iDG1D8zF+Dle/xAuShAEuzJudVE+EdcJi1i1969e3PDP3jE0a6QCSTqJCJql3mqDSOGuMVTcr5/6tTZrNNO/0Tlyh+oQDtKGnyQZXfSN0/OYo9FRu8iLs8wjiTbt5fX888ep61bKxXpBMVAmBgWV6Igzg6GKE3ki7tdJqoNI+aUr7BbbdsvU8WKu7/pphiGUQRs3lxRZcseuZU645ynOo52YU9UPLmHYleUMFFtGIZhGEYuURMymVIS7IqLsM5KEdRRsSueV5hhGIZhGIdE3LNkxJFgV1zsS6TYExW7TFQbhmEYhrFfPud9+45ceMk3bVdUBFqmYFMc7cqO4PkyUW0YhmEYRtr8wHEijjbF+Xxl5yzWEyW7TFQbhmEYhpFLlETMoRB3+4xvDhPVhmEYhmEYhnGYmKg2DMMwDCNymRYOlbjaFze7siJoj6XUK0asXbtWs2bNyl09qGbNmmrWrJnKly+f0cXF6kOrVq1ycUh169ZVhQoVjujts5UrV2rz5s1q3bq1W3krQP0bN27U0qVLtXXrVmdP9erV1ahRo9zP6tev79rLJIQqVarsd3x+cOy6deu0ePFi7dq1y5Vbu3ZtV27FihUP6KOwMtiyZctUtmxZt19I0cNna9as0ZYtW9SgQQPt3LnTtZV9aEtB/b179253rmh/w4YNXdlAGcuXL3d9T/nU26RJE1WtmrO8n2EYRgTg+y884gTf/1FbTORg7IobWRHMv22iuhjx5Zdf6rbbblPHjh3dRVSjRg2de+65at++fa5wK4jt27drzJgx2rFjh0444QQ1btz4iLb3o48+0uTJk/WLX/wiVxTzh43w/fDDDzVhwgTXFj5r2rSphgwZ4l5/9dVXOvroo53oRpTzulq1aoXWh0Cmj5566in3h4ZYRayffvrp6tatW9o/Psp/+eWXXV9efPHF+4nqiRMnaurUqTr77LOdoF6yZIlq1arlRH5BbNq0SR988IE7hvPD4Ad4/8UXX6hXr16u3scff1xXXHGFOnVKvwZh6pdgfl8cme5nGIZRFMRlCe9ULE91tCgVwbziJqqLEXg+8eB+73vf04YNG/Tqq6864de8efNczzDbeY34w8OKwMI7jecUUb1ixQonXHk9f/5858nlC3LhwoXuNQ88qAhHRGkok4uXuuvUqeM8wqtXr3ZlAtvq1avn6sK7y2eI/CCKk0UfwhehiuAePny4jjrqKPf5+vXrnee8UqVKatmypfM0sw/101620WYGArSLchYtWuTqRjiHPy7ahkA//vjjnZf47rvv1pQpU1x/BO8+deAxBrYhdnlMmzbNvceTTLm0Ydu2bc5bHo7HLjzO2EibsZnPggc7tIF9aC+vA9jXqlUrVa5c2R3LY+7cuc6zzd0GvNY8cy7oE+plX+pEqDMAKVeunKsLm+l/+pe+APZncIDdnFPOOzZk4l03DMMw4k8cPfFRwkR1MQNRhYhDNOG9RWiHsI633nrLCVneIz7x0CKmnn/+eSfUeI0Qa9eunRN0b775phO2iDbE56BBg5y3+Mknn1T37t2dOB09erQrExDAfI5QY/ucOXPc9rZt22rkyJGuHLYjThGvCEbEXzKEdiDmsQEPNCKeP3JEOeKSQQLtojy8zniHQ914vU8++WTn6UW8jxo1Sqeccop7nzxipY8Ql4hjBDSC+ZNPPnF1YyPhKAxI6MPBgwc7ewirQQSzL7afdNJJ+w0GaAuPa6+91vXhG2+84QQ/YSU9evRw7SosRIU2452+4IILnNjmHLzzzju5YTinnnqq2rRpo3vvvde9p284Vwjr6dOnuwERX4YMGI455hh312H8+PFOiLMv1wDhQGeddZYbFL399tsufOXSSy8t1LtuGIaRKSFHddw81iFFW9RCCkqyXdnZ2e46jIpdJqqLEfxR4JnE04uww4Pct29f5xUllAIBitjiPSKSUAMEJjHGQWj997//daIbIYaYxONKmVyQeG8JvWA7INqo87LLLnOe0nfffdeJZPZHEAZxyHbqo3y8x9SFEHz00UcPWCAAzy/CFREd4pxDXBT7IqwpnwFD//79nXA977zzXL3Yhe14XmfPnu1sY3vyFzvtpa18TpgJQhmvc6gbry770AZEMO3HA4wX/vzzz3eDj0mTJrl6QtvZn7ppF32O8Of4a665xol3BhO0pTDod4Q9NmIvz71793aDAvqQc0gfIoTpH0Q2AxvsoR6OpW7ahzeadvMZoTz0FR55Bh4MELAZEc/ginNtGIZRVITcwHEUacGuOBF3uxIR8r6bqC5GcOEgkBGrQXghnhB8M2bMcEISscfFhYDjNaISEdqiRQvntcXzCYhABBveT4QkMccIZUQbQhVPMx5q4reJ+UXAIfxCOAiiuWvXrq5Nn376qds3eKUpi/KpizYlE0R0YasgIZSpA5GJVxtPLB5hvOi0l3biIQ9hJwHKRdjTTsJfaEvPnj2d9zw/EPfsS3m8xgPPAIPXqWA7QpYwDsJu6NND+YMOoSgdOnRwoS2dO3d2cdgId8Q+/c45ox8ZHBEKw0AKu+gTBDZ10ga821wHePNnzpzpBka0H9HepUuXSI3iDcMo/sRx0ltJsC9K4jOumKguRiDEEFA33nijE8OESYwbN855p4NnF68l4jbE5CLGEOBhRIfYRmThXUUYMmEQQXzcccc5rzXezqFDh7rQCfYLy4ByXGhDmEkctoXbL2EUHJZE5fPULyfiofG6EhqCOA2iFO84j7B/8F6H9whNhC/HI6gRziNGjDggvIR2II4J80BQUj62IjRpE55qxCZeaz6D0FfJS7nmJ0SDZybYdqijZI4Jfcsz5SXPqA+x1PTJe++95zzpZ5xxhgtBwRsd9kf444mmXfQFHmxCRRjMEAqC6I6bd8IwDMMwooiJ6mIG8bfc0kcw4VnGS0wMMF5NPJqEPACiC/GKNxohhicbDydeWI5FsCG4ENSILrzBCDnEOsIVUU3sMSEEn3/+uRPmCFuOpVzKoW7EIV5sPK6IVDypCH3KQMimCjqOxYON8EPQI3wRlQjsECOe7KlmOwIajy3v8Zo/9thjrj5Edmr5QWjS/jBRkzJ5TzsRmwhVvN0MKkJoB3YiVrkTwHvsZFsq9BNeYTzfPBCytCt5omLofzzL1Mc+tJ/6wyAhhKkQZkIbGczQXvonNV1VEPsczyRSjksefIT9qJ9+IRQHTzWDo4zSJiaylL2P8BsT318v3I5lQPY1V2sYhwnfOXH15kJcvblxsysrgtehiepiBKIYQY14QoAS2oAIDJPrENmkhwsiEs8mXluEKBPiEHaES4Q4W4Qvwhohh6BjPya78Zq6mMTHhLyXXnrJiVw84oRSBE8vnnKgHccee6xrF4Lv/fffzxXpyZk5gNfUw/HEbH/88cdO4BMCgQikTXhbsQ/Ry+fYxGfEH2MPbec14jb5S4LXtDs1B3fwXiNcP/vsMyd0Ed5k22A/BiQMAJhkSV/26dPHiX0GI/QX9WEH/ULIBp/T108//bQ7nrYwsTGIap7pa+ph0MJ7PM1M8sQ2Bh9so03Ewc+bN8/tz+fUwT70A/awnTsQ9BX10acIfuwMnv0Qz83+DKJCRhdsyCTmccOGKnrh+f6qVDFbe/ch4hU5skpJlStKdWtJ5ctKm7ZKGzZJO3c77XoIBUrlykq1a0iVKkhbtvny9uxNs2uW1KCuVGv/myYHsC9bWr1WWr/Zt6l0mX0aNuwL1aq99RAaaBjfHHHNUx1HmyCONkX1OsxKRG0YEGMQfCGWGtGEqELEhhAAPmMfPL8hSwiClThdtgPvg6BGcOGNDYuv4KGlDEQ2wi9MrEMAh/ACxFyYMMm+QFmIYC5stvFZmDzIM+1NFtZhciBlYwOfYQPl45GlrbSd13h72Z96aR/eeATm5Zdf7sR5arnEkLMf+4dFcUKoBfWFxWbYFmK2aS/tAbZjCw/spn28pkwetIuyQp9SP+UgtkNb6DfOC/WFP5+QkYQysZN2IcwBOxHZlM0zdxvo/9DXHENZ7Ec5tJ/PkhfH4bxiO3cQXnvtNTdwYiJpfgsDbdwsDbpEmjHPv2/eUPrRVdJbH0mjP5IT11EBQXv5GdLQY6Vu7aUypb2onjBVeuFt6aV3pR1+7m1GlC8nnTBAOnOY1K+nVKOatGadNHai9NRr0kcT9++fVk2l/93unwuCS2HM59I1v5LWb+IHIVvfueEVtWu/7NCNN4w0bN5cUf/82znasKGqBvaWXrpbquKj3Q6buObFLyl2xcW2RETtMlFtFAsQsMQWE9qAZ3jYsGFOpBoehD4hNaQKRJiTapBFgfKLp04W1aWypPt+L110qrRkhXTqt6WvFkSjZyuWl/75f9Klp3vPciobNku/+Lv04HNe1BYGZVx2hnTr972XOvk7muPpnx/8SXp9TJ5H/7wTpXt+K1WtXHj5u3ZLN/5BevDZHFF9/Stq18FEtVG0mKg+eExUR4tEREW1hX8YxQI82f369XMZR/AK29LeB36ZEEJz0UUXOa81ISCZfsGwGyEOpUtJFSsQoqPIcMHJ0kWnSGXLSJu3Sl/OkFauldq1lDq3kWpUlf7vOmnKLGl8/glgHNh9zbnSb77rvdN4o+ctkuYuljq19d78pg2lO3/lokP08nv+OAT2X+/3daaDsJDh/bhLJK3bKH06qej7wTC+TuKapzrYFbdUgYVNwI8q2Zan2jAODb4MiKEOOaeN/Qnx5Ie6yEsUY7wa15duvFSqUF7atEW64XfSG2OkXXukapWln10jff9yL4R/fJV06c/Sx0Qne73PO8ELasr43b+lUS9Km7dJtapJP7pSuv5iqVE96eRB0ivve+/11u3SX+73g5J0Qv17l0oj+vMD4MNR5iw8ot1iGEecuOapTrYrTgS74kbiMDJwfVOYp9owShB8LXVqI/XrIVWuJK3d4D2rC5bmHz7B7w/H9O/h45GXrvReYbyyCE0m+QVwbFWpKG3f6b3ix/WSWjfzYpdY7vl+Ac2MwBPdMieO+b1PpRfflnbniOa1G6V/Py6dMkRq00zq3sF7rddsyL+8ru28RxrGfSnd+z8v1mHZTl/eSYN9ed06SNWrSBtzPkcwJ61In0v92tKFJ3u76UvCUAoS9oYRBeIo0EqCfVESn3E9TyaqDaMEUbO6dPv/SXVqkMVE2rlLmrdYuucp6ZEXpR0799+/Tk3puvOly8+UmjX0Anv7DmnOYmnGHC+c/3CPNHmWF9jnniBdcab0wWfSMd2l43p7ccp342OvSD//a8HCNxkmBlYo58UsEyyDoA6sWOMnKyKCCcFo1qjgsju3zZvMRXuDoA4QT71wqS+PR9sW0vip+ZfHb9fpw6QOrfydADzbs+ZnZpthGIYRP0xUG0bcyfKTFcNEPbyrgFjF84wX+raf+u233Z+XSQOh+scfSZee5j2xgDiuVFHq3l46qoN/z2RIRCrbCdfo01Ua0jevevbhwUQ/4o4zanKW1KOjr5fwi5k5WUySwSM8fa4XtHjdEcITp+dfJiKaOGqyhzBJkTjtZK8yfVMlZzIiz6Gf8oMyGEBQDhNDH3hW2r0nM/sMozgTxfzAB0OcvLlG8cJEtWGUABDPwO8kIQ1Pv+a9zT07SWcM8xMZiUteslJ66DlyLEs3fStPUBPq8dxoae4i6dijpBMH+lhnSA5PDD/D/GYh2idM8ynvOP6Dz6XlqzNrL8I3TAzEe06Wj3TMJX454b3uDev58Jb8pACp8paukNo0l4YdK/XqLH02xfcJg47h/aVOrf2+e/YUnqbvpEE+xR+8OVaa8lVmthlGcSeK+YEzIY42ATHiTOqLm22lImiXiWrDiDl8HYV4YITid38rvfCO99ISXkGoxp2/9iL5/JOkp1/3XuVTh3hBTc7li37sRSnHEIv83Yul330/zwOeCkKVrBnX3iytWX8Ibc7KS2lHfDZhKukIwpf63PduAaqamOcx431YCbmvn/i7z/BB5hDyVTNQqFZlf+96ftSsJl15lvduk5Xk/mfyayMev4Ox3DAy4ciKjLhl/Yi7XYjPuE2+jKpdJqoNI+Yg6sh2AQjAaXPzwh5YkZCMFeSBHtDbTw5s31Jq1UxqUt/vg/D8+Iu8Y4ipnjbHhzogysnNDMRUlymVtw9x2ociqEObWUURiIMmtCQdIXd0rggvQMAS+nHLnT77x+lDfdaQGy7ev84gzp2nvYCyhvWTenfxr9/7LL90flmaOrWFVq22fOtG0bJzZznt3JVhLJVRooiSVzeOmKg2jBiCwNznVOGBX7CpntMt2/0EO0Q1ntomDfykRLyweLi/mndgrLArI1V0Bk+xfC7pGXMPvf0I4KlfSQN6+VR4TKxMR8fWXgDv3u2zkhTmFF69Trrpb/755MFSw7o+JpqBAaEpZBCpVcN7tZm4mA766KqzfUgN8d4PPHPgBE9IJLI09sNuB2+8YRzk33q6zDSHA7fcQ97jOBF3u4JXNy7COjvJrqjYZKLaMGJIlcoJXX5Gtm69u5R27y74y4gQjhAfHbzaiFQnyfksHy9xuh/3sLw3HvGtfmX4Q4J2TJrly6NtR3WUPpyw/z6IfkQ1kNZv9qLMyl68XPrRn6R/jfLx4eTDZgGYlWukh/7kRfXiFf59Ohh89O/pX+PBJyymaEg3SokDZteRonpVn5mHLDwlXcxkQkmwK04kEoncmOqonC8T1YYRQxCc370EsZmt2+4vvd8EwDBpMYBnGqHId9aKtdK02dL6jV6o4rllYZO7HvcZLpLLT7cYSqAowohJb0ecMuEfJw7w2TW2JQl1YqP7HuXbjWd52cr920dGEDzIybHOhKtcdqb3QpP7+vFX8j5jOXJCXhD0i5an9z5Xrihdc44X+rSFWOrkNqUOVn72LalLTm7swsjmB2RfttPSpUuxMppi88O4L5Z2cTdon7vYS5f++kUa9fO3S+pK7rYUbdnxnggQV/ssT/U3j4lqw4gpCEuEJwRPNCL5houkv9wnrVrnczuzzHfzRv5H+t1xfjvp51z4RW8fO/zr70h3PuazeLRs7HNXh/R4qSK9qCCbBqn68Ar37+VXLnzyVZ+9BDFx8/U+fINb32Mneu94SAVI5hLS+k2cJt16t7RslRffF50q/eUnPpzlx3+WRn/sPewIX47BJuLByViSLqYaEX98X18WmU0Q5vnBPoOPloYem5m92LF3r/fKkM0kLuIz2AVlyjDxKB6GZWcnUuz6pltkGMY3jYlqw4g7WXlx1Ig1bhcff4xfKIUluRGmMHuhT7W3d6+0Pdt7hlkNkX3wep9yvM8EgqAlhzOiLzfrxoFVHjbUddt90iO3+cHAzTf4jBuI6kZ1pXo5eaSnzpb+dj9eQ/+eVRy/c6G/JU54yITp0oPPepGMmMZbj8f5P7f4lSQJMWFQETJ/vPiOXw49FcrDS036QbzfpB5MXk0yv+wkWwvZJ0D76Hv604lqxYM8u7Jc38dlsMC1v3dvlhJKuPNV5GOFnLAs+uzrxvJUG8ahYaLaMGLK7pzFUfAUEkrBZDyEAJ7l5o39AxCVTCq8+pfSpJl+G8c8+Zq0eZv0z194jzZe7+D5xruLQEXIhgl9ZAdZvMwvCsOkv12F5HnOBDzJ/3xYuukaH84R6g8QpvHLf0oLluVtI0wFsYsgQfwSyhK8zghmPNgXnORFMgvfBOibcZOk3/0nfY5q+o1FYdgPL/VraYR3MvTNL/7uV5TMDNLv8ZVM/KBiRLArPhOo8uwqfeTsyvIx/7/8ts9Y83US7InX+YqfPXE/X6UimKc6KxHX4CLDKMHwZ/3Yqzv13d9U0PadWe5H+aqzfIYMQikIqXBxwdultz+RHn7ee22DtzdArCahEdeeL/UldrOsF60sG87+eHwffiEvrR5e7ItOkZ57S5q3pGhsoY6BfaQRx3mRgRhes056/zPpjQ99iEhyu7Hr7BHeY00IyagX9497ZiXEkcdJJw32KQT5vl64zJf19sfervy+FfF8nzPSpyEkraBhHElIUvGTq6Rbbsh8NdKi+O4IsiBKE8RKsl3hOU7iOhFRu0xUG0YM4Yvo309t149+7xM5V6m6XRUr7ParB5byQpUfaVYORHAWlpKLY5gwiMjG+8uCLLm6M0WAhrCQooY2EHoR4p7xlOdbD7mmQ9MS+ZdXtZJvL/bg2c9khuWRss8wAnv3ltbGjdziyHLpG//9669XVCcTBSGTCWZXtM9ZVkSuQwv/MIwSwMiRE9Sj52EkjjYM42tjxYrauveek7VnT5lvJLaeW+4QtxRtcbYr5N+OSwaQRE46vajl3zZRbRglgPLl96hylZ0xi9U1jHhScSNB/YlvXHzGKUwCgkiLm11BgMYt/3Yiya6oEJ2WGoZhGIbxtcYfG9GKP44TiQjaZaLaMAzDMIwSQ5REmhEtTFQbhmEYhpFLnEIISqJ9xjeHxVQbhmEYhhF70Rl3u+JmX1YE7TJRbRiGYRhGLlHKtnAwmF3RolQEr0MT1YZhGIZh5BIlEXMwlAS74mJjVoodUbHLYqoNwzAMw8iFNGYhrV6cCCna4mxXXCZhJnIy0ETNLvNUG7H7kkzOQVrY6DZ16dpMjkl3fLpjk9MBJX8hJOfcpO2hvVFbjtUwjHhieaqjOQiKW/7t7AjaZaLaiDR79uzR22+/raVLl6pChQqqXLmyunfvrpYtW7rVpTJh9uzZWrFihY4++mhVqlTpoOrfvn27li1bpkaNGrm6030+depUzZ07V7t371bNmjXVo0cPNW7cWPv27dOYMWNcWzl+1qxZql+/vpo0aXJQbTAMwyhKouIVPFjimn872YETFfEZV7tMVBuRZteuXXr11Ve1c+dOde3aVdOmTdOmTZucwG3QoMF+X6D5eZGnTJmiL7/8Up07d1bFihXTeoxTv4zD9tWrV+v111/XaaedpmbNmjkhH7zOtOmLL77QBx984PYtX768Fi9e7AT8ySefrOrVq+ull17SyJEjXVt37NjhBgmFfemna0dUvnAMwzC+aeIorI3igYlqI/KUKVNGxx9/vM466ywncGfMmKFFixZpw4YNzguN8K5bt64TzTwjvOfNm6cqVao47/a6deucmMVzjOjl2ObNm6tp06a53m7Kmjx5stasWeO2tW7d2u2DF/qtt95yxyPq+/Xrp2rVqrljNm7c6D7DK33KKac4L/X06dP15JNPumN79uypvXv35i6dS/2UgxBHgLdp00blypVz9rAfHm1EPDbhAa9Xr546deqkOnXquPpMWBuGYRSOfVcaRwoT1UYsviARuojrIIIRqAhhwkIQoAjpbdu2aejQoRo7dqzeeecdDRo0yAnVIKgR0+yHxxihmuzNQJjjYV65cqW2bNniwjnwNvOachG7a9eudeI31I9Y55gTTzxRDRs2dG1r376980ovWbJErVq1cvtSD951BHifPn1yy0T00473339fZcuWdfsh4mkDNhMuwr4jRoxw4tswDKOovlPjSJztilKIRJztsuwfRuQhVnn8+PF68cUXnehEtBKXjFcabzNxyqtWrXIhHps3b3b716hRQyeccIJ74PElLvrdd9/V1q1bndhu27ZtrkDnj5qwEMrC64wXGfGNkMabjDg+//zzdfbZZ7tyAe8zZSF2CUUJYSEIfzzWhIbwCFAHgpx9OnTo4AYEeNOXL1/uhDPHIOQnTJjgJjpiG4J94sSJrh7DMIyigu8rvmeiJGYyAZvialf4jYkTpSJol3mqjciDVxjvLZ5mxHTfvn3dhEM80oRO8BoxjThFgPJHivAmBhrRyx8sHm2EM2EaCGU8w+EPmfIXLlzovNsci1cZQbx+/fpcwUw5HJOcrB7xjVBOjpNGbOM5D/unQlmIdPYnFIVwE8oh3ISBA++JxaZcBgsI8Ch94RiGUfyJUraFg6Ek2BUX+7JS7ImKXSaqjchDXHT//v113nnn5Y5s58yZ4zy9iM7hw4frsccec+EYCOTgMU4eASPGCQVZsGCB5s+f744LnxP6wTZE9I033ug81I8++qgrC6iT18np9Ti2du3aTtDTFoR61apVnXcZr/gxxxyTG3udDMeyHx5x9sVTTSx4ixYtXLgH7Tr11FNdGAked/ZHZBuGYRQV4bssOf1nHCgJdkUtXKIwm6Jml4lqI/Lwh4bnF08zr/EGI7Tx8BK7/PHHHzuBjcBNzUkdXhPaMWzYMBcigkca0Y0Q5pk/aI5FOOMtRpwjsEM9hGZ89tlnzhPO5ENioSmzVq1aGjhwoMsuggBGLOMRRwQzwZD36b4kqLNLly6aNGmS874PGTLEhZUgrvHIYw/CHA84Ex5J0Zfpj4RNev96icBvgGEcQHASxM2zG3e7IE4Dhn0RtMtEtRFpEKAIWcRlgC9L8j736tXLxSATukGMNOEeeIfbtWvnwj/CHymCGoGK0EUIk30D4RwmEiKcO3bsmOvFRmCTbQTPNuUMGDDAxXKTlYMygqhmv8GDB7vXZP3A483EQyY4Es7BF0bv3r2dl5x9jzrqKNdu2oWgR1jTNsrE800bCDv5/PPPXRtpV+qEymSS18SZO7eR9mZH40spHaWypArlpTKlpZ27pD17pcNJisXPKdE3ZUtLu/dIe/xNh7SUL+vrdgflQyJb2r5D2pvT52VL71PnrgtVqdLuw2ilYXwzxD3lXNztM745shJ2dRkRhssXsRqyfyTnlUYo80jNEIKYxcuMJxuIT2Yb3m628x5hmxpXjbc5eXWnEEJCHeEYygxiPdy6Sm4Hn1FPmASJSA7lUH5oY7CL5+T9Q4x2aAdtTG5ncr/84d6d+u0dFd37UwZLC5ZK0+cqUlSuKPXvKY08Tup7lFS+nLR6nfTep9JbH3l7DmbV4dKlpPatpKF9fZl1akmLl0tvjJXeHSctWbG/N79uTemuW6S2LQoulza8NVb67V3Srt2c53367vdeVqs2Kw7deKPEsnRJHf3rn2dqz56yuvps6c5f+0Hg10H4zoJwpy4OhMngPPN9muniYFGzKy4TMRMRtcs81Uak4Y8Mj2267YjRdKnmUr9MgzAF/nD5IUl3DOEl6UBIB4Ge2oYwYTHd55BcZrIdHJeuvuS2Fsa+JLF5+lCpQ2vp4p94ERkFOE3fv0z62TVS5ZSFLof3l751nvTtW6T3P8usPL6Pj+8r3fErqU2zvNCMXp2lM4ZJn06Srv+tNG1O3jGnDJFOGCBVPPASO4DmjaQvZ0rPvOnfZyeK/w+AYRiGUXSYqDaMEgDOpmYNpYrptX2xZER/6YdXSJUq+nCP5aukLdukenWkOjWllk2kP/5QOu8H0pKVhYePnDFcuu2nvh9g/SZp7QapYV2pSiXvCX/gj9KNt0qfTfH7vPq+NLK/1Lp5+ugPwkLaNPce8L37pEURGbAYRkFEwSN4KEQtk0SmmF3FBxPVhmEUO2rXkH7+Lal6VR9D/ed7padekzZukZo1kn5zg3TSYKlHZ+lHV0o//kvBYSCEjVxzjhfUJG15/FXpv09KS1f50A7qGtpPOqqD91oHUb1mvXT5TdxFOLBMfpYvPs0LdUT7m2OlybOOXJ8YxtdFcmrQOBGlLBIHQ9ztihImqg2jBEEMcdXKXmTi9V24TNpcyNoxdWt5r3DZMtL6jd4rvGOXF5J4kAN8nzORENFK6AbH4FHm/VcLvCDOlKM6Sl3b+9djJ0j/GiVt25HnYf7Vv6TeXaX6daRBR0tVK0mbCrAD4UyZMPkr6ed/815qWLFG2rBJev0+qUEdXy7ecSYewq49/pFKzWrSOSN9v9CH9z/j46kNI+rEJY46lbhl/Yhznuqo2mWi2jBKCHh97/yV1La5F9UbNksfTZBuf0T65Mv9Y7ChUgUfT3zjZdLR3bxgXrXOH0PsMGXc+z9p1VovqHt3kS46RRr9kTTwaOn8E6UmDbzw/uN/pX8+JG3PW0SyQFo29qEqOCle/zBPUAfmLJI+n+onYNarJTWqV7Copv01qvmMIWM+zxPUgdkLvfBHVHdo6eOjZ84rPDwFm4FJjhOnZWabYRR3mAgdR3FteaqjRSJp7YeoCGsT1YZRQkAkd2nrX/PdhKf11CFSv57Sjb+Xnh+dJ6wRtMQz3/StnHRyOdSvLZ090j+AOOI//dfHJCPYe3aWvn2h92KH7z88ucP7SU+8LC1YVng7ObZbB+/tRoRPmnngPniEEb2I6mpVfMzzzPn5l4m3HIFOk7CHGOjkQQSflSub580vTFRT55Vn+4HF1u3eS4333jDiIqrjnM85rnbFbSC0L8euKC1VbqLaMEoQiNHPJkuLVkhd2kjd2vv4ZQQx4vCND71H+vqLpJ9f60Xjjp3ShGk+3Rxit2Nrvw/f4SFRCt93WaXyQkD4bOlK7wFft1F6/JXMBDVQJu2iLEIwUr3KgRk56QERw43rF1zmRxN9fDQe7cFH+7hsUgwG8Di3buZf41kvLIyDMvr1yAtPwU7DiAtRi2M9WOJun/HNYaLaMEoAs+ZLH3wmPfOW9OSrXqzWqiF961yfZg4B26m1NPpj78nF8/vpZO/hHfWi9PJ7/hhimK89Tzquty8X4Rw81hOn58VnE6f8l3t9vdmJg1vJkV0JL0HcriTeeXP6/RDphHJQPrmrC4KsHKS6I66atlx5lvTsm9K8JVL3DtIFJ3mRPoPc4bv8QCA/yGjYpZ2fzEgb73z0wPAUfOLLltY5rAVqjJLL2jXVlbCUjIYROWzxF8OIqSfmd3fv1u/v8rEbLhyDkIeUlQMR0+FuIWIzZNAgPMLFSiQOjLVOPob9g2BmW7hDl1zWoZBbVpr6c9vBfqUPbEehZboG5on90De5FFBn5u3jFjOPgssxjLRXj7s2uXiy3ADw3zfnhScdaWzxl2gR1UVS4mqXeaoNI6ZUq5T3K4yA1L70P96pQhsKEpX5HXM4IvpQynIm7Tv8MvPrm0MpK48sJ4rsLrNxuJOL+3bPG8R+XURBvBwqcYunBuyJY0q9rBy7ooSJasOIKTWq8uPhV1Ns18LHTJPrmZR0Aby05Hsm9INQhhff8Sn0BvXJi0UeN2n/clns5LQhPnb6w/E+TAQv2oUn+/AQQjaefuPw0st1beeXEUdMsCQ5Md3JMInxjKE+DnrbdunJFLsKg3Kb1PcZQchesnuPdP5JfgLiomXSc6N9SEsqHVr5yZEcT7YQFodJNwChXymvac5CM5nhZ7ojyP1vY1x+IONuVxChRWsXpfXq4q83d+foayTOearjaBf2xGXZ9XR2Rel8mag2jBjDbwhiF2G9er30wef7i88GdaXf3ehFNQuhIKrJCvKL63y2kJfe9XmdQ87mIHh/810vpG++w4tq4rDJ+tGjozRhuo/BPhxRTSq+X37HZyEhY8nVv9w/JzYTE3/3fal1U58O76nX97c55MtOFrxkIenfU1q+2sdSYy+v8TqTHu9PP/b1EXtN7HkqTNpkyfQLT/G2fe/W/D3WhKWQHWRgTux55kTnx+PgMLsOpcsYnLmXX3P3xSmDREmzK0oCNI7ny0S1YcSccuW8ZxexjPeXLB5k9MAr+63zpI6tvBAlg8WyVX6y4cKlfjLe8P5+gZPn3vJCktvRlIHA5LubsgOUQT3ue/Awv9eZNMgkyPYtpRHHSScNkt7+2Atr0veRnaRNM9+GaXOkTTkLy1Qo50XvwD7S+CnSIy/6SYTsN3KA9J+bvX1X/dKvfoijsVF9n4u7cs5y6GPGpxfLDCbwGiLYpyyQXh/jQ1DyA0F0MM4jH0eb5/mMy2+j2RU99vfAx4eSYFecwkASETxfJqoNI6b4G+55t47xJuOVRqQimlmxsGcnL/zIdvHCaB8Ggeh87m2pZVMvYP/9a+m8E7xnl+wZZMtAOCen1CtqFq+Q/vOEXwK8VnXpvt9Ln0+RVqyWOrfNS7nHAOGfD+eFagw9Vvr7z3278c6TOSR4sds1l+rW9t75/93uBxF79/oVFFs1zQt3IV93Knjl8TwTLrJnj/ToS4WEm+RMYKT8TMlOJFxeVnfOypSJjW/XTTjKCX4vEyu7lGdXJreoGWQlT5YtxnAdQtRuvWea99hdhzGyi7ziPOJqV+mciYpRwES1YcQQfvBXr0soO5HlRHLIjoGHedix++/HKok3/NbnqAa8tax+iHgkVzUCFS9v8jEIxkS2tCUnhR6/wYSIUM/u3QcnJvNrP6n8jukunXdinpc9mY2bpT/cs3+8dVaSd5hn3od5LojrM4ZJR3f34SPnnrB/feSt/tXt6cUyHvpenfzr2Yt8Or6C5s/QDwwKCKfJ3OYsZSdKEXn8tU9MO5L4CZshljUaojJzD3xejG5hdiGoTx+WrYG9SxX78xu1yWEl3b5gT5y81FE9T5ZSzzBiBt9D732a0JW/IF90ltq2kH71HWnZSr96ImEMhDDs3O0nId71mI+1To5ZBsQ0IvQ7F/qYa4QAwvmjL7wnGZHw+7v94ixZOUuBE0aBmPzki4JDIw4mtvrqs30ubdpAjmgGCROmSs+/7b3KySsZ4tX+ydV+oiV5s3931/6Lx2D7NedIg4+RmjGJMEtauda397GX/UIu6SYoEspBKMx150sPPOuXTo/g973xDdO0QUIP/SnLhScVV+1jKfWiRVRTz8XVLhPVhhEzEHv/fdpPpIPSpfepcsWEdufEIzes60NBiKsmhnrrtvwFMN9hhDw0qiuVLy9t3uIXdkGAI7JZKCXAe2KaEetFmV6PcqtWlhrU8e3Gk4xQpu5UYUt78caXL+tDWWhL6j6ErNSo6stjf8oi/IX9C4KBCDHk1FuU9hnxJzs7S9nZ/hbKf3/nFx8qrvrARHW0iKr4jKtdFv5hGDEk+fbyiBET1aHT4m+yOYZRopk+rYVGv+VTwXzd6fFKSn7ggyEK4uxQiJtdWRG8Dk1UG0bMqV13k5q3WP1NN8MwSiRoghUrailK4BWMW3xusl1xI652ZWVlRcZDHTBRbRiGYRhGLlHJtHCwmF3RIornK3otNgzDMAzjiIHXM46eT7MreiQidh2aqDYMwzAMY798ziGnc5wg57HZFR32RfA6NFFtGIZhGEaJ8ejGzTazq/hgotowDMMwDMMwDhMT1YZhGIZhGIZxmFj2DyNtwvVdu3a5WCZS2ZQtW1blypU7rNQ2odw9e/aoQoUKR2RWb1i0gLYTO5fc9hCXxWtItiPcCuRYjitfvnxGdrIvdXEcZWAT5VPnwdjHsZTFgyT3fsnj6KQQMgwjXkQxP/DBYN+vxpHCRLVxgPCdPHmyxo4dq7Vr1zpx2KVLFx1//PGqW7fuIfcWwnP69OkaP368zjnnHNWqVavI2759+3ZX/rhx47Rp0yYnjjt16qR+/fpp6dKlrg1HH320257K7t27NWPGDK1fv14DBgzIFd/5gQBes2aNxowZo2nTprl+q1Klio455hj34HWmUNaqVatceY0aNVKdOnUythnsB8IwjKIkDOzj9t0S13zOcc8rnhUhu0xUG7lw8a5evVqffPKJE5mIS6hevbq7uIOnGREIwSuLF5j9IXiIEa7B6xq2IxqnTp2qU089NdfLG7zhlMX+YXtyOWXKlHF1U0fw5ob9g0eFzxHUH330kRP/PXr0yPX+IrbZFrzVlE+ZHB9mF7MfQp/6sDXYRLm8x04ewZ6NGzfqww8/dIKaQQd9xP7Bc53c3mAH5fB58qQSyoR58+bpyy+/dIK8atWquf0avODB5mBrsAU7MvWsG4ZhxDU/cFxFWiaYXcUHE9VGLnzZIBbXrVunVq1aOQ8vos1dKGXKaNGiRU60LlmyxAm83r17q3///po9e7Y++OADJwQRzjVq1NCIESPUpk2b3OOTQWguX75co0ePdh5kwkGOO+44de7cWStWrHDbaUOlSpU0cuRItW7dWjNnztRnn33m2odAHjp0qGtj+PJHODMYoKyTTz7ZeXwRnps3b3b74L3euXOntm7d6uqkzI4dO2rBggXOg96wYUP3Gd755s2bu3ZgE/tiz7HHHuuEehC2K1eu1Mcff6xBgwZpyJAhTggjmKmPfqC99BV28Bn7NG7cWK+//rq2bNmibdu2ufoQ0V27dnVtx26Ow+bu3btr/vz5mjRpkrON9nI+sOnzzz937YOjjjpKAwcOTNvPhmEYxv6/cXEkrnZFEfslNnJh9I63ltAFwhoQyIRP4IlFdFasWFHNmjVTtWrVnBidOHGimjRp4gQeXmLEIUJ67ty5zovbtGnTtGKP0AyE7MKFC52w5f1rr73mPK6ISoRpu3btXFuoi/IRqJUrV1bbtm311VdfufrwDiOw+UKhDAQ3IrNBgwbOFuqmDDy7eIIRs7SJ1wha2sqAAOGKCGfQQJt69erl6kP4Ux5tqFmzZq6ATx58MBBANFMfgp4HghuBzHHUgTCnP/D846nfsWOH+vTp4/ZF7CPa69ev79pGfyPqaRcP6qVthKbgrWYfjkHcM7Cg/+PmdTEM45sFx0e4Qxan7xezK1rsy7kjG6Xr0ES1kQsXLfG8J5xwgntetmyZ3nzzTSfoCNlAyBH7i6DmgWcWjypfVAhDPNe8B+KyCV1IBwIYYYygpi5E81133eXKpkwEKyAuEax4ZnnUrl3btQvhCwjTIKqpK4SRBPGb+kfIe7zFiF2ELvXyQNwG4QpsQ2D37NlTw4YNc2KfP27+sCGEYPAcQi9CXbSDfiMmPcRHMzihTQh0hD5e58GDBztv9T333KMNGzY4scyAAc81/YIXHO817cVjT3/RbsoLgwvi3NPFhxuGYRwOIcQvbpSEfM5REZ9xtctEtbH/BVGmjBN1eKQRuZ9++qmmTJniPKxc2Ijlbt26OTFHeALCEFGK0EPg4s3mEWKH04EgJRQDLywiGNFIGYhWJhJSFnU/9dRTTmQiShHUeMwRmYjdevXq5U7o44+NYwBvNMI2hGmEuOrQFurBu0vsON5jBC3eZNoc/mhpGyKa8umP4PUOBK802xgAIJ55HcQ9x2MTXmzEMtA+POiIa9oe2kvb6I9kcUw59Cv7EXLCwIJnzgll46HHAx/aFJUvG8MwDMOIMyaqjf1AlPJANCJg8RbPmTPHiWTijYEwBkI/2B48GqkzxQvyBFA2ghqPM8ITAU1IBJ5YhDnl4yl+8cUXnXBHtCJS27dv77zTYXIh20LdCM+WLVu6eG9CS9iXNiPIqS/AvohowkwIOSHMBLGeLJoRrYhs7KOc4I2mnGAn7aQ+vMnYgshFCBMygqDHc089DBIYLGBf6JOQmjA5bRXH0Jfsh20IcMQ29TPIIVyFNtJnHB+85pkI6n37SmvPHr+/8fWQlcUtSyapWo8bhmGUFExUG7kg8IhnJp4YMYtgQ2DjMcU7TSwyj1GjRrn9AHEXsmOEsAu2JWfKCGWHzB0IUOKW3377bT300ENORHbo0MF5holvnjVrlhOobEfUIypD+jomKyIu8VYTbhJS3yF4Cal455139PzzzztRTHsQp3i7qZfj2EZ8OEKYQQIeYEQ7bQ374MnGXkIwEOl4yamP8A3qY19ioAkNeffdd/Xggw+67RzL5EnKRPzj5WfwQV8E8c7r5FzUIatIENFhIiOCnD5++eWXnU20m4mKDCSCHZkydkw3zZ/TSjt2cZcgehd86VJS7ZpSk/oSDv31G6Xlq6Wt26RDvYlbuZLUpIFUtZK0fpMvb+euA/ejm9u1kOoWkgFy3z5p0XJfDuOkMmX26bTTx6lOXf93YhhRwvJUG8ahYaLa2O+LFG8xwhDhhqhFrCLweCAuCVsgJhpxx4RGvNnsi2cWYYi4RDwiWhG2ENLaIRIpP4QzIAwJw8ATjMca8U54Aw/CKNiPGG3qPfHEE3MnMVIfwjiETNBuyqKNCNYgytmPkAn2xfsdFp5BxJLNA4803mZsoY2IdMQv4h4PM9sR89jMQCBZyGIbbaMNeI8RxOxPrDP1EStOuj3CQziOdtAnZPagLI6nfWeccYYbOOD55jPiuekHzgH7MemTvqPdCHnaTCw1/Z2psK5cto6+f34dvfyu9Pzb0u70oe7FklZNpRsvlQb0lto2Z8DmxfTU2dILb0uPvCht3Z55eZUrShefKp0xXOrRUapaWVq3UZo4XXrkBen1MdKepIFHt/bSX74nNa5fSMEJaewE6fKfSyvXIsb3aeCgqSaqjUhiKdqihZ2v4kNWIm4R+8Yhk3wpJL8uKKyjsPADPmdBFdLTEY9NhhAEJ0I1kzoy2R5eh8/z2y+dvYV9nlpOuvYcbHsLakO69wWVkW4bh9z3jHTDb/37v98kffcSadkq6YRrpNl+nmexp1oV6YE/SKccL5VJE72CmL75Dumux6TsDL7FqlSSvn+Z9JOrvbhO7jr6bM166aa/Sf97I2/gceZw6f7f+7YUxq7d0vW/lUa96EX19d99RW3aLj8Yk40YwrX12acd9NQTQ9x7rqfLztj/+itOJH+vxWkBGLMr2ucLonAtmqfaKFCopnIoFzXeY7yvffv2dd7dMCnwYOvIRMAfTBszLe9Q68ukHekylBxsGYWBQ5sHXt4IfCc5SmVJ154nnTTIh3/g/f1wvLRitdS1vdT3KC+Mf3a1NHmW/6wgsP3Gy6SfXiNVqiBt3ylNmiHNWiD17Cx1buNDPP76My+On3nTH/fmWOmmv0qtmqUvt1E96bwTJNbwWbKy8HYYRhQwX1t0iVKmjDhioto44hDyQTww2B978YDv3IO9R3VIx+Q8Jw4h7OOac6WyZaTV66QrbpI+nEAokY+r/tEV0q++I9Wv473P477cP2wjFWKnzxjqBfW2HdKNv5eeH+0FNB7s710q/eI6qXYNaUR/6bnRvq4dO6UHnpWySqUX6rSBAQsx1U+/Ji3xa/IYRqQJE9DDhOi4QEhj8mTxuBAyXJld3zwmqo0jTpxuIUYZxF//ntL5J3khiff3vXHS1DleFKajfFmpbw9p2LFkKJEWLpU++FxatdaLyrXr8wRzubJelG7YLNWo6r3M7Vv6UIonX5NmzM28rR1bey8wvPWRr3NfTurc7TukB5+TzjtR6tDK71uzmrR6ff7l4Y1u09y/fv9TH1uOuIaNW3w8Nf1Ce/GE034mMAL2JdKk7W3WUDr/RN+vS1dKj72c10bDiIOojptICzmP47YMexDVcfutzY6gXSaqDaOEUKeG9Jef+sl5hFQgdq+/UHr4Belfo6Qt2/bfv3kjHy5x1nAvlvlO4xhis+cv8V7km++UPvmCbBfSdy6ULj7Nv+/VRereXqpQ3ovSti2kH/zBC/lMYFIiIn7vPuntTw4Uq3ivJ830orp2dalZo4JFNWK5YgXvaZ81X9qWMrlx2WqfuYP9qBsB/vmU/MvjNxkRTh8Rz/3sW9LCZZnZZhjGN4uFtxhHChPVhhFzwgAf4Vu9iheohD3wHjH682ulWtWl39wpbc4R1qSb+9cvpRMH+uNxXCFwEdItm/jwDATq0L5eRFeu4LNqkFHjqA55dROSQX0bNxccnpEMgv+ojv4Z8TsnzcRK2jJtTl56vJZNpQnT8i8TzzoLfCLyG9aTypfzfRAgPrtGNf8a8Y3nuyAa1vX24q2nbAYmtMkwDMMouZioNoyYQ1gGIILxxt73P2neEqlPV+nS032ow7Xn+6wg/33a7/+r66UTcgT1omU+owXHHNfLh12EbBjhLqoLkcipj2MQ0O987GOT12+WJkz1qesyAbGPaAdCNDZtSb/fgiV5+9evXXCZH30hLV7hc06PPE46rqeP0UYIY+85I6X2Lfy+iO+dSYI7FewjKwjebPr0xXfSC3/DMIonUQklMKKHiWrDiDnBg0oKumt/Lb0zznuen3vLT/B78I/eg3vOCdKjL0l1akrD+/kMHIjwc38gTfnKH0OYAxkzbvuJF9TpUtkhNJ96zU8GPJgc0unazIIs+eXV3rUnR8wnvNDNKmBCJPHR73witW7q7Xvsb9K746QZ86S+3X2seSWfVj23zPyoV8unRCPN39oN0kPPZ+6FN4woEGKO4yY+oxSbezBYnurig4lqw4g5rKKIIN681a/6lzMHyQlBJgGOmyQNPtrHEzPpr3NbLxzZ74XR0rTZeccgcBcs9YK2QlIIBWEQhGu4erZJDz136IKaMsKD0I4gdlMhlIUJhAhg2pEopA8IbyG048JTfLjLuSccWC9QXn4TN+HkwVKn1n5/FosJYSipUI6tAmBEkbhN5AuQzSSOKedMVBcfTFQbRswZ/bHPcMFKhHhWk0H43vW49PEXXngivOctlm6733+Odzc1Vnj2Aukv93lPLfHUwaN8/zNSvdq+rimzD7291MfESTJ+IOK3bE2/H+Ecf/yvF8AfTSy8XNp18798KApx1akgktESTNhkMmM6sJk+o39oJ6s6pvOkJxJZGv95e82b16jwhhmxZ9nSOooScV+mPM7EbcAQNWxFRcOIGfwW/ucJ6Qd//KZbYhhGKv+5xedgL67aBzEdUpnh2Y2LSCsJdoUUiHGwLRFRu8xTbRgx5MSBCT39OqEdfBHtvwhLsgMqv88O55jCYpIzJbme1NjtTNp3wPakTCip5RE/HihoyfOwXyY2JrcxM1ILLP4/IJlhdjmyfLac4f1V7LHFRKJFFPM5x9UuE9WGETP47iHt3YWnJPTZlCzd8l2pV+e80A3Sv5FrmhjqK86UGtX3scks0MKDtHn/d53Uu4s/Zvoc6ZEXfR7ojq28l612Ta+Vnn7DT25kpcI//Vhq3cxnwvjVvw7MBX0wkJHjpm9Jx3T39YyZIL32vrR2o9SmmZ8oSNo/Qj8ef0X63xt5qe5+eIXPX00Yyx2jpAXLfJ9ceprPXEKKvxfe8YvAEMJBTu0LT/b5uwl/+e2d0ldpsnkM6Sv94HIfIjLmc+kfD+cfe018+e9/4BeSyZREdkL7srOdlHYr2UXjN6RQ+FHcl5No3HsIFQt87L2/AEqXLnyRFK6JLm2lBnVV7Il76Efc7TO+OUxUG0ZMYTVEPKsswkIaOWAJ7vNO8nHKLOgScjOT45k4Yn5rEJqTv/ILubC4yYjjpItO9bHEZM6oXjVvyfLPp+Wltet7lNSzky8XYX44EKdMnPT1F/nyhvaTbrzUp9hjsRfaAMSCfzg+77h+Pfwx5KEmznvyLGnhi76tlDmwj890MvRYadU6H0fNpEy3MIyku5/wIjwVVqBEUJ8wwK/o+N+nCp7MSP8g7ElbmCkMbPbuQ1RnqXSZ4hsecLB4u7yIKVMmPpPEEGZ79wa78j9fiOkqOQsuGYYRb0xUG0YMIc/yhGlZzivL8uDHH+MFJJk0EJHkdQ4C+vPJ0jW/kuYu9seyH7mXmbDHAjB4huvXkernlM0xZNsgn/O8RX7b7t3SzLk+K8bcRdLOnYdvw5jxfkLkzTd4UZuai/qrBdIv/7n/Ko0IZdLnNajj289nwSn1yvt+KfHLz/Se8KYN9i9v9EfSXx9IP/EQ0cR2+ob81u99WnDb6aMb/+A9+JnD5DCfVDwmujPJrjIl1i7ubHBH6IaL/WDPMIz4YhMVDSNmICJHvSTd8FsvflmohcVNFi/3i7cc19t7a8kG8uZYudjrZPEZIAKBvM5XnCUde5RUtqy0YaP02hgfPkIZiO+Qo5nb2qcMlt740H9eFFAHqzQO65eTS7qCtGKNz7VN+AbLpSfHQCNa8Cb36SJNnSO99K73WCen4Tu2h3TSIKlrOy+GGEy8McZ7vVkdMb8bwyxfTv7uN8b6tIKGkSncCXnoT9LZI6ISrrMvd0JfXNLrlRS7ohR/HEe7TFQbRsxAHN/3jBfVUKvWZlWu7F3HfCchVBHMpNBz+Z0zmHDHMaSTw1ubvLz31wVtQDDTBrzwtP1wy0PoAPYUFMphGIfKlq0VtXGDj1V69DbpgpOLf18iYkLMcVSETCaUFLuSn6NMIsem5LziUbDLwj8MI+YMHzFRPXrO/aabYRglioSyNO6Tjnr5RZ/uIwJ6IJcoiJdDoSTYFRcbs1JypUfFLhPVhhFzypbbqwoV81nr2zCMIwJ6oGzZfZFNZQZxCZEoSXbFZcXIRI4HHtvC+YqCXSaqDcMwDMOIdH7gTIi7XXEbMOzLiamO0vmKT+8bhmEYhnHYxD2Pc9ztM745TFQbhmEYhmEYxmFiotowDMMwDMMwDhOLqTYMwzAMI5eoxK8eLFFKzXYwmF3FBxPVhmEYhmHkwmIbcRSfUcoicTDEKetH1O0yUW0YhmEYRi5REjGHk/s4LsT5fEUNi6k2DMMwDGO/FG0h93Ec7YqbsDa7ig+x9FRv3bpVixcvdqMcbh9UqlRJ9erVU7ly5Y7oyCckK9++fburh3oPpr5du3Zp3bp12rZtm6pUqeIea9ascZ/VqlVL1apVy719RT3sv2zZMlWsWFF169ZV2bJlVdzYs2ePtmzZ4l5Xr14997YiXwKcp7Vr1zo76KfKlSs7O8qXL39Av4V+3bRpk+sHPt+5c6c7hjLpJ8qjDvqqTJkyh3SuqYc2cw44PrnPCzpm9+7dWr16tWsj77nWGjRo4M4J27gWiuL8hH7gOVxfURzNG4ZRfIl7Puc45XKOs12JnMVfonQdxlJUz5w5U7feeqsaN27shAwi65xzzlH79u2PuPDcsWOHvvjiCycMe/funSsi8yN5xIxAfu6555w4O+qoo9SsWTP3nvYPHz5cPXr0UIUKFdy+XGgLFizQ3//+dzVt2lTXXHONGjVqVOwuPAYJH3/8sRsgDBgwwAlBbN64caPGjh2rzz77TJs3b3b91LJlS51xxhnOntR+27t3r+bOnau3335bgwcPVtWqVbVkyRK1a9fOCegnn3xSCxcu1JAhQzRo0CDVrFkz3zaleilS+wxxPmPGDHet0OcI5IJAhM+ZM0cvvfSSE/eUX6dOHV1wwQVO9E+YMEG9evVy12O6NhzMOeO8T5061Q0ojjnmmNzrwTAMo6iImye3pNgXtfjjOJ6nWIpqPJ8IoSuuuMKJkNdff12ff/65EzWIMbydeE/5DLFXo0YN9xqvKc+s4sOID2GEFxgvJOIwlMs+HIOg2bBhgxNhgFeTcseMGeNENd7x2rVru7IQkRzPdkQygo19OTbcupkyZYqmTZumk046yQnqSZMmuX1436ZNm/0GBHgrGTzwOfsh5urXr+/EFp/RFupC5LMPdgPtpR0IUdqBfdiNjVzAiFeOxT7243j2QQzTb+yHYKW9vKf92BeOSR5RUh79Nm/ePA0dOtTVGc7P9OnT9cEHHziB3LFjR1feypUrnZjGS4zQZj/e04f0O7atX7/eiVi28Rl9MnnyZC1atMgNmrp37+7qWb58uduf42gv7edY2svnHEs7Qx08YyfnnPOKsA+TJDgOW3nNZ+xDvcFO2srggHIvu+wy5y3nHPA8e/Zsd/0Fzznt4DP6meuMstiefH2E9vKe88U5oI2Ux77Uxfnm/HFN8xynL1LDMAzDiCKxFNWA+GnSpIkTG4QUIGQQY4gRvJ2zZs1yAhHxevLJJzuR89///teJGsQO788++2znMcZr+eabbzrhg3ikjFNPPVWtW7fWa6+95jyoiLdjjz3WCbHx48fnCie8szy///777njEIJ7Utm3bum0IJMRo8N7ihURoITD5nGf2Yf/gfWVfRB7twhuOxxpRiRDkGbGKEG/VqpUrj/b079/ftemjjz5y7cdOhC4iFC/v0qVLc8NNsPnEE0902xD5vGe/Dz/80JWP15+20j7qpo+7devm6gzCGoLwRnSGuwaAUEQIN2/e3LW/YcOGbjvnAijzjTfecMKYY+ivo48+Ovfc0p+IVcrAu41NEydOdOUi0An9wQuOLZyv448/3nl1X3zxRdeX9At10h/YR9voZzz9Z555phO0lEkf0W/cefjkk0/c/oR0nH766W6QEwYJtCcMrDj/DGAYUHG90S6ORxjTLmykbPqGa4Y+YxAxbtw4137OwYgRI1x/YyMDNO5gUBc2UD9t5vrlOO5g8CiOoT+GYRiGUZKIrajGS0l4AMIZT2zfvn2dGEWI4TnldjwCCIGDhxgRRPgAgobP3nrrLedNReAiwvESnnDCCW4bD8Qiogdhg3BG9LIvwqtLly5O1J9//vluP0QunyHYEE+IU8QeYgnBedFFF7n6CRNArCLmgzilrYg4xFQIiUD04wFGdLIvx3711VdOiOG1RLytWLHCbceLjZ30x3vvvedEPfshyBF82EX/8DlCmvqxDy849VMPNgG2sC/bEIqIVsItsIO+QCQj/EK4BEKTfRnUJIcpIDAJcUGII0BDHBhiNnhvBw4c6NqC/QhaBG+A80i/U3bnzp3Vs2dPVybnmIHU888/7/r3lFNOcf1NW/HiUydtYj/CRhDuCFlEKaKdwQd9wvlnO21GrHJuKY/j6bfQHrYBNnTo0EH/+9//XN+zP2EjbGNAwnnlPNHvDMB4DBs2TMcdd5zr93feecf1EQMM6udBvYTN0B/sSz9QN6KbQQF1X3rppWlDZQzDMA6HuN/5iqt9cbMrK4LZWmIpqjkJCOp77rnHiRYECGILgYKo5rFq1Srn/UMoBg8yQhZPJ2IIkco+iEjEVKdOnZwIROwgkjjZeI4RnHgNQxgJAguhyjN1Im4R9ggqykCIUh4PRBueVurkGEQ9bcVzSnkIQcQd7wlNCCAoqTOEMdB2vMaUjeBC3FIWAhsBh7eVfkCU4SHFNkJCEK9sR9RyHPYhVBHUPIfQhNS+pR68pWE/yqAtDBCS/wAIm0D4E5aRPPkwTOik3tTyOUf0OwMPPOWUwYPBDmUkw7EhvANb8T4TMoHnGHvob9qEsOY8AJ5iBC/nh/IYrCB8eY1wpe7kWe/YRl9/+umnrh3YTv/jhQ5wbhDqnAf6lsdDDz3kYqppG3VxDmkfAxAGO1xjnHsGXPQl5xFhzfnm/OGt53xx/XEtUyfx2cAzbWzRokVuSIhhGEZREdc81WZXtChVqlRanVCciaWo5gTgScSTh3h899139eWXXzrhgwjDI0gsL0IMcYeQRRwicnnwh4fIQrgg0JIFIOKR1+yDGGZ/JqkhjvDW4mFNFpZBoIUY3lAO+yDQEc/J8bmFEUI/8JYimB9++GEn8BBriD9EI+IYmxHz2IE45zgEJLYjIqmPerF99OjRrh2Iw5AhBbtpM8chdHkgMKkLmxBzhGXgRaWcIO5DGEKIp0akEmaSPNkvxC7TZjzH1B2ymXC+CN2gDUxapIxnn33W1Z8JYaZw6O/wzHZeI0ipP/Q3549t4dxiX/L5I9wFQc2giP6j3xG+qaNnyuzatasLCeJOxVNPPeUGNvR/6qTE0NchZhsR3adPHzcICJlDGHTRR3jhuRMSrjlEOqI99LFhGEZREyURczCUBLviZGNWBG2JpagGhBIeUkIKCA1ADBEqgIDhNj8CBQ9imLQXJtilnkTED0IGjyueTLyKIc0dxyJKEUPE5CIIw6QyXiMIqYP3CCG8lYg0xBBeSUIFDjYFDuISwYUH9rrrrnP2IHbxnuPdpF7ifZ9++mkn6ggxoF5EJQISsUyfYHNBQpV+QDhzHO1EmFM+IhjxzIN+CKKUcpNtSU6lR/8lf8Z7hD/ZMghPof+oB48s/cmdA+rmNX1On2YiIEP8PGA7fR0EKII43Yi3sFQ9nGPuRnAXArHLOU3Nc0r/Uxd9GrKb8KBfwnu83Ihx+inUyXXBIIhntiO2w6CA/uY92+ljxHk4ljJpB973cB0XZMOO7RW0caP3ckcZZ2GOmUU1nsjKsDz2K+zrPZFSTsUKu1Wu/J7cOgwjKgRnUNxStMXdrrgtV57I+S21lHrfMCGDAiIHcYZnllAFbqUHAUyqOkQlnzNREeGCcApeY8Q0YoUHE92Ie73//vtzQy54zJ8/33moEZcIHuKJCTtA7BCOMWrUKPXr1895MJlw9u9//9uVh9ANoin5YqHdtCF4w2lDap5kBCbtRziHNG1BKD/66KMuTAChTVwvYQ+0h3ADLkzsIE4XIUsdeEGZXEkdyd5a2kh5lEMIC55avOIIOd4jXLGVWPN7773XlU0oQ5ioCAhIvNSUkZp3mr7Gm8vggH4htjkIzJEjR7rwDMpGqNKOEKqBqA1ZTYDtIRtL2Aexzx2J0N/0IXcPCJVgn+S7ApSd3L/0ASI63EGgPOylD1955ZXcGOrUc0L/c7eC/ub8QIiRpj8ogwwgXC+cL44P3n36h/aSnYZJlGznmmEbdwKw46677nL1cWeEGHbOLYONBx980N0FICY8TJpMx+uv9dEXn/dUzerS/CVSdsQc3GVKS43qSf17Sk0aSDt3SbPmSxOnSRu3HLw9nP5qlaWjOkpd2zFQlSZOl6bPkbbv9OI4mfYtpdOGSGULcUFs3Cw9+5a0er1/36nTIp1z3ocqUyZ+i2gY8SZZpMVFoMXZrpDPuaDfgSiSnZMZLdxxjgJZiRjeQ8aLi/AMgg5PIkIXoYSwQvAhsBFDfE6sK2IGEYgARWyF1HOIIryzeGkJu0A8URaT4JjshqBGSHE8xxJSgqeVshBCbOOCQECGuFi8ptRLHQj7MAmR4xCuCK/wnrJD+4IHmOOwCWEewgvYjxhkyqL92I93lIlsQehiB9vDwia0FRFKXyBOEYIhQwrCl89DTHnw8tJ+2kO72S+EQtC3bA8LkiDCEYQMKBjUpOZ65nj6k36i7SEtH+0nbIU7A2GwwHvCeegTbArZUvCEh3SInPMQy852ysVejqefKJvzxr70L20M5y5Mggzp+rCbttEmyuSc0A+cAx58cSGUk88J+4TBVTiO/uA1ttC+MEDA801oR/BM017OC20J3nY+pyy2cyxQJrbQd2F/9mVbssjnL/q+Z6Qbfuvf16sl/f4HUrcO0s9ukz6coMhQvar0i+ukC06S6tSUypX19m3fIS1eId12v/TEq5l7rummU4+XfvNdqWlDqWplf+ymrdLsBdJP/yp9Omn/+u/9nXTm8Dyvdn4QZn/7KOm3/5Z27UZUL9SVV7+lsuUyC10y4gXX1Udju+i5Zwa694/9VTr/JBV7wgJYEBw8cSCkjOU5OMbiaFfUYpDjZlcsRXVRwkklGwYxysQA0114EonJRpBG4SR/EyBoEdwh53JcvpijQKqo7tdDeu1eqUol6Y5HpR//WZGAP60fXC799ntShZw5quHbKvzZLVslXfgj6dPJhZdHGYjjP/9Yalg3qbyk0A484D/4o/TheGnvPqlCOelPP5a+c2H+otqFhmT5ssZOlM68Xtq8zUR1ScdEdfHCRHW0SERUVMfrXsERgBMZwhLw8OIZxrNZ0Ip9hnKXWTeKF1EaQvfs5EU1YnjTFu+RHvO5VLmSdPYI6YQBUuP6XvRe8ENp1bqCy+vcRvrDD7ygRjC//bH02gdSpYrSGUOlvj2kDq38PufcKC1bLe3cLf3+bunVD/DaHVhm+bLSTd+Sju4m7dkrPfaStMVnoDQMwzBKGCaqMxDVCGgT0UZc4KZBqZwB/77szIQ2DgJ3tzThBWmmcAzHEsqYlKmw8DZmSVefIzWo62Om//mwD/UIdSOGn/i7NKSv1LuLdFwv6bnRBbd/8NFSw3o+Zvqh530ozDYfAq9HXpCe/IcvD2HdprkX1bBuo/TuuPTl9uostWrq+3D6XN+uKA1cDCMu+YEPhih4PI1oYqLaMEoQCMYH/uC9tnhWx0+V7n9GmjEvvejFO0v4yHXnS21bSFu3SZ9P8V5jYpwnzZTWb8rbv2NrqVwZL0gvPlU6dYhUrYr05QzpJ3+RtmzLrJ3ly0md2nhxvWKtnwCYLOap88HnpEFH5+37/Nv5C1rCOE4c5Cc94vV+4Jk8QQ0bNktPviYN7MMEVql3V2nM+ILbSHz3lWdJtar7tj38vLRmQ2b2GUZxJoTrxU18hjSxcbUrbmGWpSN4vkxUG0YJYmhf76kO31GEWCB8//mQ9J8n9xfWlSr4eOZLTpfLHFK6lBetx/aQLjjZx2h/8qV0za+k1eu8J/i+3/v9EK6IcIQndXVoKX01X/rXKO8dL4y6tXxoB/XNmJvnNU4GzzD11K4hde/g683Pi86c0ga1/WsGE8kDgcDSlf4ZIU8/3f5wwW0lK8gZw7x9cxZKLxQg6g0jSsRNnAXilvUjnV1xsi8rgnaZqDaMEhTuged5715p7QapVGmpTg2pWUPptzf6z+952n9evYr0y29L11/sU8mRdm7lev+6ZjUveAEPMeIbCK1o3siLTDJrIDC3bvde4EXLpJffyzwEpHUz3zZYsoJUkgfug5BfvsqL6haNyQudvyecNHyTv5LatZQqV5S6tJMWLtt/H9LrIcxDP2XxOp/28vkVZ3rxT9+MelFatTYz2wyjuJO86m2cKAl2Rc2zm2meaoiCXSaqDSPmEPIQxCIC97b7/MQ7vLeXny5ddY4P0fjJ1dKbY6W5i6XjekvXnOdFNGKRmOY3xkoVy0tXnOUFJSI22eud7KVFPI+dIP3xv168Iq4RwZlCKrucjIVuAmK6XNQ7dvo81UBbChLVu/dIb3zo800z8fEX10obN0lfzvQ2EuJCho/wW0vKvgMSVifRuql09ki//7wl0v/ejF7+b8PIj7AwWNw8u2HhLrMrWuerdITSH5qoNoyYg+eZsAiy0r3ynvS3B/M++8U/fEzytef7fNbD+/v8zyP6e48uoRJ/vFe658k80UzaOSYH9unqyw4hEsm/vSwyQ1hIqjf4UCgqrUrmEOLBGTDQ9hfv9raULS11aO0HDAHEcn718v1+6el+EiX9+vjLPrVfKtnZpbRrd1llJ+IjSoyDIUt790ZHDCQT10mKwfMZN/uS7YrTICgRQbtMVBtGzMGDGn5C8FQng2hmgh7eZ8Q12S9eelcaeqwXyes2SK++t78XGiGJ5xnYHj4LopT3TPJbtPzQ24zHmbaVy4mFJnwl1ROMZxqPdgjv4FEQS1ZKl/9cuvdWacgxPsTlmG55nwdbsNut1JhP6AchLiziQZsWrZCeei39vosW1dN9/z3JlikvwWzeXOmbboJhGF8jJqoNI4bgfUWQEvZQGGvWewFLWAQ5mwkXCRMMN2/1S3dnAqsIAp5rwioOxxk0d5FPZYe3nKXJEdDJ2ToAz3qI7SZmO5N24lG+/jfSSYP8JMO2zf0ggcmQCPkQ0jF+Svr289mFp0hNG3gh/fTr0sJ8Bg87dlTQooUNDsV8I2aQfSZmYbyGYaTBRLVhxJDzTkxoziKfbSNvvcD0P+xMCmQRE0Qkcc/EE2/YJLVsItWq4SfjIXCTCRMfkwlhIJQTBPahsnq9F8BMouzUWmpUT86eZEjfh7eZ+ibN8hMGCwNvPLb992mfmxpRTruZ8PjPX/jYczzeM+elP75xPemiU3w/0r7HXs6/XiZw1q9T+PLmeXCbM+ds5f0XA+JrV+4toALs4vxffoZ0ymBFBstTbRiHholqw4gZ/Ijjcf7RldJrY3KW0c75DBGJ15dJfkD4xOVn+kmBCGEmKhIiwnP3jl5UX3a69Jt/53m9EbJsD3UdCYm0K0fY9j3KC1OWF//HQ3kp82pU8zmiiW+mXXiag2cZ7zZ5phHIE6f7tHvAhMSrzpZOHyLd+z+f13r2wrwsJoS+YA+5phevTN+v557gJylSF4vN4FHPD1IP3ndr3hLrhUGZ2Qk/MimVxZK8igUl3S6216iafkXO4kpc81SbXdGiVASvwwj9mRuGcTAgIhGWCM/SOX/pJw2U/vtb72EtV066+mzpxIH+M2KgydiB55YVBK8513upv3uJT6P3wjterF97nhehgFAIZRclxE+zuMvJg7yo/vFVfrGZ9z/zovm8E70Ihi+mSx9NzLvN/rNrpO9f7r3peKN//ncfOlK/ti+H0I3WzaUWTaTJs7xIZuIh7wnpeOZNad7iA9vUoI7P2c33PML70ZcKXl2SEBrazCAmE/ygIO9WQoR+RwrE7IoecUs5V5LsipIAjeP5MlFtGDGFsISwPHh2jvjDa8rCLeee6N+HVHuLl/tlu0PaOzy8v/uP9Nvveq/01edKV5ydd0z43g51QI7Tzr8ugsn1E6ZKdz4m/fp6L+oRyt+71HvGw3ftyjU+g8nKtXnhHXi3Q+7snp39QABRjRBmsICAJqzkjz/04h1bEOA0mRUm73gkfUgHkzdZkRKYvIl3vCAIMxk3yYvrTAlZCeL0wxhHu7i+CD8qXy5edsX1fJUku6KUKSOO58tEtWHEELzNL7+f0KLlWW71wFfelwb08lk7Wjb1kxGB0AkmFf72TundT/PEMCL0gWelPXukH14htWnujwnx0sQ3160p/e8Naf3GPI8xnm485J9PPnwbELyEaZC67rwT/KqOlE0bmJRIHPRt9/tVHQM7dkmjP5a6tvc+X9LoMdkSaPcf7/GLxRzXy4exMECgHvYhFORnf5WWr0nfHkT01Nl+EijtYnJnQXw2RTr5uoO1Ojo/HiXZrnJlpB9cIf3oimxVqpBQmSjFdhxkfuAoCZrCMLuiRXYEr8OsRNwSNhqGobUbEhpyOXHJ/ouoXm2fLYP44hMGSE0aeg/zgqXS62P8RMT8sl3g1R3JMfW9yP5qgfTB534FxfmLpc1JC66wsiHHkKe6qEBIkwFkQG9fPuJ42mwvWhH0qan2qlX2KybyHUwe6tRJlnjr8TIemxOvTZ98NlmaMssPOvL7QsSu9i2krTv8JMVMV4c04km1Kgm9ce9eHdXRi+oo3qpOB5JgD3/oLrwrXnbt3bvXPcfVLsQndkVFgMbRLhPVhhFDNm6WBl0izZgnVamyXT16zFOZMjkxDTnhDuAEaSbD6kM5pqhJCtNIDjU55OKYZJm1f65twygIFvKZNbOpVq2qpaqVE3rvkb3q1Dp+Ii3uohqRFqVV+uIoPuNqV7zuWRmGcQDVq2/TiSd/rgoVDzPPnWGUcPbtK6WtWys6UW0YhpGKiWrDiDt4ZEslVKqUuWMN43DIzmYSWPz/jixPtWEcGiaqDcMwDOMQ4JY0UQRRuC0d9/zAmdoVp+wYqXbFJVQnQNgHkxWjZJeJasMwDMM4BPixj9DvfcZEScQcDCXBrrgMGLJy7Aix71GxK55XmGEYhmEcYfAOxjGBltkV3fMVl+sxkWNT1OwqdaQ7I7+HYRiGYUSZ7Ox92pdupaCIwy33ONsVNw1idsU4/COI5q1bt2rDhg3asWPHfqvi1K9fXzVq1Cjqag3DMAzja8WnY/S/eVG5PZ0JyQ6wONoVN+J+vhIRsqvIRTWjwHnz5mnMmDGaNWuWE9eMoqBcuXK68MILddxxxxV1tYZhGIZhFAFxFJ4lyT4jRqJ6586devnll3Xfffdp7dq1Kl++fG7S7ooVK2rAgAEqqRT2h5zJSCy1jCM5esuvrkP9QjoU+w61rKLo68Pth8Op42CPNwzDMAwjZqKaFXCmT5/uvNMnnHCCWrRokTt7E091u3btVJKZM2eOJk2apLJly7pH48aN1bFjRzf4yATCaRYtWuT6tFmzZqpQocIRaytCL5zLLl267LcCFXckli9frq+++kpbtmxxtjRs2FCtW7fW9u3btXHjRrVs2dK9ppxatWpltIIV1w/2zZw5U23btnVlsKrXihUrNGXKFFdH+/btValSpYwGeLNnz3Z9RD+vXLnS9TOvD0awMjhcuHChawt2JB+7bds21wfLli1z/US7aDd1cL1nCn20efNm7dq1S9WqVcv4vCaHVhmG8fWSlfO3F7e/P8tTHc3zFdfrMCtCdhW5qMYrHYTPpZde6kI9ksXUwQiNOPLZZ5/pscceU9++fZ3grFq1qhOkHTp0yEh0ImAJrcHrX7t27YzF+KGAcH733Xe1e/duJ/xpXxBxCN933nlHixcvdqKXz1avXq3KlSu741atWqWaNWtqxowZ7j13KGhzQfCHg6gcP368HnnkEQ0ZMkSXXXaZE5kffvihHn30UR1//PFq0KBBoWXRTvrqrbfeUr169XTKKadozZo1qlKliho1anRQ3nZsfeGFF3TeeeepevXquTlBOX8TJkxwbaOPOI+IYQYGiG/eZwp9hDinjd26dVPTpk0Pqo1R++IxjDiQFfOUenH7TomrXdgTlWW8D8WuKHFERDUTEZmkiCDD+4bQoHMQXng88bCWVPBm4q2/4YYbNH/+fL3++uuaNm2a2rRp47zQxKMjToMnGk//nj17NHfuXOetxTOKYEVY0sd4UPEOI0bxKlM2YhZPb5MmTZznFG8t3lYGNHhRORYRSJl4b6mLMvCuhph4vNAI9iVLlrjykkFMInxp/9lnn+0GBJRHeziG14hXBCKiFo8xdlM+7e/UqZMTylwbxN3TZsRq+ELgmWsIG2g34hRxzrVF+ZS1adMm1/5169Y5u2g/gzn6kLsB1M1+QdxjI4Kfa5Ht2I2dxPzzOf0PlImXnXroe84BfYJNqbPh8U5jH8eOHDnS2YBNtA0bOF/UEQZPDDRpw+TJk11ZnDPOLcfTH59//rm7Fuh7BqOIf9q/dOlSJ9R5j7ecPmQfymU75zn5jpBhGF8Plqc6WkRNoJX0PNWlImhXkYtqRALijlv1U6dO1ZNPPulEDx2CwLv55ptLtKgGPLv0BQ88rrxHYCF+P/jgAycM6ce6devqtNNOcyLtueeecwIKgtBFfL/44otu8ici8cEHH3Te1O7du+t///ufTjrpJOfBxJOKsEXI4XXFA4zge++995wIRGS2atVKQ4cOdYINobh+/Xon9BCFPXv23K/91Iuow5vauXPn3FAM2kTb3377bU2cONHVgyebMrkmEKsISq4FBleIX+y6+uqrXV0BRDTCnzZgF3bTP3Xq1HH9FQYQXGMIS94jPPGGM8igD+k//iCpH9GO+H7//fddnyKY6RMELK8RpSGsg2sWIUu5zZs31znnnJPWY0ybaBt9wR0ZBD31IZrxjHPOaAftCYIcAY+w5k4FApg7DRxPXxxzzDHuNfsj/GkTgxTspD3URz8PGjTI2fvqq6+680YbuX54Ngzja8ZlJojOD36mxDWsLK52Jd+tjMtdy0RSfuoo2VXkohqxgCDo06dPbieEjkAs4MEsydAneDhHjx7tBC5iF08vgvPTTz91Yvfoo492AgvvLH2JGEOUXXHFFU4E33vvva5PQ9wtAheBiuhERCI8w0AGIUkZCGbqfemll5xgRTwi0s4991wn3ghvINYbzzB1EXaBeFuwYMEBFzIiGdGKkETQJa98xOsgghGweFx5j/DnGdH9xRdfOEGJfbQlhFQkQ9s4noEGwhIbAvQVwp198HozyEDEYz82UN6ZZ57pvM7YDAhQxC0PyqO/EP30NXVjR/Cik/aRfRgA8Hm6fK3Yz3mhr/FCh1tvPNgfcUzfd+3a1dlBfxP6g3jnWOw544wz3KCF844IZ4BCecOGDXPXBOKbzxHdtO+jjz5yfz/cbeC6oWxEP9vMS20YXz/7srNFcqu4/f3xfclvFd87cbQr/FbFhZB7O252Zbu/r+xI2VXkfzEIncsvv1ynn356rpChQ0LcbUn2qIV8iwhn4qIJUSAkAm8pYhkhhpjGA8t+3O6nDxGReIURZ/QvIQAcgwDD64/wIhSjd+/eTiwiuBCriC28qXhB2Q/x9/TTTzsPMN5PPNCEDeBZBby51I/HmXAKzh31pl7MnEtEJPUUFPfLPoh7nmk3gwA8tXjXaSfCdcSIEc5LnVoH+yIy8ShjA+IxhJEwCKD91M17xHqIL0fo0m/0a+jD1LLpd9pEW0LdlEEfItaDFxqRzSAjXfw2x+NRRyCnim62cY45lkEBfUpbaCP9Qf/Rv7Qt3JVgEEJ52EBfsQ8DAtoUMujgBee8AueMc0f7o/SFYxhxwn8HJWIXzxrF/MCZYHmqozkISkToOjwinuognPEUImAQEogzxCDCoqQSYoQIz/jJT37iJqa9+eab+vjjj9WjRw/nIcULScgHwgqxFmJ0EdaIPYQuE/CIOUbs0deEayAm6d8vv/zSeavPOussJ44Rp4QyIEg5jvPD+UCosQ1Rx3YI26knHIOwTA7NAM4hAh0PMUIcjzXHsC/tS77Fhr3hDyOEdSAOsTm0OV2mC0Qlwhgbglec+iiTNuKV5m7I8OHDXbnUSxsIueA1IpXyaVMqIS4bu5MXK8Jzjs3XXXedi+cm3p0y0w0cqJN+oD0MahC52MHxIc6bc8OdALzfQJ3YwjF8zrkIkz/5LEyA5DX70E94yi+44ALn4Q7CGw86x4dJv1H5sjEMIxrEPY9z3O0zYiSqEQSENTz88MPOI4lHESHArWpiZ0mzV9JXVKQ/EIu9evVyscDE9iK0EWGECSCMQ6w1gxEeCD5u/yOsEM2I05AqDo8mnmjCHhDAeEcRfAgx+h3RhwcWzynij3oQd3jGCUNBUCLg8J5yHJ5ytiP4OJd4jJOhXLKBEHaCoA+TKRkEBO96crgP3lbCMghpCJMCn3jiidxrIZ0oZBvHcscDmxHVTI5EeNJG+oS+I/sG9SAww4Q9+oNJstiLx5h6k8vFTuzibgH7MECg7ygDQc5ghwce/WBLKrSDvuccfvLJJ068Uw6imn5D9NOniPOwjTrou/zKo28oB9GM8CcWnImc48aNc3XRxwebFQR27CivaVNbqFw5H5MfVbjDXq6sX8Vu127/fDhw2YXy9uzNvzz2q1Cec1RweUx52LWHX2z/vk6dTWrUeJ073jAMw4g/R2TxFwQZHlhECh5YxABCkMlzCLpjjz1WJRVEZxBZeKPpH0QjYg+vJJ5jvLhhEhoiEVGLOCRuGAFJ2AYTCxHeiE08tghVhDap+thOPYhS4nMRvmSWYPvgwYOdIEakISCJb0bk9+vXzwl72oKXGqGPAEeQIkKTM3MgAMPkxbFjx7owDtrFvpQdUioiEnlmQED9iEz2QRgiprGXNiaLavoFjz3XDCKUkBegrQwcEJuI6pNPPtnFLBMeAniDKZeUewwgEOAcy6CC7fQ1fRnaxDmg7VynbOc4+pnrlP7HHvqStoSwleQwFZ4RzmT9ILUgxyB2KZ8Jk5RJGj/axx0b2t2/f3/XJvqAvsVWhDjime1sQ4TTX/QP1wYDKwYkCG3sZjt1pMuZnR/r11XV1M+Hqm0L6ZX3pN0Iv4iAeQ3rSv16SKcMlpo2lHbulqbNlt74UJo4Xdpy4M2IAqlUQerRSRrRX+rVhXhEaexE6b1x0rQ5B/bPqcdLP7hCKl2IqN60Wbr5DmnyV/59ly4LdflVo1W27IEx+UZ8iOOdIstTHU3idi1m5UxQjBJZiSJuMWEKN910kxMC1157rRMrhC8wuQ5h9fOf/9zFx8bt5GcCXY1oJaQAgQlhUl+IPeY1AhIQVAhh+goRGEIHwsQ6hBpl4t1EGAdPK/sFTzfiHKFOPWFyI/uxPZQJYTuwPcTCsx9lh3YEO4B9QlaREGNMm3hPfRwTJicCxxPCgQAlzpg7FwwEkq8Fyg7ZMigrTABiO3WxL/WE9yE8I4Su8HmwN4RWhL6hb0NaPuwObaefQggKx4bwixAqw2vaFNqT3A+hH8M5o3zKok7aEOoIYStsZ1toU0itx3vKDm0P4R0h3pq6QtkhBpx2c1y6v6WNm6VBl0gz5klNGkhP/E1q30q65Q7pnqcUGVo1lf77O2lQnwM/Q1w/8Iz0i39IO3dlVl6VStLPr5VuvNR7n5PZtEX69b+kB54jLt5vq1dbeuof0nG9vMAvCG5qvDFWuvRn0patDPQW6sqr31LZciaq48LevaX01BPHa8L49qpaOaEPRu1TpzZ5k7TjAN81YZ5I3OyK40TFZLuSJ8xHnURE7SpyT3UQO3gg8bzhbeQCDpPhQsxtFDqnqEnO2BEIKysGEEpBcCeTblsgOeYZIZs8sY6+T5dxJeRtTkdI91eQHYBITLf4TBD8kBz7SzgFHnBCgshGgsc19ToI4jNdnakTBvPLJJPf9mSbktuVTH4LtqTbHoQ3/ZiuL/OrI7l99FXyDPvUtoeBVbqyM6VyRallE6lWdTlvdVRA9P76+jxBvX2HtG6jVKa0VKeWVKGcdNXZ0pSvpEde9KK2IGrXkG6+Qbr6HB/2gW6gPMZtNatL1atKf/yRVK2KdOdj0o6d0pr10mMve295uvAPLl/K5Rheb9ueJ8iN+FPKzYtQ7IhbNpOA5amOFqUimFf8iExUJPSAWFdiqrmdTswu8asIykxvWRvxgwEWYRtk/EDglvTVNb8JonQnjXCPM4b51zPnSb++XfpiphfThGT86nqpamXpl9+WPpvsvfIF0auTdPGpXlCvXifddr/0zjipfFnp9KHS9y715V1zrvTC29KcRb6/Hn5BevHd9OEf1atIo26T+nSVtu2Q7n8mc6+5EQMi9PdklAxKqtMytqIaLyMLVDDhjtjWN954w51gYkfJHUx2C6Nkkp/X3Pj6wCneuL4Xg9kJaf0m740tSGzjGW5Qx3tj9+Z4dzds9p5ZvMPJxwbhuS/bC9T6dbyI3bxVWr7K15kJlHP+Sd7LziTCW/8jvfx+3uf/flxq19J7nbGnb/eCRTXlDT/OtwkP9W0PeG90aPvkWVLDetKVZ/nnDq28qAZsXL8xfbnEenP7n3Le/1T6fEpm9hnxIDt7n7ue4ubZTQ7/iBOp4QRxIc52ZZf0PNV4H5n0RiwogprME3glmZR26qmnlug81YbxTXP8MdLwflKLxl5czpgr3feM9PxoL5RTaVRPuuIs6YozpSb1pe27vNd41At+0uDL70lfzvRlVaoonTlMqlhemrvYe34H9pEqV5Cmz5XO/6E0f0lm7axcSWrW0L9esFQaN2n/zxHaz7wpXXKaVL6c1LGNVCorf9FesYI0+GgfwoGdr32w/2CA4179IKe8stKA3tIrSSI+HcGrzcTH7Tul+5/13mqj5JAd8zzVcRafcSLudiUi5H0vU1SjWiYohgUqiJsmGwPZGnjNduJC8VLyPm6rNBlGVOjYKu912TJSz87SHe294PzerdJGn7LceaGbN5Ie/rN0THfv6WVbtTLSMd2k3l28iD17pHTCNdKSFdKJA6X7fu+PR2QjdkNZ7VtKZw6Xbn/Ef1YYiHk8xvDVAmnthgP3Wbzce9rZt1t774XPL7MJbQhe9OTXqSnx+E3ic8I5KI9t+YGXmgmM8MmX0tgJhdtlGFEgahkXDpa42hcl8RlXikTdkrHg1VdfdcKZ1ftYgIP8uukme+GtZuU/wzC+HhCKyQ4MBOqkmfw9Sj07eY/rOSf4MIdv/8ZP0CNjyP2/98IRCBFhQiAeXwQsWTT47kY4B4GKSCdUhO28xpuMVxvv9LzF0n+fykxQQ+tmUs2c+bcr1jDB+cB9CEMhpMQJ8Lo+VCQ/UY0n+d1xUue2vu0jj/Pe9DC5EQHNtmALfVBQvCxeebzU1EkM9YPPHnxqP8MwDCNeFImoJtsHC5MwEY2cxrxGWKeOoAgDIW+wiWrD+PrAbxGcF7MXStf80otqhDahIH+9yYeDnDBQ6t5B+nSS3973KH/Mp5Oln97m444RzXikb/8/n24ueHZTQQT/8xHpX6O89xvxmqmgBuoJMKkwnb5FQCOWkxdyyQ/qfv8z6cqzfWz4T6/xz4SvMPHxvJOkS0/Ps8Ut4lIAvTtLQ/r61xOnSe98krlthlHciWJ+4IMhrt7cuNmVFcHrsExRTU5EKBP6QZq0o446KncZ5uScvmHVO8Mwvj6YNMgKhHiO3/7Ei+QAk//IBX3rD3xsMEIRj/SQY314BxMM//Rfn10j95j3pOsu8Gno8OgyeRH4Uw+vJ0yX/nq/tGnrobWZbw2EOOURX52O4H3HLihsEiQLvDzygp/cWKem9IvrpB9ekbNiYjkpq1ReWdie33c5+zKhkdhxYqgffN7nuE4loSztyy6lUpwAIxZkZ5dSIpEnXEq5dQOikT/3YAg5geNqV9yIo01RvQ6LZPEXYqpZ4IXYaYQzy2wTO81Kdghtqti8ebPbhzjr1AU/DMMoWpIXfyH/MunpCFmYOtt7opOpX1s6ebDP10xsNLHBpxzvPbmIZtLLJU/AQ8zirSbsAtHNBD/yM3doKQ3okxcH/eH4Q28/4Sd4ywnLmDU/fbwy4vakQVLtmj4U5NX3C18tknCV4f2lhnVylHs+ELJCuEg6EPmnDfFhJOTOZpCRLvSjZs0tat9hiUqVipanxcif7ESW5s1ppDVrarjFXz58zIcUQVx+01IlgdlVvEkn4eJwzhIRteuIrKh48803Oy/1t7/9bbcEM5lAXn/9dT333HNuNcXTTjstEp1jGFFl7YaEhl0pTZ9jf2eGcSSoUS2h0Q9IR3X07+Pym2aiOlpEVXzG1a4iS8OBt5qV8lasWKE5c+Y4UU06PTJ9sMzy5MmT3WPIkCE2Q9UwjjBM8vvp1dn63q2ltG17llhnh68jwilCiEOACYtlSvm4ZTy9hF0Q04yXmGP27DswCwYe35DCjvhpjmWSH3HNvGZVwcONeggTHymP+kNoSYC6qDNdfXz3uhCSlO9lvPFuEmWa/UmlxzPf5cRUp3M3lMk5HvakaVMyePRpY+Y/A4nc2HF/TPH/ASmpdvE386MrpDbNs7Vvn1/2Ok4kL+cdJ+JuV5xTIGZFxK4iE9WEd/z+97/Xxx9/rCVLlrgOmD9/vltFkU5hiWpeEw4Slc4xjKiCoCObBbmkEXZMLEQIfzVfuuVOaclKL23aNJd+8z0/UZEQjh/92cdUEy7y46u8iPxihvS7u6Q1G/wxXdpJf/iBD7tYuUa6/rc+Q8fQY6Xf3ugnBf75Ph+OcThccLJ03fneFsI//nyvj9Hm66Ntc7+kOFk/tm6Xbvqrbyc0qitdeoZv+1Ov+8wjUKWy9KtvS8ceJb30nnT3kz7WHGFODPnPrvYhMoSb/OhPB+btpryfXyudPMiL6b89KL30bv7tZ0Ea2hhSCxYG35N+0Y0sleFHPyZfk3l20Yc5I7WIU6G81Lop9rA4RbR+9OMqZjKhJNgVJxIuD3x2pOKqi0xUYzihH2vWrHGeaVi3bp1Lo0dnkG6PlRYJBzEM48iDWMSbTGx0r85eCPTo5HNMv/KB98yeNtQvsoJXlol8xFTD/KU+FpuVBXt09rmqmeTIZEbiiVnFkO84xHmFCv6YWjV8PQhOJgIeLsRk4w0kZpWsJP16Sp9+KVWqJA071g8E4PFXfFYTIM6ZbCZnj/DtO7aHdPlNPua6CovTDJdaNpG6d5QG9ZGmzZFaNZEGHe3bjKf+gWd9THoq7Vr4NHrYjlCfOL3g9rNqJaEBTGjMBD8xk+mNOXcJovEbUijcLdi7N9iVWR5dd6ehmNuPmMauOBK1jAsHS1zti1ue6kQEz1ORiWoWdvn+97+v008/XY8++qi7vXLSSSepcePGbvTEMuWNGjVSw4Y5y6QZhnFEYZIhYQyEOhCqEEI2WN77JzmLwPCdheh571Pp+t/kLf7CCojX3iz955Y8UcsjHBOe8fSG0BDqYRsPXh8ui5Z7r/o9v/WCF88vj2QRSmpAvOh4q4HfE0JfgsOG1yEEhFzbrB75y2978c0kRx7BFpyprNL4xKvpU/gh6kkjyKDh0Zek5asLbj95sG+7f//0gAXCucj2HupYOZwSWUl2Ff6DT3jNqUOkTq2Lv7A2DMM4IhMVKYYJiXipp02b5rJ/IKLxUAOx1QhtxDdhIHEaTRlGcWP7joR+ebt0z5NSuXJZLoxiZH8fwjFygF/whb/89Rulp9+Q7n7Ci8Bk+BNl9cQbLpZOHOQXOsne5xePeWOsDx2hfEIgEO01qkq/vsGL95v/5Vc7PFwo66wR0sWnei87Ihnxi6D95AvpP09K46fu750n3zbCmfbf9bj01Gt5sc/Y/e0LvLedwQKL2RAT/tVC7xm/Y5S0OMdbn0qDOtKffuzF/C13SEtXHb59RnpYYOihP/nn4gp3Z/fmjCj5fYvLrXd+y7GLZ7MrWucLjRWX0JZERO0q8uwffNEQAjJ27FhNnDhRq1evdmI75LO+5JJLNHDgwEh0jmFEFQQtKfWID8YFSugHApU/RfJS163lPbir1/pQj4JS0RHyEY5BnC5bJS1d6eOP8RAnT2JkG3/axGcXJbSB+HA8xQh4wlRYFCZ10qVyQicQ+EDKv1TbaB+hLYS91KrubcArTohIWGExHRyHKKcPWUUxejcmiz/+18j/Njzxd+ncE1TsY8WD+IzLb1qyXUHMxIGSYleU4o/jaFeRhX8E8FS/++67evDBB91S5du3b3cdgtjGS3388ccXdZWGYaTAXfZwp712nc067fRxKl/uQOVMNrCcCIiM6VQMejspCqRI6FXE5RkHD3p6yuRWGvdJZ/c+47CZb5C4CLNU+M2OW3wumF3RonQEr8MiF9WEfZABZMGCBW7ZckYaXbp00datW1WjRg0XEmIYxtdHhQq71a79UlWsuNu63SjWXuqVK2spSkTpx/5giattcbcrbvZlRcyeIhfViGjS5zFBkRUVia8ePHiw81jjuQ6hIIZhGIYRZUKqwLjmPTa7oplSL2pCNE4pEIv83hWGE19WrVo1txw5kxLJV43neu7cuVq7dm1RV2kYhmEYXzv84IdHnEDMBEETJ+JuV9xI5OSpjtL5KnJPNSOK+vXra8uWLS59HiEg77zzjuuYWrVq5WYDMQzDMIyoEkcxHYirXXG3L2rxx3E8T0UuqvFMjxw5Up07d1anTp3c7SPSohBrPXz4cBdfbRiGYRiGYRhxoshFNeCNbt68uVq0aOFiq48++mi3uiJLlLMIjGEYhmEYxRO8nVH0EmZKnLy5RkxjqkNOQSYkvvrqqy7kg2XLiavu2bOni7N+4YUX9OWXXxZVlYZhGIbxjQkzwh2jNIkqU0JO4LjaFTfier5K5fxtRcmuIvNUE+KxcOFCLV26VBMmTHBhH927d9e2bdu0c+dOjRkzRu+//74T2HGL+zEMwzBKHnHNUx13u+KmP6KYzzkTSrSoxkP90EMP6fPPP9f06dNdJ9x5550u3AMP9rJly9wzISBR6qCowERQFt7hOXhQypYtm68XhT9A4tz5nLsIUNh5CRNzSItIPeXKlcv9kuLc8qDOcNvwYDw4YZZvKDscn58NyW0Jq2OFL5VM/whDOw92VbSwfGpYQjVkvAlfbIXZHmwN+yW3IUorRxlGSSeuf6dmV/SIW57qrJwQpKjZVaSe6kWLFumrr75ymT/oAFLpBVFEir0hQ4aoQ4cORVWlkQS5we+77z7t2LHDTRatXbu2hg4d6uLag2hOBkH9yiuvuPAcYt45T5mwefNmt2Img6STTz7Zlc/5nTRpkhtMnX766S7sh3a0adMmo3KDSOX6YXl77nZw/ZA9ZtCgQWlt4BhsJsyoffv2LnafuP26des621P3ze+Pkn6YOXOmW5zomGOOKbS9lMW+EydOdA/uwjCHoE+fPm5i7urVq93KoWTAYdCRDgQ0KSYR0NiIbeRzR2jTZ/ytGIZR/EkdHMcFsyu6ecXj4rFOJKXTi9IdhiIT1Xigr7nmGifknn32WdcJvEY00BEIj9atW6tly5ZFVaWRcqfg008/Vb9+/dyiO5MnT1alSpVcSkNWskxepIAHHl7i29u2batevXrlZmkJF3Dw/qZexAhfQnmWLFmSu8AP+7Gd+gcOHOjqXrNmjROWCETKoP7gRUdEJpdNnYhRYu55zTWCuKWNCNjggQ9f9MGjzGeEGjGIYF+E/VFHHZVbZ3IO2bCIQeiH4KFnP0Rw+Dx4yoMQDx7o5H5YvHix3nzzTbVq1UrNmjVzn9NeBhwMCugXBHrNmjVz5xoke7QR4tzR4RjOFwMB2hC85cl3A5L7i/MT+iCcpzAIiMKXjWHEjbiLz7jdNQvf7XGzKwjQuMX3J5LsigpFJqrLly/vBBVeT8QGQqNjx45OLIROCQLFODIwsMGzi8cUTzHib9WqVc6jOnv2bCfU8IQee+yxTnAH4YhYY2EehB7eXkRh3759cwdAQaByHrn7wHs+Y4XMESNG7OfdXb58ud544w3nbUY8Ug75yceNG+faQjgQQrJdu3buOMpiP7zcK1eu1DnnnKMePXq4a2XDhg2uzE2bNumjjz5yZXL9EJffrVu3/bzNn332masXjy/lUA/CPtw14Q4J4nzq1KmuH/B+0w8MONifOmgnxzNAoE3YjEjHBrzOlEMf0EfYefHFF7v+BPqb/sCLz770NykkEf7UieCm/AEDBjiRjfhmISTu7IT9sBkhTrvpL+xlUET99BfH0P+UTxsYEFEexxiG8c3lqY6LdzAQ58wfcSTu12EiQnYVmagOt7RXrFjhhEadOnWcyHjvvfdcqABhBoR/kKc6v9vixuERPJwIQiaIIloRatwlICSCbYg1hBpiERCJiDsmkSIsEdScN84nIhDRGSCsAwHK3Qc81OyH8EPwBTi3eIo5jnOOYMeDzb4IcUI2CDu58sornSc7eNkRi9SN55cBGnAN0T6OoUze08YPPvjAiebQNgZsDCiwq169ek5k4knHo96oUSPniQ/e6NAPM2bMcMcOHjzYtY3rlroR5wxGEKvYRngJ9tHW4N2gLbTx6aefdmKd8BOuefqZemgbfcTABcFPP9JG/j7YRnm0F9vYj+MY+AD1fPLJJ+5vhv5AvDOgwBvPHQC88bQNeI2tDFLShfgYhmEY6X8rDeNIUGQ+dYTcW2+9pVGjRjlRgvh55plndMcdd+jee+/VXXfdpSeeeMIJC+PIfEngDX3++ef1yCOPODHGAAYRiRDkMzygeE3xSiNkAWHH+cIr3Lt3b5177rlOJCIyeSSPFMnu8v/snQWYHUX2xc/E3d2VuJEgEUISLBAS3BZngV34s66sG+ussiyLu1twSSCQhChxd3d3n//3q0plOi9vJpNkMjPdc89873tvWqrvrWo5dfrWLbaDHPM2AoKIsgtxDoDkMfEPx0bF5n8IM8ryFVdcoZ49ezqyimodQjGwgfMHohlCMqIfCCmdBY5NmEggnQHsgz0cE6We0AsINgQXVRs7gqKMIkwngnqYMmXKIRui4R6EKQ0cONAp2WH76OtQcrBfdtllrnwUds7zjz/+2BFf7EBZ5piQYjo2oQzqGSIMKAOy379/f6c4h7APfKS+KOfqq69Wr169nCo9f/58tx+dBDqnxLNDxrmekjg9rcFgKDjERRU8XiTdP0PBIc/kLRQ5CAPEIajWKJQsP/fccx2hGzlypPr27etImyHvAfmETELmCKHo0KGDU5cJG4DcofSiohKqQLsAiBwhEhBCCDAKLEQcQo2iG7aBuEHGx40b59ZRDqELEEbCF6KDAaMfQi4gzKjWHAOVFzUbGwIZREGGoKJIY1eUyIeQDeK/o+o3y6NIR8Txlw+/OS9RobEXNRhb+J2qWEDssQXCSqeB7UIoSAB2MF4AtZ/zHPUfUt2gQYPDbKD+WE6HgHbBFsrCx9QsJSHEhnoJ7YgNxFtTP6ETRNtQTngTQXkGgyH/kXr9JglJ86eo+JU0/zJi6FeeKdUQJMgZpAnVjYwKKGwQj1tuucURL8gESpy9esl7cNJBdJki/pprrnFqJuQPRRiyigpNGxCKEB3wBoFjO8gcHR/IG/vQRtEsFLQbZBriTaeIUAkUa/Yj1CJaXlCWOQ4kHXLKNpDYQJwhrmHwAetRa1HX586d67aDLLIPH84lCCShGqi7kM3Uc4hzLqTki6anC6n2ULbxgfORciDW6c5D6jEa9x/iqFOzf6A8Uxeo44SAcNww0DD4DvFFyWf9RRdd5Eh3iMPEH+wM+4WYMUh9yGzC9USdcPzQFqmTTdi1ZDAUHMLA76QhDFaPE5nJDcyveKFYDM/DEnldAZABXu+jLBICwuttBiyiFFos9clDIIPRm3yIIYbYolaj+EKcIXlhe0ggoQjE9qJCE2bANoRrhMwtEDcG70G4L774YkcQ2Y/QB7JgEJ8M8aM8CC/EnTjgwYMHu7ALSPiECRMcWaeMEKMc7MQ+bOLD2wzCMkIYCCQYOwg94VgAshoutOAvii42EMMPaUehjyaOZz3nH6oyPkLWiQsP523YNnoBB8U7ekFTF8SVf/TRR4dGkofQGeK5sZV6xk9CTyDSxEtTf4R1AAg1y/GVcB1ipCHhHBuizkBTBjo++eST7npiUCX1SH2HcJWo3UdFJp1eMrDE58YUdxQrRiepoK0wnGzE6WF/LDC/4tteSWm7jBQ/4uJXnpFqSBDqJcoccdWQICoBQh0yGoQBZXGpnDgBJfPSSy91MbcBkDQIM6o1nRrIK7HAqMKo0yi2EGDIINsQvgNBJCaZ8BHUZEB7sT0xxsT6hkwYlE3Gl5AyEaWcsAXUW0gtx+d/SCFEknMA+yCg0QGQ7A/5h7CTIg/yDbAL8okiDnmlTM4lwh8g4JRNGAZ2EPJC/HHI/0xcNOcjx+O8w27WQ1apK45F+ZyPzPzJ9hBvbMM/zmfKpI5CGcFW9mFfCC/LIdIo6ISmEE8diDz1QWw2nQ7sp45pA8qjU0EIC7Hu1E3IeIINHBMbeTPAtqwLafog8pRB+SG/eDqlbN9+af9BgX3z5gp6/93uysyMZ+w1YzCrVJIqVSBTjbRhs7RjJx2F4yuPpixXVqpayZdBebt202E6ctsypaX6tbmWci4Te1at9fUOmjZbqVO7znXHMiQXSU+plzS/wlvBJPsVp0wZOSGaEjdOfmVk5tH7YwgCauijjz7qVGoqAcJ19913O+J2//33u0Fm99xzjyNncaicOCHkQ46ql6Fpo3mXowpsyIMcTZkXTtyoyhs9uVPze0YH8AW1Ot2MgdmVHbU/akPUzpDnOoqwPOpDyGUdvWFGjxPWpyrR0Qs3tU5SZ2k8mp2pvkfTbqUeM3W7aH1Fc1tHfU2t02hdRLFsldTvZmnhMqlxPen6QdKDz0ubtihWZLp3N+mK86U+p0s1qjF2Q1qwVPpopPT8O96/Y0GjutINg6R+Z0qtm0n7DkgTpktDvpBefNcT7IDixaTv3yZ97zbaLedyt26X7v619OFw92JAHTou0E23fKySJQ8/bw3Zg0tg2KedNPiNnu7/l/8hXXZe4a2xMGkVyO1srHFA1K8QQpcEROcMSKJfPA+iA/3jjsyY+pVnSjXqXsjnSwwsJyzqHa+tiQ1lgCKqGoqgIe8RJglJXQayi/lLjR3O7iaT08kcLSOq5qaWdbQbWHSAYTpklzIuevyjxTdmtz7qW2qdHKudOa07lu3S+Ztqe06+RnvKqLzfuEEqUVz6zX8UG/ToIv3vN75TEG2KOjWl0ztJZ3aWbvmxtH7T0cti9yYNpH//XDq3++HKc72a0gW9pLYtpF/8M4tYV68indfT19/R7uWVK0r3fk0aNVHavC2lAQyJhOWpjh9SRY6kII75nJPqV57GVPNanJRpKNEgqKaEBpACLCwzGAz5B25FJUv4kIe4oFZ16b5ve0LNfRVFetpcqVwZ6dR2PnQDcvydW3xHYc/enMuDUD/yO6lXV6lYhlfsp8yWypaR2rXw37ddLpUpJX3vj54Yr9kg3feQtGKNVDzNnbJ4htStg7fxQKb0xURp+86TViUGgyGPkERibUgYqY6qoqkKWm7VO4PBYOBWctMlUtf2vi7eHSZ994/S6nVSseLS6e2lx//gY52/eqX0zqfS6Mk511uPztIZHT2hHj9N+vZ90qwFXrFG8X7gF1LDOl6x/ntdafNcv9+nY6QRX6ZXqhvUkd75n/+9dr309JtZMdUGg6HwIi6qpyF+sGnYDIYiggrlpP5neWV17z5p9kJp/FRpdw4qb+UK0lndPIFFhZ21UJo+x8c7M7iPcgJQkcGuPdIpTaTTOvhlC5Z5chqZIyhHoKoTdkG4yrYd0l8flxZlzfWjYeOkp96QfvJ1r1h3bp0zqS5VUrrwbKl0KW/znx+Vxk7NWv/B5z6emvjp6lW9cj39IKkGUR8DeCYP7Cs1qe8HO776oTRvce78MyQDlqc6fkgqmQ7jeZLmX0YM/Spxsl+rhEpJRZwqyWBIAi4/T7r2Ip9Fg0tyzXrpvc+lvz/pVdsoeLHEIMHv3Cr1OtXvA7lct8EPEmxYV3rpPemFd6Sdu/0AwB/eIZUsLi1Z6QcDNq7vCTKDJm+9V/psbO5CjatUlOrV8r9nzvdEPgps//gLH/pBSEv7UzzJze6NLqEdXdr6bbZs80r1YeVJGvml9O2bPQE/p7v08vs521i7unTTpZ74E9P91Jvpybch2UjqG9gw4Dxpz+k4ZZE4FqQb/J8EFIuhX3lOqskRTF7ekE6PtGecxKQHI381KdKiad8MBkP+oGa1LOLJPap2DenWy6UOp/gBf3MX+/UQRbJtPHpfFrkNyxkkePNlfhkqLeR26Uqp92nS167x23GIcAsk1hhSy6C/jGJSbrL6oaTXquZ/Y9OWrUdus3y1tHaDJ+5tWngyvNtPEnoEUJI3b/W2sR2kHaIfRYXyWYMXmzXwSnx2yjp1N6ifzx6Cr28NlWbMO7pfhuQhqaQ6bkQmtygKfiXFv4wUf+LiV7G8HlXLDHvPPPOMnn32WUekAel5mPzjoYcect8GgyH/AbkcO0X69QPSnx6R5i/xy7u1lx76tVSxvP8f5fe/v/aEGlI8epIfDPiPp3wYRiDm8InU+xz/swhF+PHXpB/+WbrrV9KbQ3OfVxqiDMkFqOnp4pQZaMg6ULOqVD6HQZiErRCXzfFR3OkUMCAxAJKNsk68Ndi6I3vVG9BBuOVyr8Jv3iI98frRB0oakokkZ5Mwv+KbiSYJyIyk8g3/FymlmumWmfiFmeOY7ILXR8yqx/TQ5LAeOnSoU7CZ2CKJr18MhsIO4ppv+IG0bqMnv88Olh77vXR6R6lzG5/C7qMRPu6aQXjcw54ZLP3kb14VhnQyGO+1f0tNGxxZfrjnkTnjjp95Ins8IRFO7T5YVjRvdBQQ7T37/HYQ/5wmZ4FMfzZOunuzJ+B3Xi21aeaJfoWy0pX9pVPbZh07JSX6EaB+Orbyv9//XJo4M2dfDMlFyJ+fXcrPuPsVtymij4Ywv4D5FQ8ciGF75dmdgKmjH3/8cX3xxReHZlNkshfS6XGBMpseKfdsRkWDIX9BzO/Tg6WREzyhDmRv9iLpF/+SrrzAhzGgPJcs6ScyefJ1Hyv94HOeUAPIK/HNj7wiNW/oU86hSIP5S6XHXvW/5y46fkINlqzwAxGxh7LSgWf+e5/5mGsU6527ci5zzGTpnl9L5/bMUqS7tvPfU+f4T8D0edmr6qjTDPiks4F/1FO6sJMNGypqzOjWKlY8nrNYFggyM7R4UW3FBUnOUx0nZfBYkHQFPmnnYWYM/cqzGRWZ3vpXv/qVRo0apQULFrgKYGrlcuXKud9lypRxU0DfcMMNbhrruFSQwRBHLF4hnXOLtDiSNcNgiBOe+6t09YUq1CpadEbFpMRXQwl485xEv2ivoHzmNHlWnP1KN8NuHJEZU7/yTKmGPF9//fXq1auX3nrrLadcn3feeWrcuLGrjIoVK6pJkyaqVevgyCeDwXDSwODA0iWtgg3xxNmnZ71JMBgMhrggT6cp79Kli5uWfPXq1W6QIjMrtm3rgxXpYYS4mDj0NgyGOKNUCZ+to1VTn3qOHM2ktHvyjaxtEKBuvETqc5q0/0BWiAiD9sKy5972sdjR8IeffM3PUMhkLAx43LjFx2PfcbUPy3j8demLExiPjF33XC91aeNDTh56QRo37fD1HOvMTv54hJ2MmpS1jjR7GQcHKEbDODq18lORj5jgM5YEVCov/egOqV5tH/pCHuvU7CAAH5lshvARZk9kICZ1lA7EaH/9Wh9Ok1ugyBw4QCxrhoqnGwUaU3i/fEXlxi/OW2a+JK6/MCOJGReOlgo3KUhqe5lfCZtRMbwqmj17tiPWpNcrWbJk4hraYIgLyOBx/UBPqiGhxEEzQyDE5aKzpd992+dcZvnfn/IkFV7H4D32QS389u/9YDzS0ZHr+hs3+iwahJg8+IIn1c0a+uMQZzxs7ImRavgX8dzBhuaNpB/82cdXQ1LP6yH9+htStcp+CvF/P+v3g6+d3U366V2et/3tCemD4Z741qkh/eeXPl/1W59Iv/intGqdL+O2K6Rv3uSP9eGI9Cn8yC7yw9t9ne3Y5Qc5ZkeoAYTwuot9mcfmu79XJuSN+yGEzk3S/EpKaER2fiXt2Z1Uv6KiZZJQLCYhH1GUOBkNW7NmTU2ZMkWjR492y0qXLn1oqvK6deuqatWqsasogyGWOHiZcblBTolTZXAfinPb5p6kkg6OyU4WLPXbfv6lNHS01L+X1K6lz/YxZ5EniORmZt90l29Ip5cXYGKZQX2lC87yCvHbD0mLlkmlS0stGnlbsJuJa6bNzZr98Sd3+ZzZoHgxn0Jw7UZP9ukUYDsdAzKerFor1agqNarnt2UQJyr1lu1H2sNU5pSLjxOmS5+Mztl+Oico5UfLJJKKzINZTgvj3bFUKV9/xwoEzyj5TNKtP+mkOmkoCn4liVtlxPBt0EmZUXHLli2aO3eu/vGPf2jw4MFuAhgaHXJ92223qV+/fnl9WIPBcOga9Bk0Nm31JHT1ej/NOGohiivTh4ftCHd44Dnp9w9lZbFgcOPXfyn98yfSgD5S5YqH78N2kPGlq6Tdu/1yZlrkeBwjZBg5EZBV5Gf/9CEZTE5Dbmg+AaEj8OgrWcSVZRw7vLWmDFRlsGGT9/EfP/V1wQyQfKL1QCgL4S/pULem/962Xfrfi377nDBqsnT5PceqzBbuh0aLRgf0629mqF6tY7czhBLE5cGYW5hf8UJRaK8khYFkxtCvPCfVxM5t27bNpc4D5KkOk8AwmHHTpk15fUiDwRAB4Rjf/7MPjSDEAYJ8egefGo946VrVfawy5PmhF6VPRx+ZFg4V91v3HcxtPUiqXtXPMMiEMS++62OT+Q4TsAwZJX37Pk8ih3yRN81BmrubfujValTz+nWYsdWnvCNlH9OlowYHQKB/918f641/z72VRaq5Nb89TFq3yXcUzj5NqlrJT/TCFOWURS7r7FLpvfah3x6i/s6wo9sOiSfuOkkY8WWGO08e/JVPK5hb8DBMYj7nqF9Je/WOX/hHe5lfhR9Jba8DBw64T8j+UaRS6gXs2rVLQ4YMcZPApIIGP+uss9z05UlqeIOhMIEJU866XpqzkIf9flWqtEPFipHrUypbms6tV2e378h+au8ALlNmHyxfzhNOFFpCKVh+xJ0jXNJ5Pb4pw2cyQWXff9CGnGZnDLeW7O5srKceyJCye6+0I2VAY07lJnjsVo5x3lu2lNeBA8VcCMzgB4+NVCc19VxS/bKUevFCXFPPJdWvPJcNCPEgvGPr1q3uA8kOI7+plDp1CvmQboMhAQi3ntp1NurW2z5QmTI2j7bh+LB1a1n9778Xa/PmCu68KvyPNYPBYEhQTDXhH+PHj9eECRPcrIohkTxp96655hr16NEjrw9rMBjSoHixA6pYcafKlDVSbTg+ZGZmKKNYEZToDQaDoaBJ9e7du134x3//+1/NmzfvUFo91GoGLPbs2TOvD2kwGAyGQoy4jeDPDZI850JS/Upqu8VpIF/S86XnOamGRI8cOdINUKxUqZI2b96sVq1aaceOHY5UV69ePa8PaTAYDIZCipBONYlIat5j8yteCOmMk4aMGObfLnEyRqFu2LBBjRo1cp+pU6fqoosucvHVTApjMBgMhqKFpJPqpMH8iheSmqe6WAyvrzwn1TQo4R4VK1ZUrVq13MDFRYsWOaWacJC1a9fm9SENBoPBUIhRFPIDJwnmV7wQx3zOST0P85xUI9UzayJZP/iGXL/xxhsuppr/y5Ytm9eHNBgMBkMhRVLzVIMk56lOql9JzuecVL+KxyhPdZ7f4cjw0adPHzVp0kSdOnVyMdaEfvBNGEj79u3z+pAGg8FgiIHilDQVLW6DqHKLpPqVVP+SeH3FtZ1OilJdu3ZtVa1aVS1atFDz5s114YUXOmJdpkwZt9xgMBgMBoPBYEgS8pxUEzv9zDPPOHJ95513qmXLli7rx4cffqg333xTl19+uS6++OK8PmyRBK+yyAm+fft294qE1yPUNSE2x/uqJLyqZTp58ouH8li+ZcsWdyyWMQ19uh4x+7Ifxye2/kR7zRyXtxwcm3SN4W0ImWWI1wd5cQxmbuJD2bmduSnUFbZx3gPOe0KeypUrd0xtEGYxox2pt7jMHmUwGAwGgyGPSTXkYt26dVq1apXmzJnjSMHChQsd8SG+esqUKW4ymN69eyfuFUVBAPK1fv16vffee5o+fbojZBUqVFD//v116qmnOlJ3vCAN4pNPPukGlt5www3q3r27I9OvvPKKRo0apauuukrnnnuuI3+pgIzPnz/fEW/eUpxIDCXnCUR68uTJ+vTTT7VixQq3vF69eq5j1rp16zxLI7Rs2TItXbpUbdu2VbVq1XJ1fkLCFy9e7DqMc+fOdfZWqVLFneNnnHGGa49juX64Xqj7pk2bqkaNGsf8asyuKUNhRlLzAycRccwPfCxIcrslCRkxPA/zjFSj1t13330uRzVEA/AdVE4INwQLspe0hi8IoN6SonDatGluWvj69es7Yk0ecOoXBXvnzp2OrIVsLNQ/YTiQQUg562gPVOeoMsp60iJOmjRJp59+urp27eoI34wZM1w7bty40R2L8vkAOk+QyNWrV+vzzz8/NEgVggog5ZQLCWY7FGGOH+Ltg8IblGKAjRDdt99+Ww0aNFDfvn3deo6BL9iAQhxswA/ON8pjHeFG+E5dcA6yjm2D4k35LGM76vKLL75w2xO2FFRwbGVfOobYy//YxzIy2dCpwbfLLrvMdSSwh+34cCzW8Rt78Q8/Ic7sHwZhBPJNW1LP1BPHxzaOSzlsj534yPpgDx+2OxYCbzDkJ5KcQzfJ+ZyTKH4Fv5KGpPqVcfAai9N5mGekGnIA2UHxC6/CV65ceUip5MHfq1cvFw5iOHFArCBnkCpUTXKCQwj5sAyCOGbMGLcN6wcNGuS2efXVV93bBPaHHKNqn3/++S4OPoATGFIHSYQU0q6oz7Qr6jMnOfuOHj1aX375pSOwp5xyis455xy33ccff+z2p/3PO+88Rwoh2hB1iCUDWTt06OAI87vvvuumsocssj8Ent8A4sjbDYj0mWee6Qa5cmxs4pvyPvroI82cOdNtf9ppp7kZOyGmpHHENwgy22ADCvJnn33mlG/CR1DV2QZVmWVDhw51NjHAlk4KxydciW8Uesg5CjkElvOdCY7Iw37zzTerW7duzmcIPdtTh2PHjnWdTNoABZuBupT7yCOPuP2pNzqj1Aeq+7hx41ydzpo1yx2nTZs27g0Px6AjwCRKbEvdh3Jpb+w/66yzEpdZwZAcxGXk/rHC/IoXrL3ihWIxvG/k2VMYovHNb35TAwcO1HPPPecqgwGKkAh+sx61kY/hxAGBa9iwoSNwjz32mCO1HTt2VOfOnR1hbNy4sdsG0gZRmzhxolOl6fSgsBK+AQGETLJtlFQD2gxCCiC2hJqwP0o461BNOSYDTyHPEFmOQTmQ3zp16jhCDXmHUNesWdOFVixZssSpuxBniCFlXXDBBY6gfvDBB+58adasmSOlkE62p0w+gTRCzPEbvwgJ6dGjh1sOicVGeuwsxz7IK52IoNxD+iHjnJvYzP+EW3BeYh/hM5BZQl/wB78hr9RTly5dDilu1B3kFpvYl7oOnRGWUTYhK/hCfaDyYy+2sg4FH+Ud8g9ppuPDtpRLxwBijz+0F+1KPdEO1Dv53+lI0P7UHeEwcbz5GIoO4phvNjcwv+IFa6/4ITNmb0zyjFSjJqIyQkggaTzkISssh1iFV9dJy6NYUKAeIb233367I1iQs5dfftkRXMJBIKmQOFRgiCPtgToMKURtRqHlZEVpJqQjFaH9+Ebd5Tf7hbcQKKeUy/6QdD60NakUIdRsD6mFmEIuIctBHQ6hExDXAQMGOBUa+4cPH+7Wh7yUYQAhvqaSRpYTsgHBhIRyTqHM439O8ciQXmxD1eZ8xA46HthGWZy/KMKo/ZRPCAxlYxekGx+jgxSxK/XVNsQ41A2dAhR/iDzkG2KOusxxULfplDCAl3qlw0I9cXzqEMV6/Pjxh9oBFZ2wGrbjgz3t2rXLkwGhBsPJguWpjh+SmqeaZwvno/kVr7zixWN0HubpQEUICgQNxY3X3RAlXqlDLCAUqKMQBiPWeQM6KhBl6hsyOWTIEEfE+J/Bc3xDHkeMGOG2D1k5IHkouuGEhaCmA6QTgjps2DBH8iCBKLbsA5FHOYXYsR3hJpDJ1F4lZaMsQ54hhCBkt2AdYUGcDyGGmZteAMtRuCGkEF9+U3bI1MHxILl8Qtwm+4fBDSFmme2Cj2xLvXE8fofY7NQLFhWYziHnL7/pLKAuB3KPDxBx1G8IN76F49PhoEzOeTo4hN2E+mQfjsX1ge9hzEGwL5r7lmWQZlR1bKa9UOwZq8CbH9oxbvFmhqKJJObRtTzV8W2zpMUfR/1KyvUVV7/yjFTzOp6ZE1HWSKUHeX7hhRf02muvuVfvECteZaOsss5wYoBwoUJT7xA16jcQRQgdYQsowJBBlOJAoEHqyZndDSao2xBHSHUYBAkIiWA55UMkUVoDQQ4DIvlAJCGnHINt2R+bsR+CSKYYFOIFCxa4/cOgSQCRRNl9/vnnnWJMRwD/wgBY9gtKfAgXgaxiJ8SWjgZEGIWXslJ9D7+xjboLseKcr5BWwipQ/Inh/upXv+rKCPvgI3UCcUZhD4SZeqFjye9AvFGaQ5uF40btCDcMymebkD4QMo9/tC11h13BztxmUjhwIEM7d5bWgcx43JCSglKlGJRLB6+gLTEYDAZD7Eg1aiCDqohfhcDxap/wA0gKaikqNuSDgVZGqk8c1DGkkUF4KKUAkkWcLgo1CjIKM4PfIHoQQIhgUGnDaGGIalCJAygnZMVAZUUhRoXleGF/iDJxwi+99JIjfUF1htBCliHykENiiBmgSnww4RnYQOgDby0YXIf9pASkfLbDzihxZWAr2xFKwfmE3RBnYonZnv2fffZZtw/kNcSUE3aCco+yDslF8eUYUWLM/9gMUYdAQ6TpCJLxhAGK+MHxIbiUHR0ISBnsw+BDjvPAAw+49ZBrFH2OxwBCQmc++eQTdwz+Z3noHAR1PbQBBJ16IoyHQZvEVdNJffHFF922+EX7BrtzE/axenVVPfvkQFUon6nV6yHwihVwr3oVqXNrqW5Nadcead4SafYCaceu4yuzTGmpVVOpZWOuI2naXGnRcmlvmhc2jepKZ5/OuZhDgZnSpi3SJ6Olzdv8onbtFmnAwDEqXjxmFW4wGAyGwpH9A2UyTMpBGAJqKbG7t9xyiyM377zzjiPZcZLyCysgVKiXZO5AJaY+IYWQP0gapDDkdYaAsQySSBaQkP6OdrjmmmtcGEEUtCEDTtkOEhoG/0HmQihCCCFBSQ0KNf+jHp999tmOjLMc8g3J53/OD0gx2xBLzLkBQWY5x8KfqC3BJ8rDr9B5wD62DeET2AAgpYRhcAyyZxDjH4gwijWEnYGIgOXYhj8QYToGpMWjUxgGY2IXx2egIMdMjeumHliHzRB3roHQEeF4tA0dSNqHusM+yr7xxhtdRwVizbKrr77ahdlQf+QAD+Ek1BNtRmeGTivrKZuyIPTU3dEGKFYqV0Jfu7KqOraSfvRXafIsxQYVyknfuFG6doDUpJ5Utoy0/4AnsDPnS395VHp/eO7L45bT70zpp1/3pBqyfiBTWrVOmjRD+vk/penzDj/+Pd+WrrvY75sTdu2WfvVv6V/PeHJeqyZjA4i397GphmTmqU4q4pgf+Fhg56HhZCFPc3DxgA+vv8m5CzlAUSSEAIIXBnkZThwQK4hYdoPyIJ18UgERiwLVOIqQwSI19SHLIZ58AiCM6d46QPj4RAGZTAXHQY092jkFAc9uenvsTJemERIewi6iiOZzhgxHSTwDK/mEmHFCl7AR5TpVzQ91AtFNrcMAiDOfVJANJACyzifdOhBCP1KRm8lhQLuW0p1XS+XLSV8ZGB9SDfe6fqD0w9ul8mWzSG2J4lKNqlKvrlKdGtKSlYcT4exQqqR0fi/p7/dKjetllccQ0wa1/ad2Dekbv5MmzUQk8Osh3blB6VLSxX2lh19Or3gXZUTzOScJSc5THTpASfMrqfmck55XPCNGfuUZqQ6pxUgP9o9//MPFolIZEA4IEeEfVJBN/mKIAyDDqNp0Qohtji0piNyL4vQs6XCK9MM7PKHevlN6d5g0fLxUsbw06BzpjI5Si8bSfd+Rbr1X2rjl6J2LQKhRu8dOkT4a4dXoC8+W2jSTTusg/fWH0rXfldasl7bt8Or1hyPSh39A1O+6VurcxhPpF971+xiORBInf0m6X0Y+44M4ks+k+pVnpJrX8KjSTNdMHC+VACkhxpXYWl5h8yqbV9oGQ2EG5y5KMDHb0WVJAG4EVyKJVo4K16fIzL1y6/bhOBmezGce4353XOXVY473wLPSbx+U9uz1659/W3r5n9LpHaW+Z0jdO0vvfZ59efjb5zRfHmY8/4703T9Im7f69ZT/4j+kMzvJhck0beBJNVi2Snrx3fTlEudd7+DtbM5CafCQeHVcDIackJR7XirMr3ghI2bnYZ7mqWYgFvGpTG5BTxeVmtzGZHu49tprXa8ju1flBkNhQtwu5NygWQPpzz+U2jb3BHXcFOm5t30IRToyiAjXqZV0y+VS80bS1m3SmCnS4KFSlYrSvMXSlu1Z2zet78n3uo1eTR7QxyvLE2dIv38o9wMLCaXo1MaT4bXrpWffyiLUYMVa6fHXpG4dfJw1KnROpJqBiRed7f3Zsk166IUsQg2Wr5FeeEfq1s7be2pbaczknG0sWcLXC6EoqNRPviGt2ZA7/4oionmPk4Qk+xW3/MC5gfkVL+yP4XmYpzHVxKuSxo3sBxDo8MocFZusHyC2r9ENhpgDklu82EHVWdL5PaVrLpJ+/z/p5fcPJ9YQ0e/fJn31Kh+7TCwz6wf1k756hVS1svTRSOl7f5Q2bJZ6dJEe+IUvf/0mqWt7qWxpT4x7dJYWr5AeeyV3SnfNalK9g6HoU+dIy1cfuQ1Efet2T+47tfbHJawjO5LeoK63hQGFK/241sMwf4lXsambc3tI/3spZyWfzCGXn+fLXLhUevVDU6mzQ8gZD5KUVz2pfqXOF5AkWJ7qeCGzKOepjub8TU09Fv1O/W0wGE4eCKUIlxsxwAhrm7Z6Eooq26a5jzWGML/2oSemFctJ37xJ+tEdnpAeOJhxA2LNgMdWzXx5PU/1McmQapRs4qCjxBwCSzz0khXSqImetOYGlFXt4HhayHg6hZuMHavWelLdrKHvBHCsdNi924dnNG/oY7RbNJGWpRB14rOpE1CujK+37GgF9XDjpVKtGr6+nnlLWrk2l84ZDAaDIbHIU6U6O8JsJNpgKBhAAMOb6W3bvQL75lBPlm+/Urr0XB/C8JtvSiMneFW4R1fpu7f6bRgA+OjL0jvDpArl/T5kuYCgo+qGyz2Qaf7n98SZPuUdOaUh5IuX555UYw/HBsQ2pxPNGBAYBidC7AkDyY5U79ztBzqiQNMp+OFXpdXrpAVLs0Jcvn5tli+Uk5OtjetLV/f3xHvRCh9znVBhz2AwGAwFSaoNBkPhAUrqwbBPvTFEuvdvWQSYmGp+kwe6QR3pnO4+trh/L09UiRX+48PSv57OCq0YO1ka+pQPuaDcQ+Eckb40BPrGH0hzFh2fzdGBjXv25bDNQZvY9Ggvv4aN9bmtGYiInx8/Lo2b6hVusn5UqpBVRk5loWaT6q8+gygP+EGPS1ceud327WW0YH5dFS8Rf7a9Y3tp7dubrJhhQ86wPNUGw/HBSLXBkDBESSlkOPxmIF00PIOwiqfflK64gMmEpHMhmyOl83p6YsmAQ2KFo7HKzGjIYL9QdlBoyx5UlikfAjt38fHbj12h3NrVs9TvKFCmCV8Be/dKu/fkXCYE/6YfSY/+TurazuekRnFPrTOOhVKdnfJM5+O6AV6lJzMIpDpdLPeCBXX1v/9erKSA6e7d9zFmcklyPuek+pXkPNVJ9CnJ7VWsKKfUMxgMhQOEZvTs6gffHQ2Ee0BK2adyRf8dBhhu3OxDRnKDMOEJBHPctBMbtDd3kQ/tYFpy0uCVKeVDOKKoVU2qezCdHdlLdmQT+hEFSvXXfyldfaF0YW9PkFHb5y/1ISqEh6BEj5+a3n7CPdiXlHuQy1c+kBZkW8cZh4hoUsC5cVbXo0zZng2SOkDd/IoXktoJSqpfGTHsLBipNhgSBkI3fn6X9NmYw5enuy8RxoBKDYmEWDK4MExgQoYPwiJSJ1ZJV86+gyEmhGTkhuDmBAYgrljjSXW7FlKt6n7AYhQtm/hOAHZPnpl95o/U+HIUa6YT/8dTfkDkvn2+88EkMhBq/J8+N/3+dWpK1w/yKjU2kuov+J0KBj4OJNvKMUVNZLo/CPnB4d0qTKC+mLI9xLsbDHFDUsNazK/CAyPVBkPCAOklNIJ44YwIN0PdJb9yUJXLlZVuuMQvI3yCFHlk8hg6SmrdzKe2u7K/J6AhLpuwC4h2OE4q8uJxRfgHRJcwDVLhkfrvsVez4rfpNNx4iSfJ5K+eMT9LWUZlh9BiG3m0Q+YQyO21F/mpyslx/ekYH94CyArCJDIA/8lbna5OGdTZqqk/Frm6Ub6zQ9tm0i+/4VX23IKH/f4DB1xzFca8x2HioOMRjUKKtsLo14nA/IpnXvEkpkDk/mF+FTyMVBsMCQav6iGfgBzTZNN48T1P9m67Urqqv19HfPBnYz3h/vgLT1pRgn98h1SutM/+QeYMsmSQhg+UjJSdl0B1fuoNT6arVJJ+cpcn0sO/9N/k1mYwJZg+Txo1KSs84e6vSD+43f//4PPSnx/xceD1a3mS27Cu1L6l9JfH/L5MiHP71V6FhZe/9Un6sJmaVaWbL/VqNsT76cHZq9QOGX7bY+GQ8E4ejj5W9/jIa2FEUvM5J9UvkFS/Qs7jpIXtBFIdt1CJJPplpNpgSCDCgDJP1PwyFOZv3STdeY0nbCF2mgGMv3lQWn1wam5I6r+flb57iyfWkNrv3nZwn4M5nN0xKDszTUq9PLD/07F+lsJv3OAJ8X3f9Wo6x3YKfIafZOZn//AdAkAOamZOrFbZ/0+WD4g1pJptJ82UGtbxMzA+/FvfgaBTEMIZps2V/v5ElpIfxTk9pPan+N8fDJcmz8rZfkJoZi88tlAJ6nP//oxDnaGT9QyhXCb0iWY8MRiKEpIYAmIoHDBSbTAkDJAzVGfikiGUX0yUTm3nSSkhIJBPwJtQ8kj/4p8+nCEQZGKr//yoD61A+SUDBwoxzyH2WbbGK8go2iETCHHI0+Zk/T5REOv8tyd8zPeAsz2RDnazbv1m6a+PSZ+Mytpn5y4/jTq+Akh0GGhJRo9fP+D979xWKl3SK9u4TL0w2PHHf5UWLk9vD7MwkjoPgevhlw6fNj0dPh8n9bvpWMOi6ZGUOMZ9jg+9u0n/+YUf7GnE2mAwGPIGGZnWZTMYEgWU5/NvyyK3zDiIQsuAwyvOP5j14oAPc3jpPU8W0w30g3QSKnH5+VK9Wp5IEkf83mdSk/rShBleAQYQM3JA883AwbzSgSDzxHcTCtKkgR9ICFkmbR92p6rKxIH36uo7AGOn+I5FFNWrSN06SH1O8wMgqZPh4z0Zz26iGYCifUZHafM2adaCo4R+xAC000++Jv38/7JmkjyZr3D30RNyCnyJxLx6T6pfUIK9pARKoF+0V5j1OYl+MWYhKSE7mTH1y0i1wZAwEPPb+3offlCu3C61bLlcxYuHGMmDcb6Z0j5yWOcia0bYJyjVBfHmNAMbimXZfaKsPfjkQy5UZLBlSznNm1fPqeI/u0v6+d2+Lk4m3ADMg5XMwzEOD8bcwPyKb3tB0JJEqlMHKibhGsuMqV8W/mEwJBjVqm/RVdd+pjJljjI7iqFIYM7sBpo/v16+d4ySQmBSYX7FC3Tq4jaZSFInSUmqX0aqDYYEg1tRieL7VSIB02UbThzFDr6xyG/E6aF4LEiyXxYZGk8k9ZyMC5IpHxgMBoOh0IDX7iFNW5KATyGkIGl+JbW9kuxXSBmYRL/iAiPVBoPBYDjpsZGQzzg9HHMboxu3h35SyUxuYH7FCwdieB4aqTYYDAaDwXAIcSIxx4Ok+2coOBipNhgMBoPBYDAYThBGqg0Gg8FgMBgMhhOEZf8wGAwGw0lDyC8blzyzuQW+xDHlV24Q/EoaQjslrb3Mr8IDI9UGg8FgOOn5gZOIpOepThr5NL/iheIxzCtupNqQ51i1apWmTJnipoLlYqhQoYKaNWumqlWr5ulDiFHB69ev14YNG1SrVi1VqVIl3y8+bNi+fbt27drljl+yZMnD1m3ZskXTpk1TxYoV1aJFC5UrV047d+509cMN45RTTlGlSpWOsJsbCftu2rTJrS8I3wyGvEJSz13zK14oCu2VFB8zUnKlx8WvZHazDQWKyZMn609/+pPee+89vf/++3rttdc0cuRIRzwDQj7NE3nFSDqrmTNn6p133tH8+fNVENizZ4879vDhw7V169bD1kGqlyxZovvvv18PPfSQVqxY4WyeN2+e/v3vf+vhhx/W0qVL05ZLvUCoFy9e7L4Nhjgj6fmBkwbzK77tlZSwncyD/CBu+bdNqTbkOSCO9evX1z333OMuiI8//lgTJkzQGWecoc2bN2vlypVuOT1P1FuUZtRtLpo6deq4fVm3YMECt47ltWvXdstLly6tdevWObK6Y8cOtw2KLuR27ty5ThWvUaOG+00ZjRs3dmXs27dP1apVc/uuXr3alcl2jRo1OqQIN2jQwCnJbL927Vp3PMqjHHxi+aJFi9yxypYt68pm+ejRozV+/HiVKlVK7dq1c/vxG4SbAfZSJn5MnDjRLUPVxi6ODbmGlKPuY1PNmjWdLdjIsagzjs+x8bty5cpuu3Qqt8FQGPM5hxjkpCD6wE9avLj5FS9Eczkn6RrbfzC3fZyuLyPVhjwHFwEEcdasWY4EQmIhh3v37tXYsWM1ePBgRwgJaeBm8PnnnzvSCCCTl19+ufseN26c5syZo927dztCfNlllznSDUmHmEJAIcSEUbANijXEGPL+zDPPODtuvvlmjRkzxtlxzjnnaOrUqW5fiCllnXfeeY7oY1e/fv3Utm1bt37UqFG66aabHLGlfMgvxHfIkCFue47dtWtXtWrVyqnl+PrZZ5+5batXr36IVHMjoAzI+fLly50fEH6OXb58eec/HYoRI0Zo2bJlzs5u3brp7LPPdkQcOzp16qSNGzc6NZxOBdvwfcEFF6hXr17OFoOhsCN0MOPycMwN4qKeHSuS6ldR8c9QcLCnseGk3LAgyYR/QAD5QD7pQYf444suukgNGzbUpEmTHKm89tprHRF99tlnNX36dEcWO3bs6JRdFFrCSFq3bu3IM/uceeaZjny+/PLLLkSCsolbhnwSfgK2bdvmCCz7sw6ySxn85phsB+Hu06ePI76UC/mHPKMOR2PAIcsQ4Z49ezpSDYmGYLdp0+YQsb311lvVtGlTR3ijoKwOHTq4sA/qhrI4DoSa8rELX5o0aeIIOnYFtZ74azojoR45FiT7pZdecuS/R48edgYbDAaDwVAIYKTakOeADLZs2VLf+ta3XIgDSnRQXCGcqNR8QigH6jIkkm1ZvmbNGkdsUW8hzBBp/oeoQ14hwBBySC5kHfIMUSUcAyUahZsyUcj5v0yZMo6cQ7ixA9IOQaVsCDbrKIttIbQoyt27d3f7BVWNjgBEGpWcfSHllMfrKbbjQygGBDoVdBYg259++qkrG4KNr/jD/sRks47wEEJB6HhA3FHyo3Var149N+AzhKnwNsAUF4PBYDAYCgeSE3xjKDSAAEIkUXohgpBWyCKqK8osBBQSzG9IMqQZcsmH3xBFYqUXLlzoFO2vfe1rTmEG7MN2qLcovZBdfgdSDcGGHBNzTEYQ1GG2xw5UYEIqzj//fN1+++2O3FIGBJd9IflDhw51ZBUFOhpWAeFFGYbQ3nnnnbr44ovdfuF1dk4DKUIGlObNm7twFToEqNMAf+k8QMZRuq+44gqnYmNzKqhTPkE9N0JtiAuSmqc6aT4FJN2vpPlmfhUemFJtyHNA9lBaSSUHUUWJhUQSQxy9oaG2okwTdhFipFFv+/bteygdH2owZBzVmXhnyDHLZ8yY4b5RnSHs/Ia8Q0bZnmNR/kcffeSIN/uRfi/YxjaoxhyffQm9QGkeNmyYBg0adEQKu2A3ZRH7TFgJZB47IcyoyyyD3BMPHk2tByDN5557rhuYiYqP6h3KhSSjfqPaU1f4k1eEmVL27SuuvXuTl6GgMCMjgzAfBuMWtCUFD87xpOapDn4ljaQl1a8k56lO2niFuPplpNqQ50AlhmySSo+LArKKsssgPT6ovZBOCDeKMGEYDMLj4iF7RpcuXVw5EOcvvvjiUJ5r1OS6deu6QXyElEBACd8gBIRviCuElWOzLd+EnKAQo/5CyjkWZaJiQ7QJOwk2QoaxjfhmFOHohcz+lEVsdxioyHHZL6jyqNwMgOzdu7fzLwxSDISdEBBUakD4CMeHvBOn/cEHH7iyqR+IN+XhE9tQn9gIicdHyiVchfVHu9msX1dZL77QTxXLH9CuPRDs+J3wPN+rVpLq1ZJKl5I2bJZWr5O276QDd+zlUWVly/jyypeVNm2RVq2Tdu892AuJHruY1LShVKNqzmXyYmHZKl8ONpUosV8XDxyt6jUOT7NYVBGnh+KxwPyKF5LcXkmbVTEjxZ+4+JWRae+QDXkMiCUKc7jQg5oL+STcAVUWQogagrKMyss+ABKKygwgr2wb1AXWEToCuSREg9ANyqYc1lE+y1kfVHH+ZznH41iEh6BSh9COQO5RrT/88EOnEt99991HKNUh1CTkouaYLIMEB/Wb8iG9HDvMBIUtHDP4D1hOWfiGPyFbCvsHu/AHv6kv9uNYIX4bm4P/EO7Umw2ks/f10uyF/v/WzaR775Te+sR/9saIWDepL939Fan3aVLrpp5gb90uTZ4lvf6R9Pw7nlznFuXKSFdfKF12ntS1nVSpgrRuozR2qvTMm9JHIw+vn3Ytpdf+JTWoc/SyPxsr3XqvtGYDCst+3X3P22rRcoUKE2bNaqD/PThQmZkZ+tld0s/vxtb8ST0HOKfj8nA8GsyveCE6N0KS/QJJ8C0zpn6ZUm3Ic0AI+eRmHeQTFZdPKiCs6QDxTDcgEKSWE83EwX6Q5egAwJCpBKWcuGnS7oXc1FFwUefkF0p2drHlqX6wHPujPkCW0yG75enqKx2KZXjidOUFUs+u0tQ50pxFigUqlpf+8D3p0nNou6zlZUpL5/aQzujkl//vRelALhRrVOn/u1760R2+7NDEDet60tyzi/T9P3uyHoh1m2ZSzWpeIT8azj5d6t9bevrN4/U4mUgln0n0K2lxuknNUx3HvMdF2a8DkUlt4nLvMFJtKPKAEA8cONDlog6hK4lBhlSyhFcj+Y7L/RY7v3qFNKifV6fXbpBGTpBWrpXat5S6dZAqlJN+fIc0ZbZflxMI47jnBunHd3pyvWt3VgejcxupVROpdg3pbz+W9u6VXv/Y7/feZ9LP/yk1a+iq8gjUqelVb+p2+RppxJcnpTpij/BCNG7xkUdDUl/0JtWvpPtn11fBI0HswWA4dgQ1OZ3SnBSke3xAa471sXI8+xwvmjaQ7rzWk1UI9W0/kYaNlfbt9yEc37vVE+S6taRv3yyNnZJzWEuF8tJl53pCvWOX9N0/SK9+KO3cJVUqL33rZukHX/Wq9AVnSW8O8eo32/73Ba/4pwKyf+/X/Dpiql9+T1q8/KRWi8FgMBgKMYxUGwxFBKjVp3eULoVclpPWrPNEdeZ8aX82yUEgtad1lPqdIZUqKS1a7tVY4oZRfzdsyiLabMuAws3bfKzyBb2kU5r4AYCvfpAV450btG0uNajtf388Uho6yhNqQEz1o69KV/b35bdrIVWpKK3dmH15Xdr4bcGwMdLL70vbfBi/1m+WHntNuuICv03HVlLlitLGLX49otb+NL2J+rWlay709bpijQ/7yK4eDQaDwZB8GKk2GIoIqleR/vojqXIFr7Lu3uMzVjz2qvTgC9L2gyQzAFL7nVv9wL5a1XxIBhlElqyQ5i9mkKf0qwe8SlyiuHT7VdINg6QR4z0RP7WdV5UhpcQmf/eP0pr1ubO1RWPycnsFmMGDgVAHkGVj4gxPgqtVkRrVy5lUt2lOWkNvy4x5WYQ6YPkqaflqX17Lxv7446ZmXx7qNPXSpIEv87WPpIWmUmeLuI3gzw2SFr8aRVL9Srp/SfMr4+AcEHGCkWqDIcHgFhtCF4KSTFgDoRL8T6zwL+7xhPt3/80im3VrSn//iTSwr1di2QeCW7qkJ56tmnoy+cUkT6rLlZVuvVzq0lY6rUPW8dkH9RYCn5lLFZfjoSyjhG/ZkX5gJakBp8/1v4mtJu3dl9OzL5MQEmKlGeRYp4ZX3feQQu8gSLGHOg0IEaE+cgLx19cP8p0JVPsnX49nusL8QMjFnkTEKSvBsSBkLzK/4oGktlexg1la4nT/MFJtMCQcIXMFJJj8zk+8Ls1b4snvdQN8qAZZMeYvlR59xZPtn92dRahRs59726/vdap0+fmeyAKIb0DQE7ivoywTZsGAP1L8jZ6Us5IchSP7jfzvHTulTdmkesYewLjSOn6Cymwx/EvvBwr0+b2kMztLX0zwdkKwCYmhowD27JN27s6+LPwL21Onbw09ttCWoog4PRSPBUn1K6kqfFHwK0n+ZcTQFyPVBkPCgYJKViLyOd/5C+mjEV49fvFdaeSX0v9+K5Up5dPuPf+2VK2ydH5PTx7JtnH1t32ohdvnHWn6POn33zmoYEfUZwhm+P+V96V7fitt2XZiNjNQEJU7HcjgwTbumBk5D6Qk9nvoaB+uwWDE5/4ifTjCh4J07yKdfZpUtvTB8vbnrKozEcxNlxyMKd8sPf7a4ap3tD4K3ZvLzIJ5SMUtLVZuYX7FC0lvr6QR68yDearj5JORaoMhwSBs46X3pSlzpG3bfZxwGEwHEXzrU6nqX304AzMLotoSCvHkG14xJl3dxJlZ+xBT/f7nXqkmLpuBjqEsQiA+qHkwE8b7J0Co90svvCt9Ns7HeaNWp8OCZdIfH/a/v5yWc2YSwl1+8S9p7iIfgx1QqaLvJPAJwP6lq7IvixzX734mfThSWrRMmjz7yG2YXGX8uFZasKCuChPWrauc70Q/qXmqQZLzVAPzKx4I11ii0sEqK0814S1xub5sRkWDIWEgfvjsGz2BNBiyA5Pg/Pqbh4fwnAzwUCQHPOChnxRinVS/wkywSfSL9uIbksYniX4lZbbIzJj6lYyrxWAwHAID7v7vK5mqUC68Nsv6pEO69bnd52jlnAiOx+6TebxjPWZ029x9MlM+OmkfBpRe3T99/m2DwWAwHB+S9a7AYDC4EI47rvZxxL97yCuSPTpLW7b72QEXHBzgB5rU91OBVyjrwynu/ZtUo4pfxqQohEHce7/PPR3Qu5v03Vt9TPUzg6VXPvCp8+77rtSioTRnsQ+1SE3Rdyxo11L6+V0+EweDAEndF02D17qZ9Jtv+jhoBl1iI6EpgGUMvmR74sgDsPGWy33qvA+GHx6rfUk/6bYrPeF8f7j03+fTh338+hs+5R65srEpuynfUX9/+y2pwym59/lAJEzCve7UyQE+Msiycf34zLBpMBgMcYCRaoMhgSAeun4dT5q6d5b69/axygzA+8PDfrKSU5p64npeLz/C71/PSLt3+8F3pJ07q5vfhzL+8ZRPHUe+6fu+I53RyR8npLEjlK9HF+nUtlL1af74J4IVq/2AQmzoc4YfsPjsW9625g2lX94jndvDDyycuSBroCB2Q7Z7dvVx1nQiFq84OO35lZ7479njOw/vf+Zjxbu1l37/vSyy/GAaQg3OPt13VsimAinPKe464+BEO+yTW+DLvn0H3CtO6jNphDdp8blxzaNblP0KSNp5aCg8MFJtMCQUGQc/DFYE5FS++iKp9+nS5q2etJLpA0ya5afZhmS6qblf9FOFN6jjFdwLe3vCWau6z3XNM8llt8jmuCcKZjP8w/+k9i2lqpWlH9wu3XSpV59rVvXLwNip0t+fzPKx56nSVwZ64tuorvTJaOmpN72t6zf5bVCx//ZjPy05RBYiTp5t8MI70qejj7SHgZm3X+nLpX4ef9VPcZ4tMr1KzuDP3CJTGco8UNxV7mFhGTmlNTmOueNpO2bURE3PD24BgUlK/GoU0fy5SSNpSfUrqfmcg19JiX+Pc3sZqTYYEojdezI04WAavFkL/DTjEEgye0AimdwFookSPX6adPtPs0IZ2O61D6Wt26R//FRq1kCqVyuLSJMdg9AJMqVdNN4AAJJoSURBVGosPBhKgvo7Z4GfMpzwEtLdnSg+HSP9+THpp1/3pBYbopi7WPrJ33zav+ggTQh57eqegDODYxDcBn/ilWNmfYQcE/oSxZBR0h8f8dOqpwLl2KUMzPRpCNk2J1Cv37rPh68cG07+Q5F2JFc3bykqlFe+IGkP+wDzK15I4tuSpOepzoiZX5b9w2BIGCB/hErc/SsfZ4wye+0AaclyqVc3qVdXP7MgKfY+GOFzTxMOEtTeAJRtQiJQqs/s5Kcl37hZeu8zP5EKZTA9dwi9gPReco709qd+fV6ATkC3dtJ5PX14CYoyJHroKP+BWEdzZUOWB/TxoRdTZ3v7ogS/SiXprK7SRWdL7U/xQi+TyODT8PG+7OzeejOTZP+zfDq9+UsUaxCe85tvSd+9xcfG52dKvbg8HIuyX+FjfsWvvUASzsXMiF+BXMfBLyPVBkPCACl85BXp/37t/69adavKlfPMknsSZBjllWxgEM6jhU6yD+QWko1Cnd1kLCcT2ABhxm5sPtEpwSmPgYuwaspDfS8K2LWrpNavr+Qc/9ld0s/vPvmkGuK5/2AFk6ItDg/GY0n5lWS/QiqzpPjFeRhN0ZZEv+JCPpPql4V/GAwJx/kXfKnOXSKzmxiKLObOra8nHutfIBPAhO84PBiPdba3JPkFkjpIMap+Jgmpqm5SkBlDv4xUGwwJR8lSe1W2XAHIy4ZCh1Kl0wSMGwwGgyFPkIz3HwaDwWAwGAwGQwHCSLXBYDAYDIZDiMur9uNF0v0zFBws/MNgMBgM+ZKnOklkJql+gSRlkYjC/IoXisXwPDRSbTAYDIaTiqRkWkiF+RUvFIX2ihMBTWJ7xc9ig8FgMMQKScy4AMyveKEotFeS/MuMYXsZqTYYDAbDSQX5ZsNEKUlCNAd3Ev2KG6E5GsyveOFADM9DI9UGg8FgOOlqEw/IOD0cj4aoT0nyCyStrQKS2FZFJf92XGAx1Ya0CCcxN9dwgyVWixinwj54IN2EDOE73dSnYTl+5jTwKGxzsqZMjdZ5KD+dDwaDwWA48XutwZDXMFJtyBY7d+7UjBkzNHXqVG3btk1lypRRq1at1KlTJ1WqxFTHBXcjPBrB3Lx5szZu3OjsrFat2mHr1q5dqzlz5qhKlSpq27at6yTMmzdPixYtUufOnVWjRo205W/dulULFy5UuXLl1LhxY5UqVSpP/WA5Ni9YsEC1a9dW2bJltX37dlWtWrVA6ttgMBgMBkPuYaTacAQgd8QxTZw4UcOHD3fED1K3b98+R0g3bdqkChUqHNo2qtwGlTWsA5DWKJGMxlYG9Tvdqx6WhzJTywsqbigv9VjLli3TpEmTdMopp6hy5cqHFGjW4cO4cePUqFEj10lgH8jyiBEj1LBhQ0digx9RhT7YG62jVNvD8XPjR9SHaNmAsufOnavFixc7ol++fPkjFPLoMU3FNhgMeYXUe1PSYPdLw8mCkWpDWqCYQjy5sV5zzTWqX7++du3apS1btjgFdfny5Y50Q1CrV6/uiB/KLSSwQYMGjuhNmDDBrYO4Ll261BFFyCHLS5Ys6cpDFT7jjDNUsWJFrVixwpWJygxpP+2005zKPGbMGLft7t27XXkdO3Z0y7Ft/fr1bh/sgTi3a9dOzZo1c4R68ODBatKkiesEYF/NmjUP+ZcapxWNj0TFxnfI9YYNG5xq3KNHD7cexX7v3r2aP3++I+7du3d39YHt06dPV7du3Zy6HPzAL/ygrNGjRzsf+KCSQ/ZRx7EP9fvMM8903yji1B82jBw5UrNmzVLfvn21Z88et0/Xrl2dLfjIMuqvRIkS9qAwFEqk65QmAUn1C5ysELeCRqrAkxQEv5LaXhkx8stIteEIQNggiZA7CDEkGdIGEYbsQgIhiBBHiCqEGXJNWAiEGSIK+Xv++efd/uyDClyrVi1XxnPPPedIKuEkhJdAxlGUP/nkE0fauZAoE/IJSR0yZIgjs4RqQE6jgOASprJjxw5nF8fmAoTAo6yznu9juZFi0wsvvKD+/fs7ggzJxh86AGPHjnWEvk6dOvrggw/UtGlTVwfUBWEydevWdXWAH9iBH3QIgh+Uhx+lS5d2++AXBBtAkPmftwNt2rQ55EPwY+bMmW47FHb+pw1C58NgKMwIb4qSBvMrXohj3uPcwPwqPDBSbUgLyB8XKkprangBqjDhEu3bt9dFF12kzz//XKNGjXJEkDCR2bNnO5IMGYQkrlq1ypF0iOWaNWscoTz33HOd+v3uu+/qyy+/dAQS0tmyZUunDLMfBBbSCiCxkFwIZfRBRlkcE4UXdR1CyzbNmzd3x0PV7devn+sU5AYhTIMysZH93n//fecTy8JgRgg2dUP8M8umTZvmbIdM4wf+04nADxTn4AekGz8g5lOmTHHlU48tWrRwZaKAUx7+sAyi3adPH3Xp0sV1QqgTlGuW05mAUGNPnHryhqKHaMhTkmB+xQvWXvFCZgzvG0aqDWkBgYPcoQCnJpaHOPINKUYphQwSAsEyiCeqNMouxJJyiA1G9YZkEhKB2gy5RKGlDAg6SjckMaiykGi2oxyIJ2Ec/B8lxxBx1FsU25AHl+NAZNkfshk+0Z58CJXgWNGysB8lnW2DbajMkGc6GdFYcEgx/qE2AzoL5513njs+fuBDTn5Amnv27On2nzx5slPDQ4hJAHZgO/vxQfUPiji2sg4in1S1zJAchPM6aeeq+RXP9kraOJQQupg0gSUzkpUrLn4ZqTYcAW44kF6IMkrs6tWrHTmELEIaIYuc7OvWrXMhGpBsviGLkFPCMCDSKMXsi3rM/oF4UwaqMiozZUDE2ReFGmKKuowNEFqOBQgRSX3FBSlGIWb5gAEDHJkmRjlchGEwIYiGf3A8SCpEPhwDe0BQ5gMRjw7AjIIyUJ+HDh3q/sd+Og3shx/nn3++Tj31VLcvdcMx+B1IO8cnXIaBkdTVyy+/7Ig2RD0g1QeOQT3yZoB1kHDLCmKIy4MxaWQmqX4leRB01K8kITVVbFJwIJIHPi5+Gak2pAXqM4P7COt4/fXX3QBBSCwkDgW3Xr16LnwBBZfQDgglyzjxUXlRbhk0yEXBgD4G4YUUdJDqzz77zA1ahLQz2A/FlQGGhIIQXgL5JFaZ1HXZXUzcGLGT7b/44gtHkENMNQSUb0IvUNMJTQmp9VhHuePHj9ebb77pLljKaN26tfMvpwdJINnYh8/4RDlXXXWVK5//8YNl+B22IyQlOvAHko1CTd0RysFxsTOsD77hEzHW/A/hxg9iz2kLwkZyM0Bx187S2rKlbOzP9OBmXo0zCrV2tOJydS/PPLycMmX2qmTJfbnb12AoZEjiYL6i5J+h4GCk2nAEIGmQNbJKoCajNBOigdKMCgtphDhzYyJeGtIIMSbEgWXEDKMao8LyP3HXxP5SFiQzDMyDXEO8WceyQYMGOXIMweX4kFSOiXLNYMnUvNBsw74Qe1RnSPg555zjyCcEHyUYJRuCj80BhKScfvrp7jcqMTYSv0w4BjZCuPkdjkfYBWoz9kBkIcD4AenFV8og5hmlmbLxg6wdOfnBMVH+V65c6Qg2tlIG69gOEs7bAo5HDm2ynECkqWOWQ8Bz6nBEMXrEaZo3s4uWrMg7QppfQFCqU1Pq3lmqX1vatVuatUCaNFPasj0XjDgVGVKFslKn1lLbFrztkCbMlGYv8GWnomUT6cLeUskc7pSYsHGzNHiotGGTX9a+w0JdevkXKl48eVNzGwwGgyE9MjKty2ZIg3BahAwU4X9IYghLYDlKdAhnCOlvwvYQRNZDGlnPcuKt33jjDX3ve99z5JB9IKghxCKUGT0Wy0JIRupkKXwoP9jB/9H9+IS45OgshcHOEFoR3YZlfAL5jW7Db7YJsaEcO2wbXinmxo/oviDUYYj1Dr4GG1mPqo1qTUYRSH+vXr3SxprRVI+8Iv3fr6Va1aRff1Nq31L6wV+k0ZPic7pXriD9+E7pqgul2tWl0qWkA5nS9h3SgqXSnx6RXv0w9+XRPBf3kX5+t9SkvlSpgi8PQjxjvvSjv0hfTo8cv6L08G+ky847ulq9Z4/0p0elPz4s7dkrdeiwQDfd+rFKlvTtW1gwa1YD/e/BgcrMzNDP7vJ1cbLfhIfrAYT7RBKQVL/CPTWJfoVnUxhrk0S/khKykxlTv0ypNqRFOHnDILl0SHdTYr+oohy9eXFxQKRRwFGmUW9Ty0tXZnYzFwaSjLqcDpB1Ptntl125UZ+juWhB6gMmXRm59SO740eXh98Qa2LX+RACQq7u3AzeaNVUum6AVL6cJ4dxIdW4dduV0v9dL5WJNG+xDKliea80//F70vyl0sQZRy+PMi49V/rT96W6WenKVTxDqlFV6t1NeuS30jfvk0ZNlPYf8OR4/aajq/vYyml2Vjfpb0/4/QzJz+ecVL9Akv1KYkx1HPM5J9UvI9WG/DvZDmawIN3d8U7xXVTBzYVQGUJbgrqfK0TuRXEK/ejaTvr2zZ4Mb9kmvfSe9Pk4qWIF6Yrzpb5nSo3qSX/4rnTDD6R1fpxptuhwit8WQr1vv/TpaOm9z6QK5aVLzvHHa39wm6u+Ja1aJ+3cJf3qAentT6USaUQtlPPvf9Xvu3ef9Oxb0vadJ61KYo2kqIKpML/ihaSR6XR+xYmA5oRUQSsufhmpNuR7rHZuc0Yb8r7uuC+F+9TByJNcwXGiTK/g5hYcB2WZfY6F0LPf7Vf5WGoiaFB///yYj38Gg4dIL/1D6tVV6tHFx1tDfHPyue/pvjzsePw16cd/lbbt8Osfe9WXd1ZXH2fdrKEn1WDNeun9z9OXe1oHH0ZCmdPmSO8Oi1fHJT8Rx3yzuYH5FS8ktb1AUHTjpuxmh2ga3zj5ZezGYCgiaN1Mevi3UtvmPkRh7BTpidekOYt8bHEq4O9ndpLuvFpq3kjaul0aM8WrxjWqSFNmS5u2Hl5+8WKekF53sY9fJlSDOOV778+9ilumlNSupSfkK9ZLr3yQRajB2o2eGEOoUbLbtZDe+TT7MYtlS0sXnu3V5k1bpEdfySLUAJX7hXc8Oa9QTuraXvrCpx/PFqVKSrddIVWt5FXqJ173oSKG9LB8zvFMZZY0ASSp+ZzDPAtJ8+vAgQOWp9pgMBROnN8zSz0GZ3TycdZ/ftSrtVGVtVxZ6Vf3SDcMkqpV8WSZ9WefJt0w0IdhEI7x9V96Utr3DOmhX3tVePNWqU1zTzz5H4I8Z6H04AteeT4aalWX6tXyx5s6R1qx5shtWE72D0htpzber+xUdCKN6tTwv3fvSR8qsnSl/6acc7pL/3kuZ1vbNJMG9fPbz50vvTnEVOqils85qX4lOe9xdCKzJCGp7XXA8lQbDIbCBEhfuMeSFo544jUbfThHtcpS0wbS77/rCeFTb/j1ZL34ydf8IEH2gawSBkEYNxk5iGUGHVtJZcv43w3q+LCJAMpDDSYeeuEy6YPhUmYuQ0daNPa2AdIAEtucCtTwlWs8qcaHMmV8VpB02LVLmjbXq+0o0YR4LFt1+DYQ/xD2S2eAjkd25lInt1zuBziiUlNv1I/BkBQkkXgWJf8MBYdkvdsxGAyHgZCHQBYJfbj/cemdYV69ve1y6YZLpCoVpXvvlIaMkhYv95kw7rzGk8fV66V/Pe1Jcfmy0levlK4d4MMuoqp39BmFeDdygvSH/0mLlvuwkRCjnBtAlCG2ALKaLjRlx05p8zb/u1wZH+KRLane4+OiyTeNAo+vpNGbPtf7eGZn6WvXZI3ppOycHrmQ88vP9/7PWyK98mF6Gw0Gg8FQtGCk2mBIMIhFDgMS3xgi/fGRrHXT53jyiurKIL5zu0vPDJYuOMuTT+Ku7/uv9L+Xskgzii/p7Lq09ap2CLmIvnEkzd2t90qLV5yA4QePlxNZPRaxiWwfpN4j5KXnqdK7D3tSjf/k8EZxDz64jkI2ZdNBuekSH06C/88OTh+esmVrOU2f1ljFSxSuyV+WL6tRYIMpozOKJgFJ8yeKMDAsqUhyuyUJGTE8D41UGwwJRCDSkNJwT9qw+fBtdu+Vnntb+spATy6JJX5/uHTOmV61XbdBevuTw8kr4Q5hkB+KdFgXcknz/7AxPmzjeIGyvXe/DzepXcOT3dT7KiSYUJSgRBMrnRMWLpdu+pH0yO+kXqd6NZzsIQGUz8fFhG/LnsyT7ePqi/x2S1dIL76XPvZ68aLaevLxC1SYcSzZX/IyNVYSSUwSyUwSOw1xzHt8LH4lDRkH7x1xai8j1QZDAkHccPWqR9+O8ArUbHIuE95RsnjWAEMye2xPE8+cDmHCE5TrL2cc++zhUZCNhPAMwjoa1vGhHTtS7GCGxbq1/G9CVlLXpwOhKAysZIAhn2YNPHln2nM6CmHg4bgp6VVw1n3lYh8/DpEmY0j2nYfC/RCgXnt2PfpMkXkFy+ccLyS1vZLauYtjPuektpeRaoMhgWAQIVOURxHin6NgkB8kGhJJqjrIKWS6kaTqVfyHWOwo0t2zg+rJYMTdu0/M9tXrfEhF/do+XR6hFguWHb4N2UWYZhy7J82UDuRCdcVPyv7n09IjL0sN63q7yfzxj5/4DCc7d/spy9OhQW2fKpB6XLZaev6d7DOO0KlhJst0k8Zkj0zXGcmq3pPzcMwoJvXo7ENhDAZDspBEJT5OMFJtMCQM3E+5pbpP+CGfpg5FOoRKQEpvuszno961W/pwuFeIPx7p44xrVJOuH+gHHBL24fYp70MnDh0n5d6dFy8gsWX2Qj+5Sr3a0sB+0gPPZhFYBlbefJknwfgCCQ7HRW3v3MbbNXmWDyUBDEgkrzSDFR9+2U/UMmOeXwdx73OG/03Iy/LV6ev0qv4+wwmhIa9+6AcpZocWjaRv3XT4FOtHAx0E8s36CXrIN6uTjvx69uJXEhVQ8yueKdriFlJQlP06cOBArPJvG6k2GBIMlNKglg7sK/375z6OmpAKZi1kgpYQGjF8vB98N+QLP3iRtHbfvdWT2Lc+8enovn6tn+QlENWTwZEgz0zu0v8sn7buR3d4xfwzpikvJ10zQOp3kARPmCGNmpg1acwPvip962bfj3jkFemX//LqO9OT//B2r36f0kRqXM/nuob84muYGZGJZkgBmAr2J1MKKvXaDX5K8qPFJKfrdOQEn2eWngOxrPlHePMrn3NcHoq5RVHIU51k8pkkJN2vzBip70aqDYYEAmKKouq+Dyq8ZPRA4UV95v4UyPaSlX7GwzApCrMm/vFh6adf9zmryVf9tWuz9gn3tmjZIQbZDSrMA/shyg+96Al1INbfv82r7sFu0vT95G9Z6foYvHhWN69WgzM6ep8h1RBhOg1XX+jV5vt/5O3nGYTiDcZPk/71jO9YpOLcHlKrpv43gzdnZhMiErBxizRuqk9dmFvAp/fv94PDXGclj58hvGVo2di/mSgIxO3hWJSRxEFvRcE/u74KHkaqDYaEAVJIeAMTnDAA74MRUvdOnlwycQsKcxhcyFTjqLnkqA7PGUImHnzer//mjV7FDXHXLCNlXs2q0usfZcVbT5gujZ7seSC/TxQQXmY1RCG+9Fyf6QMyiA2Eh6xcK/3pkcOnE8e/oaOlDqd4Yj9igrT1YC5rYqV/+6BXvIklrlDe1wPl4S+hHD/8S/r0eIBwlNkLfKeBeOwQDpMdRn4p9b/9WL3OOKm3ZKaM/+P3pOsHZZ0DBoPBYMg7ZGQmtctmMBRRrNkgnXOzz2oRYqkZtEiqOMI96h/MXjF/ifT2p17FTXcXQMFF1b3obB/bvHevV2g/HeMH7c1a6GdMjM6ECC2cuzjvfIHMQ+r7nC41ru9jqKfMkkZN8gMrU9PZEapCTDX+TJ935JTkqNjtT/G5qpkOnU4BxHzyTD/teXZ3Q+qCWRfxl4GN2Q1QLOwg48knT/swmPx8hbtv3z6nUJcoUSIxSjWPTvziG7+S8urd/Ip3eyUlFWJmZqYbsxBiquMSimSk2mBIGMhH3ft6r65WqLBDHTsuVPESPqbBDYLLODKHdU44bB9yU59M449iA8dOlxf6uMvLTP5siPv3F9O0qU21ZUt510EZ8bzP/53fD0cQpwFHR4P5Fd/2gqAlqROEX3yH6ysJ11jmwTEL0YGKcfDLXgIaDAlG1arbdPGg0SpT5iizoxgSi917SmrliuqOVDsUwHMpaVk/AsyveMHaK14oFsPOj5FqgyHhKFbsgIoVT7gca8ix/Qv5XDQGg8GQCMSrC2AwGAyG2CHERiYN+BRCCpIE8yue7ZW0IXIHYuiXkWqDwWAw5EtsZNIQ/IrTQz83ML/ihaReX5kH7x1xur6MVBsMBoMh3/JUJwVJ8yeKpPqVdP+S5ldmDP0xUm0wGAwGg8FgMJwgjFQbDAaD4aQjLimxDL6tkoyk+2coOFj2D4PBYDCcdDKdNCKDP6T7SuLU0Enzp6j4lTT/MmLol5HqkwxuuDt37tSOHTsOPVhKly6tsmXL5vpBw+jX3bt3H9r3ZOZtxN7t27e7YwQbw3KAHfjD4AHWlSpVSmXKlHE28sG+MGDiWGZPo/w9e/a4ssNoesrGBspJt/3evXvdh+0CjiVJfBgEQRnBl9y2B3Zib0i4X65cOffNzFZhdrXsygq+sn3Im0p5/A6+xOkmYjAU1fzAccuheyztlcTOgvkVLxSP4XlopPokgxPiww8/1ODBg1WjRg1HuDp27KgLLrhAVatWzdXJsn79eg0fPlwVK1ZUjx49VKFChZNmLwTz9ddfV/ny5XXppZce9jDcsmWLxo4dqy+++EKbNm1yhLd9+/bq1auX1q5dq3Xr1qlr165atWqVe9i0bNlSJUuWzFUdbdu2TV9++aVGjBihjRs3uuOy/8UXX6y6desesQ/kddq0aZo5c6a6dOni6hHbmzRp4uopWnYUqfVN3c6ZM8fVKb6kI/BRQMJXr17t2nT27NmOYFevXl0XXnih6tWr52xq27atatasmW3bQqjHjRun+vXrq1GjRs6XYcOGuf2xIakExFB0EaeH4rEgqX4l2bek+5U0/zJi5o+R6pMMSN2KFSvc7wEDBmjBggWaPn26I1A9e/Z063ft2uWIVVBLg9oblkP8Fi1a5Eg5y9guqMP8z2+IGGon+7I+7Au5ZT3kNpQZlNmwHITl7APJhCgGQso3y8eMGePIPWS3cePGbvtgP7ZBxCHebMdxWQZZ5bgQcJal2owdkMxZs2bpgw8+UKtWrVy9sA8kne05DvvwO/jDcTds2ODqpUGDBlq+fLk7NmU2a9bsiFQ8kGX+xw8Q6hmFmbbgd3gjEHJjRusuXNjUcSDzvXv3VuXKld0xIPJ0LN59991DZVMfQU1nG8ph+datW/XRRx/p1FNPVaVKlZwNTZs2db9D5wA7sAG7sQFbQpuGNqEsPnG88RiKFsLbq6Qpu+ZXvFAU2ituym5uMuzEKXzMSHU+gBMd4nbGGWc4ErZy5UqndkKQ+EalhGxDkCBaZ511ljZv3uzUUJYDCCOka+HChZowYYJTRlGE33rrLacoU/4bb7yhPn36uHI+/vhjLVu2zBG2vn37OnUcBZjl8+fPd9ugMHfr1s2Fe7B87ty5qlatmiPVZ5555mE+QHAhkpBkVHaUWOyHZEICJ0+erKVLlzqC+/bbbzuizD4osWvWrHE2ojjjD4TykksucUotFwq+jR492pWJ/ezDhYS9EEoU4U8//dTVFeT83HPPVZs2bQ5TjiHy2DdjxgxXN9QfRBtSCuGFtFLvkHfQqVMnVy/4PmXKFNcudF5QyiGvEHbqjmOhhIfOB2QX8ozd2FC7dm3XvtQDNqDisy/lX3TRRY6A82E/bOCYixcvPsJe2pTOAHZQlyNHjnTlUBfsw3Hef/9910a0Hco+bdSvXz9np8FQWBE6uEknM0lCECTiRGaKsl/hGkuaXwcO5t8+2hvkwoT4WBpjhBhaiB5EE0Aw+R8yBSmEuEGSCa9AJWYZijbENxBsSCzlQMQgyXxDEiFtLJ83b546dOjg9kMNDaEYkHbIKdtRbufOnV34BgSQ5SjpEL127dodOkaq/RBJ4sIJryBshYcIiixkE2IKYYWMozSjZANIH/tCBCGukEEIMjZEL37KRXE+++yznbodwh8CcYcU41fDhg2djxBSOhiAMvgdQkQIj4Gcvvfee5o6daork44KxJMPpBWyja10IGrVquWOzbEAdoYOEKR3yJAhjjwHUh2UbToG//3vf9062qJ58+auQ0F5+E0dU0+QYuqYNhw/frzbt06dOu547EsHiu2oF+qT9Z9//rnbh3WEidBO3bt3d2SbdqNDwvb4x3GpcwsZMRRmRN96JeWhH81TnSS/4pofuCj7l/TzMDNGfhmpzgfwGh9C9ac//cmRakgQZAhlFIUWUgdZgnihkkKU+Q2JhBRCQiHQkC6UYsggii+qNeQNhZjeHGom5A/y3L9/f6dwQiD/+c9/asmSJY6EoaCyjmP/+9//dmVAVCGzKNCQcYh96gkcDZvI7uQOBBdFlp4lZBYVG0I+ceJERzghqhBkyG10EGQYcJiOHKICQ4Ih/vjD9pQdjkmYBWVDeE877TSngFMWJPf0009X69atnQ34T93Q0cB/iC1+R4FdkGTqDp9DZyaAjgHrr7/+emcTqv+kSZMOxVTTIaJN6CQFVRsyzDedHeqGtqcN6cRgX+jE0Ib4SF1AolkXFHfOAXyiwwLZxmfINstPOeWUEz5HDQaDwWAwnBiMVOcDUHUheMTgQo4hdJCnoPQGEhbiZ/mGhKPQ8hsiB1mlHMgU6idKJUSNOG2IH6ScMiDdEHO+KYv9onHJEE9CKILSC6FjeYgBBuE7AOKKLRwf2ykLu3Iz/TD7YS9EHfJJB4DBh9gQQB2g1tLhgECHdZBZVOxPPvnEhTvgHyovJDVVTU/t2WIzxDXEPEPqIdSQWj7Yw7FSFQvqh/2oD9oHG1K3qVKlimtLyDWdm6FDh7ryQ0x0qBfeABC2AhHmgy8hxjpsl2p7aAvsoI7DoFT8De3JdzhPsqsHg8FgOF6kuz8lCXFRPQ3xQ7ICwQopIKMQy/PPP19XXHGFI23EzELaUJchkSjIxDejOqJ4QtxQlyGxqJGo2ZAxCC8EHTWbckOIBCEWhEBATiGekFdiqiHfEDPKYzllUS4qK6QMW7ABRZRjoFpDBlNvqOzLdmyD2kwcNLHSHBflNxBrlGbKDWkEKYd9UXAhmHyjKkcVaYgi/qMk4xcdBPwmNIZj4EtQgPElleiGVIMsJxQlEE3qJwzcCDHsHIf6o6OR7qFxtJg0yqYsOgAQX+o8dHhCSAw2oPgTE44vEGpU6bA/wF6UbDoLQQlnf+qG/VGnqQPaiuUhU0zqCO8kP/gMyctTnSQyk1S/QBJ9Kgp+Jc23jBj6ZUp1PiBkfYBIopIS/kCsLKQKtROySXxuULTPOeccF7IAwXz88cddGSGHMQolJJVtiR2GbBHnDCmGeEKSCV0gSwf7Qx4hkoScQN451iOPPOJIcIsWLZwtkHgGKj755JNO2YUMp6bCg8wTkgBZfu2119zxsYksIIQpQKSxj/0hhsQ0v/jii27gIdvQWWAQIOEZqUp4CNuArJI9gywglE9HgJAUCClKMASTOgvHBkHtpw4g+88//7wbvAdRDVk7+BByQQfghRdecPtAbkM+abbjd6jjUDbf1Hf0gqZcQj6o35ChA3BMCDbti/28kcAnwkvwCZ+pV8rjXKA+SCFIh4H2Dpk88ANbiRtnPe2EKk6bsz60SyDwRxvAsXNnKc2Y0VilSmWFsMQRNEnJEnQipN176U2cWHk0qSvPpZHMebvSpajvnMujX7QnUk71GptVp85Gt78huXmqk+pXGHgZJzKTG5hf8UKxGJ6HRqrz4aSAFKE+Qoi4CTMIjnhpYn/DK33UXlRHSBgfFOgrr7zSLQ/hACFtHar33Xff7ZRjCDGZNRjQCCGjPMgcii7ZI/gfQg3RhXBDrFF/IWMoqNgAYcM2joUt7B+Ie/SEhsRjC2p2IN4cn44A9pGfmWOwP/+zLaQ/pAvEPghySPsXrSOOR1gIxDdMPoN/2Ae55jgQYeyDaEI8AR2JYD91i8/ULdvzPySfbzoPHBeFmbphGftyDAgx9UTdBEU/7MP+0ewaEFk6CWGiGuykHDpBlD9o0CAX2kN51NdVV13l6pX6prNDO3DM8847z63HF5Zddtllrq4oC5JNXaFi0+Z0frCBWHiOQVmQd5aFQaPZYd26ypo06jw1qS+9/7m0N0bcmlOkTg3pzE7SgD5Sw7rSzt3S1NnSB59Lk2ZJ23ceW5nlykgdW0vn95RObefJ8OfjpGFjpVkLDifGYFA/6f9ukIofhVRv3Cz98l/SjPn+/06dFujGmz9WiZLZh0YVJcTpoXgsML/ihaLQXknxMSPFj7j4lZFp749PKuJevScaZgDJJSYapRlVHuJMxyD1Ains9VTYwy2i9blhs9T7emn2QqlhHem5v0otm0g//bv0+GuKDZo1lP73G6l3N0+wo9i5S/rvC9Iv/nUkEc4OFcpJP75T+uaNUhmf3vuwOvvJ36RnBmd1PGrXkF76u9Sjy5HHTwXRT4M/kW67V9q2Q+rQYYFuuvVjlSzp32QUJHbvLqGHHhyohQvqus7ViBek2tULLqVeXB6OR4P5FS8kvb3C7L4gCb5lRvwK7RUHv0ypPsmIw0lwMv0Iyi4KMLMFRqc+z4vy8xtxsTOgYnmpWSOpRlWpVTPFBmVLSz+/O4tQQ6I3bpFKFJeqVZHKlpG+dq00eZb00nvSgaP0dapX8eXdfpVUqqS0/4BXl3kGVakoVass/ekHvr7+95K0a7e0Zr0vu37t9OEfnAlVK3uyjo27d0v7Cp5DFzpYnur4IZDPuBCZ3CLpeaqT1FlI9SsuMFJtOKkg1IJwEEPBo5CK7GkxoK906bmerM5cIP3639KX0334Bst/eIdUvqz0i/+Txk+X5i7KubzT2ks3XuIJ9doN0l8fl4aO8uT9svM8Qa9cQfr6tdJbn0gLl/n6euRl6dUPPflOBWT8yT9KXdt5dfqxVz0ZNyQj3+zRYHmqDYUFSby+4uqXkWrDSUVcLoSiAFTeOjWliuW8srtpiw97yIlsQyZrVfNqLCosavGWrZ7sUkZ03yAmIHKxPeo44yq3bpNWr889qcfO6wZ40swgwt8+IL3+cdb6+U/4cJYbBkmN60tndMiZVOPD+b2yfPjjI9IDz2bZAykn1OP6gVKDOtIpTTypBmwPCU+H7p2lNs19OZ+MlsZOyZ1/BoOhYFFYw/gM8YeRaoOhiKDvGZ5cNq3vyeLUOdL/XpTe/lTasu3I7evWlG66VLrlcqlBbWnHLmnaXOmp16VG9byiy/+QaMIxLunnM2osXO7jlvuc7pdPni1d911p6crc2Vm+nNTIT5CpBcukLyYdvp4YasIyrrnIH69tC0/ys3tOom73OcOT/vWbpHc+PXxbErhQB1df6DN99OoqfTgiZxsJE7n9Sq9079jpVWrqx2BIAixPtcFwfDBSbTAUEXSITLzIOD2yanRpI519uvS9P0pbt/t1vFuAND/1J+mMjl7pDanlzuoqde/kCepV/aWL7pSWr5YG9pUe+71PdQdhL1PGl8N+HPfKC6R/Pe1jmY+G+rU8oQdk04AIp2LRch8TjcJMNg/U7ewym2Ar64Nv6V6ekD6c7Vh3Rie/fU7x0T1P9R8wcqI04suj+1VUkS6/ehKQVL+S6E9R8Stp/mXE0C8j1QZDggFRLBa5H23Y5BXqUqWkTq2kcmV9GMWB/dK3fy/t2uNT1z16n9SdrBfypHb6XL8tqjDKL/c4VOgQ8kGsMh/3+2DeZrKPLF4hzVnkY5NzQ6gBoR2VK/rfK9d4wpuKdRulFWs8qa5Xy9u0OY3aDrbvkIaNkVo1lSpWkM7pLi1aljW4EQJ9bo+stHnERef0cpiwFAY8Uh+k+Hv81awOiaFo5XNOql9xzA+cG5hf8UKxGJ6HRqoNhgSDe1G4H0Fuv/YLaeIMrz5f1Fv6w/d8HPGgc6SHX5EmTPchIsQLs9uYydKP/ipNmunjo8nb/Jcf+mwajrCnGZRNeAaq9D+ekjZt9eEhx5Ifm/lsgs1k4EhHcHfvyQq3wAY6CdkBxfmTMdINl/i46nvvlCqVl94Z5sk4YR90LMIxKTsndGsv9TvT//5ymjRkVO59K6qI00PxWGB+xQtFob2S4mNGTPNUG6k2GBIMCCUkl+8Ph0sjJ2Ste+UDnwv6Z3d7BbffGdLsBV7JRbVF+b3vIemLiQd32OX3QaU9vaNXdA/OsO4IaQiXGDdV+uPD2SvHRwO3Tog4sc6owengQjUO+he2zwmfjpFeeFe6cZBUt5b0q29KP7rD280xKC/Y7zoK2UjV5Le+7Qr/HWKpN289crtMZejAAf8paBw4UPDpqKL5gZME8yueGVuS7FecMmXkxqe4+WWk2mBIMFavk37zH6/ITphx+DrCH55605NfSDSDArlnfTBc+mKCn61w+PjD9yEbxz+f9nHPqNCBUE6aIf3wz/739HnHT6jB+GleHScsg1CVdMCOh17y6e7WbpS2HCX8Aju//ydPrpmlMadb8+xF2YeqMDCS2RexkTR6DNZMh5Urq+ntt7qrWLGCn1Fx//5iWr++UoHaYOQzXrA81fFrLz5Jy799IIZ+2YyKBkPCsGaD1O8mH9NsMETRtIH0KZ2i2vlXLzwU9x18pVGiRInEqIRJ9QtFcC+91gT6RXvxnVS/iPFPygQwmTH1y5RqgyFhqFZJ+t5t0nf+4EMUUFcBb+BTM1qgBodnC/wA9RrVOoy/IgQjVbWlvJDCLsRKRzNscIyjhWMcDVG7crIhandAWJ6aYi/4lWof24c6YpeDfOIIsG/xHGyKgsGhxIYfG1JjTvL2AUI8+Q9v93nHDYaiDMtTbThZMFJtMCQMkDkGFN7/hA/7+MsPfGYO0tMRCrJyrSeSzRtJv7hbalzPhzL84C8+y8cl50jfuMGTyLFTpT/8z08Swz7tWki//Zaf1nvFWumbv/ODCc/rIf30656w/ulRH799vIBKMnDwlsukjGI+cwczIGIjNrRoJP3u2z6Mg2X33u9zYYO6NaTrBvoyCA0h+0jIK/3jO3ws+BtDfCw0seaQ5H7dpe/e4utq1kIfxkJoy2F1WtzHYF/Qy5P4+5+U3h2WvQ+k2/vlPVkZUXL7oN8PW8/IcMpMXmsyxM2TASV0IAyGooo4KJ6GeMJurwZDAuFU2QypaiXpjM5SmVKeUPIhDpiBdpefJzWp7/XRz8dJy1f5fSGizLwI6Wb7Hl2kj0Z6pZMpvRvW8eSW7UirB2pW8yn4UHlrVj0x27GHWO7vf9XPbsg04L26SaMmSBXKS+f39LbBOp97S5q3NIs433+v9ysQ29t+6meOrFRBunaATxfYtb2fmIbY7+YNPalGvYVkPz04fTw4ZPTOa3z6vnmLpckzc/ahamVfd6VLH4PfBwdnKiPTq/559NwPxRQUj0hqPuek+pVEf4qCX3EZyJd0v4xUGwwJA2EP5E+GJEJyUVYzS/pwivYtsyaBYTs+DN6761dZZHLyLOnrv5T+80tPak/r4D9hn/BN+Y4EhhCMg+EQOU2aklvMXyr9+gHpgV/4jkHvbv4TwLFI8/fr//g81ID7LlOjh7CRGoQ5ZGYN2HzidekHt3vyTeeAT/AFP179QHrhnfQzM551mlSruvftmcE+R3ZOmLtY+vuTxxgCkskDhJl28pYA08FiRslT2xYcsU5K/GpR8Ys3JXEjM7lBnLJIHAtCvLH5VfAwUm0wJAw7d0l/fczPOrhqnfTnR3xe5Y1bfLo8pgGHOBLSQYq8/zwjLVyWtT/EEaX47l9J37jRT4xCaAQxxOs3etW6ZWPpgec8WQUfj5QefcUTWtbnBZg6HGX6KwOkjq38hDDYRvjK6EnSv5+VFi/P2p5sJQ+94FViyPTDL/nwkODTA896UnlxH6l1M68i0zFAecbfvz3hy0hryyfS2d2k3ajZbx4ew50OM+dLv/z3sXrs5nvUyQAhM8x46fKPFwCfSCr5TKpfSSRoRcWvpPiXkeJPXPyy7B8GQ8LAbIO9b5DmLuK/TBeiwRTjqNbMVkioA6QQcso2EMvsQMhH2AdiunSlD/tg+ZZth0/qAgHmtpeXswtyH2UGwyYNpNrVva1LVnjb09lNDHMg1cRFp07kwgBC1lMeceHYSodi3YacBx5iB6SeY9JpSadmF174hxGT9nzrpvwn1SHXbNJIjfkVLxSV9op+xxmZMfXLlGqDIcFTk9eosVkDLh6rkqWOZKBNJHU/xrKbHgwDKUi0OjVvy2t/uhKLBfPr6ZOhnR2xDtlZCgJuAObBFG1JQtL9cgNmY0BkjiUNYkjRZn4VfhyIYXsl605gMBgOQ9mye9Sm7WKVKZuDHG1ILPbuLVGoFKckxbMm1a8kp52LtlmSEJ19MEnnYWYM/UpmQJjBYDAYDIbjQhKJZ1Hyz1BwMFJtMBgMBoPBYDCcIIxUGwwGg+GkIgwMi8sr3GP1KUl+gaT5k3T/4jSQL+l+FXzAncFgMBgSCx6ISU09l3S/4kRmirJf+BOnwXzHmn87TjBSbTAYDIaTiqSTz6TB/Ipve8WNhCYt/3Yy7wgGg8FgKDRIetaFpCGpfoGk+5U0/zJj5peRaoPBYDCc9LzH5JxNGvAr5HROEmgr/IoLkTnW9jK/4oH9MWwvI9UGg8FgyJdcs0n1K6m+JQ1J9ytpvmXG0C+LqY4h9uzZozVr1mj9+vWuF1eyZEnVq1dPVapUcYMVcgtO1J07d2rfvn0qU6aMmxWMMnfv3q1q1aqpbNmyR8Qxsc+GDRu0detW1ahRQ+XLl3fLd+3a5faljJo1ax6THVFgy6pVq9wxGjZsqMqVKzsfFy5c6MqtWrWqTjbwEaWGuuHYFStWPCxmjXUbN27U0qVLVb16ddWpU8f5vW3bNi1YsEAVKlRQgwYNVLp06aMei7K2bNni6pP2Y9+cYsewjfbhQ/l84hJrZijaiNskDkUZcSIxx4Ok+2coOJhSHTNA8lauXKlXXnlFTz31lJ555hm9/PLLmj17tiPbx1rW/Pnz9eWXX2rt2rXu/y+++ELvvPOOli9fnu2NZ/r06XrxxRfdd3j1uWjRIr366qsaM2aM9u49/tn7tm/frnfffVe/+MUvNGzYMO3YscORzv/+97+aOnWq8gsQ6hkzZmj8+PFH1Cv+TZgwQT/96U/1/PPPO0LMNpMnT9avf/1r1y50MI4G6pdOBH698cYbjpDnZp9ly5Y5u/i2h4PBYDAYDIUDplTHDCjCs2bNcoTq2muvVf369R2hQ1VGTYWArl692imZ5cqVU+3atZ2aCUlGcUUNZd26deucmjxlyhRHjjdv3qwuXbpo06ZNbh0kmWOhnFJGVLWuVauW+82+HTt2dL+XLFnilNvevXs7Irx48WJHPjk226NoQ5hRobEz2IzCHlVbIYkcl89nn32mdu3aOZtRhrEbZRcSSyeAbSgj2AeRDeo9x0PZZnu2xSYUfZahwnO8oEhTduhUsB/2opSPHDnS1SXbN2rUyKnk2B72o65pC+oOcgzRDkoyvlOXlMv/pUqVcoo2bcLxqAu24YPNgZiznP+xo1KlSs4OysE26oFlc+bM0fDhw9W2bVvXhpTLmwZTAA2FGUnL55w0f6II98ekIsntliRkxPA8NFIdM0DmAmkj3AAyB9mChEHKIKKjRo1y5AwSPWDAADVv3lxPPvmkTj/9dPXp08cR8tdff90tnzlzpiOPqN+QVIjiihUr9OGHHx4KA6GMrl27HgrpILSB0A9UbsggZBXSDrEjZIPy33zzTUcGWXbmmWfqrLPOckruE0884Qgq+0Ewb7zxRrVs2dKFTwSwD4QRAs4xINaAiwtyjL0otZBZyjj//PPVqlUrvf/++47YYmeLFi3Ur18/58vQoUNdXRFKcs4556hXr16HfMFnOgeffPKJqzPCOdiP9WPHjnV+QfrZ74wzzjgU0gG5huBS93RAqI958+a5OqXeaR/IL8emk4J/2EknhDbi7QBlhJAPfKNOOObEiRN16qmnug4TbRneQlC32MBxWI6yzfL+/furbt26ibuhGpKVpzqJ52dS8x4H8cD8ild7JQ0ZMbx3GKmOGVBkIYyffvqpnnvuOUdQIaAQZogc5LB79+5q06aN+w1JYx/UUQgpFx5EDEIKGWZfTlgU5k6dOumDDz5wxL1bt25q3bq1I8cQQFTsQEQhshyXOOe5c+c6Qg8Bpix+oxxDTDkeKjjEkrIh7Njxla98xRHS9957z62HPPJ/ABcRijKK8bRp0xzxDOowCjiEkn1OO+00jRs3zhFslFzILXUDgYdA8xkyZIizG1WfcigzGh9NHTRr1syRXkgtpJx6u/rqq1094hfEHzWYbaNAuaZDAAnmuEEJB5SHCt+3b1/nMyEehMawnuMQE3/ZZZc5kg2pR+nHF/zo0KGDq0s6NiwPHZoRI0a4um/atKl69uzp2oR2w6843XQMRQ/HO8aisMPyOccLRaG9kvQsKBbD9jJSHcOHE2roPffc45RQlGYUWkgaxA7yyXp+swxVFMU4FWxHWZA0yCdkD3IGMUSJRvnlw3r2D73gcME2adLEKc98INEQx4EDB7p1EN+PP/7YEXeUXkg8hJrjQWoh64RDhP3SxYJDztu3b++IN4osqjmqPL9RbiH0hF5AUPEXBZl9IKGQVEgpRJ1jsC3Em+OiIkd79CjV1CH1RCcAZRwCja3szzLKQE1OBWVRD8RDU0ennHLKobAQOjjYQlw4ISB8qFveFFA2+0HmKZvlqPuTJk1y5B8yT73TYaFDQwgKNxfCQugsUXfYhjrOm4Soym8wFEYkUfVMOpLaZkn3K2n+ZcbMH3sax/QEQ6mF/EGyIJOQQQhr2Ca6LR+IGyooxJRQiEBkw0UYJc2EX/AJ056myy/L8TkeAxtRrSGBkHFIMsot+19++eWO4EL6IZkQQ5ZDCvmNTdiT7rVViBWGHKNmE54SlkOiUWpZBygPgosyDBGFnKJwExZx9tlnq3Hjxo6Iv/XWW45g33TTTYfCOFC3sZFOCKEVkHi2TVc36WyE1BIyAilGleYbUs0HxRubLrzwQjfokbqiDfAdko7doX1oQzoIdERon5CNhdAZFG22p674Dvbl5nXf3n3FtWZNVZUqffyDRwsDuKcWO3hf3Z9H6Y6DCHK09MmIrEe7pR/IPLycChV2qnz5Xc7uog7O0zCgOWkdQK5JkLQpopPqV8h5bH7FK799iRIlYnMeJusOVwQAOUX9hXxBsMhSgZoKsYPAcbMg5paTkJAD1Ew+KKIQU9RdlhPnG8gcZRJ7TFxuauaO7IhbiJ9GocWWQYMGuTATiCFlYAffHAf7uDCOtceJbZBKwh5Q3SGjEGT+h7QGQs6HdfwP0UdhRxmG4FM/kFeWoeyH/QKpxkb+DynxUIWxFcLPNvgTCD31nfo6inq/5JJLnH3YRrhIqDdU8EAiWE49ZDf9Ku1DOAvHh4yjaKNkQ/rxhbpArafe6cCwD2WyDhuwN13drl5VVW++PEg1q0lT5xydQBY2lC0tNW8snXOm1KCutHO392PEl9Kqddx0j608CHKtalKPU6XOraV9+6UvJkoTpksbNtNuh2/frb103cVSiaNEL2zYJD36qrR8tf+/Y8cFuvq6YSpRImYVfpKQ2tFPAuKWP/dYkGS/kthuUb+Scn3F9b5hpDpm4OSCqKKokhkiDJi76KKLXHzvueee60gncceEc1x88cWO7PXo0cOlqiMVHttDxFB3UZeJI0ZNhlRCKNkvqKjEDUM8oyd0NAQEpRxi17lzZ0fsKJcwiLffftul2IOwsh2EO2TkgHDzIeyE40XjLfGH5SjpkFpsIXaYY0Bq8YWYaVRfYpSxk4GHqNcsI5SD3i2EFDsITyG0I6i8lBXNH43KTpnUFyo226GQUzesY1DkSy+95EhuGKiI/xBbfAl1yH4hpzV1ht1s//nnnzubQpYSSDHbsH2I0Q5ZWog7B8TLo2wTJ892tDVtgCrOYEfsonz8otNwwQUXZDtQsUbVYrrvW6XU/hTph3+R3v9csQEdgT9+Txp0jlShrCfE3GLp961ZL/35Uenhl3PfUShZQvrKAOlnd0s1q0qlS3kSfde10uLl0vf+KA0dnUWsq1eR7r1TOq+HV8pzwt59Utky0o//Ku3aTUrGUsrMjMdDwGAwGAx5g4zMpHXZEg5IKFkqINYhhAPChhoN4UMNZR0kDAIH8WM5qilqakhzR7ND/tgGwkqZkO2gxPIbwkpZbEs5UZWWZZTFvnxD6tie5ZBzlofXbGHgIQQRpRgCCVC4AQQxKLoQ0xDDDbkOscSozhwDYhzSzqHcBuIfTVXHskBusYXOB+XhK8Q0TLASTanHJ9iAzYS3QFipM0BZwZ7QBtgfYqKD7fhHu7At9oV6CHVOpyOo49Qx+1IW7YZdHBvf2J71lEd9sD31SzuHgacsp6NCmdG0hCiuva+XZi+U2jaXPn5CqlVd+tuT0o/+olgAAv2re6Tv3UrIgCfOEFdcpLrxdM0G6YbvS8PGHr28CuWkW6+Qfn6XVOXgmNhQXlChF6+Qvv8n6b3P/DpIODZ840bulEeWySJsY3/uoh+OkK79jrR9p9ShwwLddOvHKlmyYKewnjihuZ564nxn7d/vlf7v+qN3EPIaXC8hnIBrLI6Dj4qSX+HenkS/wtvNIOwk0a+4ZctIml+mVMcMnFgQRj7pkN06SCeKcTpAILNDiNNOBSc3JC91X5ZDBqPZPKKILocgpoKLB5KYakPUjux8DLM7RgGRTnecYCvHCyEyqYDkphugmF0bUFZ0xkeODbk+GlLLitZpdral1klOCL3mOHWfz+oq3X6VJ62r10sPveBDPsqXk67uL119kQ/juO870lXfklb4vk+2INTjx3d4Qk0IySvvS+8O8+VdeYF0fi+pcT3pZ3dJ46f5MA6I9R8fkV79KH34R7my0h++K53WQdq9R3rydU+oDUUnr3PS/IlzfuBjQZLbLUnIiOF5aKTaYCgi4H5bqqRXYLlN7dnLgKSj71eqhFeHGYzHPrmJY0bcIryCwYWQU/bLLYoX86oy4RcMSvzD/6SHXswK84BcV6si9T9L6tRa6t5Zeu2jnG3p192Xhw8PPCv95gFp90Gb3hwiPX+/L69FY6lFo6zY6K3bpYkz0pd79mnSKU18ZwUiPnRU7n0sSgid16Tm0A2/k4Sk56lOGpLqV4blqTYYDIUVXdpKr/5Lat3ME91xU6T/vih9Oc0P2Es3SPCCs6SvXys1a+gJ5rhp0tNvSHVrSiMn+MGCAPLcrYNXdJetku64WhrQx4ddQDjv+pW0eWvu7CQ2uWVj/xtySxx4NG56yzbp6Td9rDOdhDbNfShGdo8U50cvH1LCgMLn3soi1GDbDumVD6Rze0jly0qnd5Q+G5ezjWVKS1+9UqpYwXcYHn9V2pRL/4oikhJCkArzK16w9ooXisXwvmFKtcFQRNC7q1erg/jUvKF0Xk/pX89If338cAW6ckXpH/ceHCRYzqu9CCHtWkqXnuNJ5fip0vXf9+EZ/XtLj/zOk9sdO6V6tT3B5lh1akjjr5T++VTu0uHVriHVOxjZMm1uFnGPYtYCafM2rz53buMJc7qOAUBlr3ow6ohtINGpWLvB2469fU6X/vZEzrZ2auU7HOxDNpL3hx/dr6KM1Dz3SYH5FS9Ye8UPmTF7Y2Kk2mBIMKL5nSHGqKrEH0N4Ia5k2PjxnV7mZSAjCnaNKtIfvy9de7EPxWDM0vI1UplSfsBjtcq+3Eb1yBHuy4bcEuMcAIdiwCRkdd5i6cV3c59fGpU6kGBUb7JppILsHyvX+ONiB+o2Sno6QPJRywntqFBeOrWdtGRlpI4kdW0vFYtEKOR0D0cdv+1KqUpFX19PvC6tP3J+JUMRyFMd/Epi3uMk+hVSu5pf8cD+GOYVT9YdzmAwHAaIdCDVENGf/1Ma8oVXb28Y6DNboErf9RXp9SHS3EVS3zOlqy70hHrhMun3D0mfjvHq9E2XSvdc7wf4ubIPvp2LhvNBnt/+xMdCQ+AZGJjb0A8A8Q0huKvXpR9gSZlbDpJoYrf5ZEeq6Uh8NFK69DwfCvLTr/uBheSnZr8Lekp3XJVVTzt2ZR9KAgg3GdjXE+/ZC6TBQ+I1CLQgEMd8s0dDEvMdByTZryS2W5LzVGfGzC8j1QZDggHB5cMzZPBQr6oG/P5/PhsGadZQrM/tLi1Z4TNhQKBRiH/7oPTsW4fvc053qWs7P8gxhIxwvwvPqZnzpW/8Nn3YRm4QwjBA8RzuUC6OOjOLDOeET0ZLw8f5uGkGN75wv7R0lVfsG9b16nOw32X6yOaZyyDPWy/3Cjn+P/WmT+2XHRL27DYYDAZDDjBSbTAkGBs3S8+/I1WqIH0y5vB1xBc/8rLEXDguzGOfJ9Or1vr0cKjLpJ1LVX1f+1CaMtsr3yE+mclTAmEfNfH4CTWYs8iXVbK4V4KzI6sfj5RmLvAhIunipKNAMb/1J9LXrpEakCY9ByJOqEh2E8qg0HOsJ9/w9UNYSzrivGFjRY0d01rFihfsjIpLF+cu7aLBYDAYThw2+YvBkDAQx3z2DdLcxQVtiaEw4c8/kL59c8FN/sLrW2Kq4/IatyhP/hIm3TC/Cj/iOklKUv1Kxl3AYDAcQsXy0rUDfEiDwQAIeel7RsHURRxzzR6LX0n2LWl+hfZKGpJ6HhaLoV+mVBsMCQShGX1u8mEdqJNM4DJjvp9EJYRK1Kgq3XWd1KS+j58mtR5Tm5PTmVkGefaMm+pDHUIGDvJTf+cWnyGEWOI/P+qzfPToIt1+pbTvgA8dYRDgieCq/t6OMNnLc2/78BRA/Dc+1a0h7drjJ3PBN1CpvHTWaT66Y+REH/4CGJD4lYv97IfkvX5nWFbYBoST2RvLl5GWrZbuf+LIgZXUxQ2D/IQvhIa88K6P084OXdr4/N7EYOcWmZFAbv8IyZsHSUYxn3ubrCoF8WxKHRQWpwdkUfYrDA4zv+I3CDgJbZYZU78sptpgSCDczInFpTo1PRnkf1LjndXNx1iTgu6WyzwZBpNmZaWFIwUdOZjJL33tRVLvbtJbn/isHLdd4Qcpcm8jLR2Tx0CqmRzmhks88f183ImT6nlLpL/08Gn/LjtP6nmqNGysV+Eh/L26+QGKZPUI8dvlyki//bYnyOD5t6Xv/MF3ImpXl355jy/v4r7SGZ18XDhE85qL/IQ4kOXf/Cd9FpFGdaV775SaN/Lx2X95LGf7Gfz4lYGezBcWxOB5ZChEiAOBOR6YX/FCRszOQyPVBkMCwSBEl/nj4LeboryUdGFv/4li+jzpm7/z5Bgwa+K99/tc1ZDRK/v7T0C4x1F2GNDHd5hYhqnATxSTZkr3Py797tueSN98mf9EQbq/n/wty246Du1bZqnDrZodzKO9wxPvtz/1syDSWfjh7YeXhShC2sD/vZR+kCJZQ5o28Nsx++L8JTnbz/EY5Enqwlwjk7rzB8/LV9RkKkGhL8hwoGje4yQhyX7FLT9wbmB+xQv7Y3geGqk2GBIGMnQ8M1havMITThRb1OatOzzpDOQKRfrz8T5tHmEeAYR6kNUCYk6oR8dTPDmEbG7f6VXt+rWkh1+W1m/0+zBl+fufeVI98ssT9wHySrq6GtWkay70CjOZSSDsW7f5QZh/esSrzQHY9tpHUrNGnqCSK5ttQ5388X+eoDNjIpPYkDqPDse6jdKUWdK9f8t+EpdRk6TRk30dPPbq0SeyGTtFuva7x+N53sd7lisr/fab0tevKxhizUORQX0gbvGRRdEvEPxKGixPdbyQGcM81RZTbTAkPPsHsxOSUg/SCbmGoEIKSYMHqc4pHR1Thp/VVapby4ePMDkMSjazJy5f7SdhiW7Lbe9E0umlgvsox0JpJaSCGGryYE+d7f1JBSEghKJAyglPSQ3lgEijOHdp68vdtFWaMMPP+gjxzskOQkCoKzoqccs/zWySw572bZTfSGqWjKT6BYHZy8WeQL+i2SSS8nYhrlkykuqXkWqDIWGA9PW+3g86rFxlm3r0mK6SJQ/O0mIoMti3r7i+GNlOmzZV0ClNpM+f86Eg+Y2kks+k+mWkOl6IK/lMql8W/mEwJBiVKu5Q7z5TVabMnoI2xZDP2L27pKZObepItcFwLIC8JG0q7yjiQM4M8YSRaoMh4cgQ8WgFbYWhqCLkPA6/k4Kk+gVCKr2k+pU0JLW9ihUrFqt4amCk2mAwGAwnFUkJjUiF+RUvJLUTlFS/MmLYWTBSbTAYDIaTijg9FI8F5le8YO0VL2TE8L6RTPnAYDAYDIUq32zI6ZwkmF/xG1wach8nCeZX4YGRaoPBYDCc9HzOfJJEZpLqF0i6X0lD0tsrM0Z+Gak2GAwGg8FQZBAnkmaIF4xUGwwGg8FgMBgMJwgj1QaDwWAwGIoM4jgAzhAPWPaPQoAwt326i/5EL/5Qbmqux+zKzc6O4znmsZQRrYOordml08nOr2M95rHuFz1uTvvltn6jy/OqzQ2GwpoWK4l5quOWRzc3CH4lDUlrp4CkPjsyYuiXkeoCRLhpbdy4UVOnTtWKFStcUH716tXVpUsX1ahRw03PeSJgpPO8efNc+Z06dVLz5s1zzK2KTcuXL3fHrVu37nEdc9OmTVq2bJlq1qzpPkfzgWPu3r1bs2bN0ty5c93v0qVLq0WLFjrllFNUvnz5I/Zh+tKZM2e6fRs3bqwtW7aoTJkyru5S/Qv1nO7CXLNmjdauXas6deqoWrVquSLV69ev18SJE903/3PM008/3fm5bt06V29ly5bNtoxdu3Zp1apV7niVKlXS9u3bNWfOHGfD8da5wVCYcaL3scKKpOepjhOZyQ3Mr3ihWAzPQyPVBQwI1pQpU/TRRx85gsXDZ+fOnWrWrJkja1EFNyfFNl2PjnWUT9nvvPOOrrnmGtWqVUuVK1c+QnEN+0FWR4wYoXLlymnAgAGHPQzTKTJRNSOs27t3r7Zu3XroONn5EH7v2bNH06dPd3byG3LMxUQ59erVc7ak7s+6sWPHuk4D60ePHu1I6VlnneUIeTr1P52/HG/btm3uO4zmD1P0prOVbcePH+/qqGLFis5OlrVt29Z9Dxs2TAMHDlT9+vXTHpPfdKI+/vhjde/eXe3atXM+0CmoUqXKoe2za/N09R2nG46h6CKJ52kSfUryNOVFwa8knZMZMWwvI9UFDMgn6ixE8NZbb3WqLASvZMmSTsGcPXu2U7ABBLNDhw6OUKKUcrJBxvhu3769GjZsqFKlSh0qO6yfP3++U0BRoPlABleuXKlFixa59RBvCD3EkGNCDCHXEEaWQVqxA0UX4te6dWunQC9cuNCVXaJECe3YscMdH/sA+3JBoDovXbrU7Y89+ICtQckNJBNCDZm+6qqrnK3YtHr1alc2CjbHorNRtWpVdezY0dkEGaUuFi9erM8++8yViT8o8ijGGzZscPUBucdn6pFjcRwUcDou4RUu39QHdlIO23Gszp07u/3DjYoy6QA0aNBAl19+uWsvfAdDhw7Vu+++636feuqpTkFHgcYWjoHyzn6TJ0/WBx984FRyjkO90XnhGNQ7+yxYsMD5RhktW7Z0vlMHbE/d4EObNm3UqFGjxN1IDclD6KwmTdkN6b6SpsSbX/Fsrzgqu7n1Ky4+Gaku6AYoUcIRPwjk559/rqZNmzqiBMkljAISDJmCLBLCUaFCBUe4X375ZUcsIXwQLQgjJK927dqHyoagsS+EvV+/fo4MUh4hIBD5V1991RFIyCPHh1Cj9m7evNkRxSVLlrh1kL9x48Y5IgdJhpD36dPH2TtkyBCddtppjjhiH6SbjgIEs0ePHk4Zh2ii4nJRTJo0yT2AINbYBTgeZPb22293vuMfvlEWHQzIPH6wHWVzkUGcAb+xm+XUEQQbkvr22287kkxYBqSUcliHL5RD+AV1TKdg1KhR6tu3r6vD559/3oXe4D/1B3r27Hmos8I3dmPPyJEjHTHneBB82oGy6USgVPOmgTqkziHCdA4uvvhi165sFzo5+Pvee+85lZ1j0sGgPlk+bdo013b8fu2111w5dDpoL3y58sorXV0ZDIUV4Q0QSFJcNX6FCW3i9NBPKpnJDZLuV5Kur7j6lSzZIIaA2EEQUX4JKXj99dc1ePBgRwAh3BC2Jk2aOIIGSYS4QvhCLPFXvvIV9e/f3xE2YnxT45QhsWzXtWvXQwo1hI6HASfsmWee6cgsZBoyiJIMCe3Vq5duuukmd1wIOET8rrvucoQTFRWyiHoK8YXMX3LJJe64xG+jsEIOIYBh22uvvVbXX3+9swGCHtTdEKIC6aWDAHkMFxA3PuqAjgJ1gMoLccWn4CsEHdvojJxzzjlO7Uddpzz2GzRokFvOesrgQ7l0MIIazIe6wGY6DnQGbrjhBkeMCc2hrAA6Gd26dXN20amA6NJedBpQp1GPr7vuOl1wwQWuQ8HxODb1OGbMGFf/qPmo/ZdddpkuvfRSZyfHCO1F3RBC8tWvftXZRZvTccBOOiN33HGH85F6haDH7fWYwWAo3Ej6PSXp/hkKDqZUFzAghcTVoj6ifk6YMMF9UEQJPSD2FtIJ0YJYodoSRgD5g0wymBFCx3pIV0AIq6AsiCBhCqifLIOYQSzDwDjILOQYUkkZ2AS5RZFF/WVbCC3bQDQho5BabKQMPpBCVHRsCbHBLMMuOg4QTMqlk4AqHbUVgsoxIJWQyOgrYog75BUCCbAHP1gercNgM/USyqSDgL2BRA8fPtyRdRReOhUQUraLgsGDqM/hLQDHjc7ARfl0UCDLdCCoX+xjPzoM2EG9cUz2JZQGv/CX42E/dc52QfUO/nIc2pf2or5pW8plf/zlf/zBLrahHkLnxGAwGAwGQ8HCSHUBIyi6EFLIGsQJooSiCXGCgH7729922xKaEAaxQcQgkXxD0FKn8oTEQfogtpC5kCkDBZzMHIR9QChDLCDf2BJiHwHbsx3LIIOsD4P6WM4+lBGNS44S0EB08Y8P/1MOhDUa+wUZhZhjI2QVIskxiF+mI4GyjRqPQvzSSy+5MlKnmg0poAIpD8fmN2WhOLMMJfvLL790BBt/Ukl1tF75pB6HeqV9aJszzjjDvWEgFANb8Su0A/7iD4QYJT/EbEPmQz2lDqZkOWXQYaGeqRfINMuwKdpeUSKeEw5kZmjnrtLuO86IvvnLK5EplJlTeW6TXFZdKIdyS5bcp+LFuZZO3E6DwWAwxANGqgsYkCZCN4itRQWFUBEfjJoM0UbNRGWFGEK0oynXcooxCqEEENELL7zQ7QdBfeihh9yxIO/pQJmQWo5FOAq/IZAQRIgdg+ggeSjOEPRUREliSHHHfp988skh9ZasF2GgIsejfGKaCY9gf2yDvEJAUY0hl0GpRiWnXqLHoVyUcGKiGbDYqlWrw0ZC82EfyC/KMvWJYn88rwCpQwYaQuzxC2UZck6ITVDo6QTwNoHj0m7ERUOyOSag/lCoCevgDUKILYcwExZCPDoKN/XCucCgSuw/HqxZXVXPPnmxKpTL1Jr1UtxeenKGV6sidWot1a0p7dotzV8izV4o7dx9fGWWKSWd0kRq0UTav0+aPk9atFza58NjD0PDOlLv03jzkXOZm7ZIn46Rtmzz/7drt1gXXTxGxYvHrcbzHpanOn5Iep7quMTn5hbmV+GBkepCcPMKqiYKKESNmGYGrUEqie8lphkSSvwz8bmQLeJyQw5owitQuQkLiF5k/A8hgwCzPwSdciF3EFUIHKSZMigXIgt5Y+AhhJoMI2yPDfwPIeWY/E8YAoSXY6CgUh52Ux4fYouJFYbMn3vuuYcIM8spP5rHGWJJmaiudAQg7qwnRpkyGKiHLdQRhJll1AE2sw/+UzeozxBeiDwhNWxDPeA3AxYDIcZHBh8SHkJ9h3oAZBahMxDi2dk3qmZTXkiDyDfr8YdYc9qL49ABYDnlMiAShZr6IU4dJR676FjQmYLgE1PPcQn5wD/aB3/Zl3WUybnBOhR9zhnqP3QWckKFsiV05+XV1LGV9KO/SlNmKzaoUE665wbp2gFS0/pS2TLS/gOewM6YJ/3lMemD4bkvj+do3zOkn3xdat1MqlEFJV9atVaaMEP6xb98udHj/983pa8MPFwpTwfI/i//Lf3rGd4+STVrbNaBA7wxScPUiyCSlh0jIGnZTAKSlkUiwPyK330jM2aTK2VkJrE7GhOE1/8onSFPMoDEhVzLLGd9CLEI8cMQYLbjA7EME6aEhxfLIH2sD4P/KC8Mygv/h5CCMBgvlBfsgRyGEApII79ZFmxgG44bBvoFO/kdbI36F3xLHc3L/pQXtgtkmO1DrDdgeQg7CSPv09kctRUEG0J4SBgECdg2lMHvoByHcJhgb3Z2Ur/hOLQDZYTwk2i9hboK9R3SFrJdCEXhw7pQt6HsUL/B99COIVQlWpcbNku9r/dq7lldpbcfksqXk/72pPSjvygWwJ07rpL+9AOpfNkjSS2XytzF0lXflGbMP3p5pUpK5/WU/n6v1KR++nCSsVOkb/xOmjyLdvak+oGf545UU8YXE6WBX5e2bpc6dFigm279WCVLFhyp3rWrpP7z70u0dEktp8x//pxU3b9MyVfkxSythRHmV7xg7RVfjpQRo+wfplQXIMKJAmmK5peOIruZ+aLqKUQrNa0aRCt1WThWOgQiGcqDrGV3vOz2iapR0e1z8i9qL+VFy4yWnW55ah2k2hwF67Jbn93ydDbnZGe69kpXbyAMqExnQ7ryo52A7GxLi5MQi5wfaN9S+tEdnlBv3ym995k0fLxUsbx0yTnSaR2klo2l+74j3foTr17nhHYtsgg1avf4qdJHI3hLIl14ltS6uXR6R+mvP5Su+660ZoO0bYf0839KH41MH/4BUf/aNVLnNl6dfuEdv4/hSITY/6Qpu+ZXvFAU2ituyu7RCHU0eUEc/DJSbTAUIXBPCvelo4xxPAzunpbpwyVyvQ/HyfBkPvMY97vjaqlBHX+8/zwr/eZBac/BhDHPvS298k9PrPudKfXoLL33efbl4e/Zp/v4aMyA/H73D9KmrX79v5+RXvq7dEYnH7vdtKEn1WDpKun5d9KXy7a//ob/zVuBN4fEq+OS3/mckzb5S3jgx01Jyw3Mr3ghmqggSdfY/v37Y3d9Gak2GIoImjaQ/vwDqU1zsphIY6dKz78tLVmZngwWLyZ1bC3dcpnUvJG0dZvfZ/AQqXIlad5iH+oQgArMPus2SoPOkS46W6pU3scr//5/0s5dubOzdCmv/nIPXbteevatLEINVqyRHntV6tbex1mjQudEqsuU9rbwIoWBhP99IYtQg+WrPXHu2s4r4V3aSmMm52xjyRK+XmpUlfbuk558I4uIG47+KjcpSGr0ZFL9Kir+GQoORqoNhiKCi/t40huEDGKMr7lQ+sPD0svvH06sIaLfu1W6/SqpTk2pRHG/HrJ82xVStcrShyOk7//Jx3D36CI98AuvMvN/VwhvaU+Mu3eRlqzwRDg3SnfNaj7TB5g6V1q2+shtJs7whL5yRalTG+8XYR3ZkfSGdb0tDChcuebIbcgogmnUzXk9pIdfylnJb9FYuuJ8X+bCZdJrH5pKbTAYDEUdRqoNhgQDkhuEQWKAGdu5easnj6iybQ/GGmcekF77yBNTBuh98ybpx3d6Qgq5JGaZuGJinMmcAXp19dtColGyO5xyOLGEwBIPjRI+anLu0/lRVhhQt3i5tCONwr1qnbRyrSfVzRr6TgDHSofdu6U5C6XmDb39EOJUos4yiDkoV8bXW3acmg7GTZdItWr4+npmsLRibS6dMxgMBkNiYaTaYEgwIIBh/CiD6FBgBw/1ZPn2K73yTAjDb74ljZzoQyF6nupVaraBTKMwvzPME+ivXikN6OMJOsQ8dQIV/uf3pFnSXx+V5i7xZSxalntSjT0cG5BbO51ijC9hcGKF8j4MJDtSTT7rdz+Tzu3hs6D84KuelKMwuxCXVn7AYfCFcnKytXF96aoLPfFetEJ66d1ji08vikhiHt04xXkeK5LuV9L8M78KD4xUGwwJBkrqwcyDbiDdvfdnhWAQN8zvay7ygwIZ9Pfiu9IFZ3kCTUaLPz4i/fOprNCK0ZOlT57yRJRyD4VzRJ5Ri1dIN3xfmrPo+GyODmzcsy/7bQKR5ffRnpHDxkiz5ksdWnly/fETPoUeE8Gc3kmqXCGrjJyKgoR/5WKpQW1/fAY9osQbskdIg5lEBL+SRtKS6lecskgcC5KU9SPufhmpNhgSDMhwIKirUX0jEixhFU+9KV1+Pin9PNkc8oWPKXaDBDdKr35weKwyIR2Ej4SyA7Ete1BZ5lgQWHJIHy8Y0BjKrV09S/2OAmWa8BXAoMvdPs16toDg3/Rj6dHfSae2lerUkAb1O5LIcyzqJTvlmc7HdRd7lX7ZwQGO6WK5d+woo8WLaqt4iYLLU71nTwnt3p19msn8RJweiscC8yteSHJ7JU2tzkjxJy5+Gak2GBKGY0lht3yVJ6WEc1Sp6L+JKeb+tXHz4dk9cgIZMABkdNy0Exu0BwHeuMUPVqxf24eCQOajqMVgxlr+N0rxjmxCP6JgtsSv/9Ir8/3P8mrzvgPSwqX+eOd090r0uKnp7Sfc46r+UrMGvnNCh4MBjumwYEFd/fc/A1XQ2L/fK3O4U5AJD4pCfuAkIal+hQw0SfYrbsru0XyKm19Gqg2GhAFiTM7leSmEL939qF5tr1JDuEgzB3kNE5hUqSRVquAJ59HK2XdQkOVZnBuCmxOYNpy0eZBq0uWhVhNSEkXLJn6QInZPnpl95o8oeKNNPulf/FP6+5NSi0bS3v0+NeDvvu0JNf5Pj0xVHgXq9g2DvEpNTDYDFIPfqcjMzND+/YUj5AG/unfy50VB5nMGSSIzUb+SFl+d1DzVccx7XJT9OnDgQOzuHUaqDYaEgXjoX94jjfjyYHxwRlaqOjJ4ECsNUKQhieRcJnyCmQPJ5PHJaJ/ho1Z16YoLDo+pJk0eRNsVm+benRdiKOEX85f6vNGkwiMc5fHXskJXGGyI3QzCJH/1zPlZKixZQCDL2IaKHDKHQCyvvVA6r5f0xGvSsLHS2oN5pcke0vcM/xv/GayZCly95FypVTN/rLeGSjMXZO8DZaKGH1MocSBpGajikVGgJ4JM3zm57cqscJmCzAscF7WpqOc7TqpfSffPrq+Ch5FqgyFhgLMw8A4CDImGfIJBfaXV3/KDESGfX71Curq/X0d88GdjfRjHxyOlGy7xZZBWj3LeHSYx6/1d1/rJY0DJSNl5CQj8U29I5/fwavlP7/JEmk4CKfGuGeAJK5gxXxo1yf9Gib3rOumHt3sS/J/npb88Ku3a48NIfvUNT9I7tJT+/JgPB2FCHGZvhIiDtz9NH9JRo5p082WenEO8iUUPnZN0QGH//XeYcj73fh84kKn9SN8ZGSpRoliecOpoWsUEcVmDwWAolDBSbTAkEKi6IUNGGHRHuMR3bs5KHxdip1Fsf/egtHqd3w6S+p/npG/f7OOsf3a39L3bPDljgGB4C+fKzkyTUi8P7Gew49NvSv93vSfEf/iezzeNgBsmlYHc/uwffipxAOFmgpuQ45qBl8yeCKlev0maPNuT6van+AGLqNx0DEL6vulzpb89kRUfHsW53X0ebsCkN5Nn5Ww/aflQ20PZuQH1uX9/husQFC9x7CQYVbx+Ld9GBoPBYMh/GKk2GBIGyNnwcX5CEsI6IMmEUvCbHNCEhwRFeP5i6Zf/kt4YkkW+iaH+0yN+AOPXr/ODAgkdgDiTRm/5Gk+2h47y034DVN8Qi8zvEwXE9v4npPp1pIt6e3KKWg0QcxlE+dfHvQ3RfNRMo85sjmDKLGnb9iyS++sHfHx2p9ZSqVJZMcaQ66UrpR//zeeuTgdiqAkLgeiS6zs6bXo6fD5e6nfzsXqdcUK3ZGy7cZBX5EOITmFB3Ebw5wZJi1+NIql+Jd2/pPmVkZERu1CdjMy4WWwwGHIEyvP5t0nT5mbNUNiwjifLV17g08JBqBmg99J7PntGyGUdRemSXtUlrrperYPxy/P8RCqETXw5XVq30W/LvRyyyvekGXmjVgPIPOEmTKnetL5XnSfNlD4d46c+T1WV6QCc1c13AMipzYDHAB431atKp3WQ+pzuY8apk+HjpdGTDqYczGbAI2EuZ3b26QSJ4c5ugGJBg3Cfp/4oXX2hCg1SByom5cGfZL+iWRfMr3i1F0hCm2XG1C8j1QZDwkBYRO/rfaaLsuV2qWWLFSpePDz8Dw6ey/Tp5Jie/Gg4bJ/9BZOajbCPEsU8Wc8pljm3CD75kAvFGtTJ2jWVtXx5Tff/i3/zHaHCglTdJg4PxtzA/IoXrL3i3WYZMblvWPiHwZBgVK++RVdfN0xlyhxldhRDbEH6vuGfdzhEqnOcErKAH45xeTDmFuZXvGB5quODTMtTbTAYChtclG7x/SpRIheStCGWgK8WK3agUD8cyaMLShCfkiAEv5jWO0kdhqT6ldT820n3C1ieaoPBYDAYEpqnOihpSUSS/Upiu0X9Ssr1BeLYVvGYosZgMBgMBoPBYCjEMFJtMBgMBoPBYDCcIIxUGwwGg+GkI2nxniBp/iTdr6Lin6HgkKxRIwaDwWAodASGAW9J9CtO+XOPBeZXPNsrLoP5cgvuG3GLEzdSbTAYDIaTiqQ97APMr3ghye2VxPSOGZGZWOPiVzLPMIPBYDAUqtRYYfbBJCGpfkVni0wSkuxXNMNOErOaZMbEL1OqC+CC3r1792F5QEuXLp0n08FS/p49e7R3715XJjlhcyqT7fft2+eOfTzHD/5QBsfKTRnhmNRBeK3DviVLlnTLAb9PhqIQ7KXuKf9Ec7CGCx1fgu2UV6pUKefDsZQdbItODRyXnrnBcCzTeScJSfUrPJ+Sdh9Kej7npPpVPEbhY0aq8wmBgC1cuFCffvqpli1b5v5v0qSJzj33XNWvX/+ET5ydO3fq888/18iRI3XppZeqU6dOOU62ABGcPHmyqlatqmbNmh3XMZcvX+58atq0aa58wMZJkyY5G7dt2+bIJ3aeeuqpmj59utvmtNNOczadDGDv0qVLVbduXVf3J3ID4oJfvXq1hg0bptmzZ7v/q1Spoh49ejifypUrd0xlcU5s377d2UY5uUESX/kZkoek56lOkl8gLqrgsSJuqmdukfQ81Zkx8stIdT5i8+bNGjdunJYsWaKuXbs6wlu2bFlHRCFVKMzRmcdQPFmO+gz4HZTQVJWVkw5C9sknnzjS2rhxY/epXr26KxMCHVVCKQOC+/HHH6t58+aqU6eOU7cBdrAt2wXVmP2DGksZwT6IY82aNQ8RyKCUR30AwdYVK1bo/fffV8OGDdWmTRtXdqVKlVzZCxYscLa2bNnS7RcUbPZlPeWGXmsol+NFX+eFumE5ZbEv60NZ2FmjRg1VqFDBlRnqO/jL/nyzPNRD6P2HdfzGjg0bNrj6W7RokfOlYsWKbh/ageOzPd/ROmdflO1Qj3xYzvFmzJjhCH/37t2dndgc2i7UOT6EtwNBAQz1HJebjsFgMBgMSYSR6nwEyuyqVasciTzrrLMccQokcd26dRoxYoTmz5/vyBEkrV+/fo64vffee444sQ3fffv2Vfv27Q+RYAD5Wrt2rdsewg5xX7NmjSpXruwU4C+//NKReog0JLhPnz5uPcccP3682xebIGmjRo1y/6OY9uzZ0ynQbEc5HBM/Onbs6Oxbv369Zs2adWiULseZMGGCI5H4wHHwN2Dr1q1avHix+vfv78oIxHHHjh3uG4L63HPPuW3Z/+yzz1b58uVdZwQ7IayQ7l69ejki+c477zifATbgA/t99NFHTkHH3i1btrj6QkGmDufOneuUddZjL/vhb61atXTOOeeoQYMGrh2GDh3q7Apk/IILLnCdAWzGV1TvMWPGaNCgQc4etqF+qR/KnDJlikaPHu3qvVq1aq6+qPtXXnnF+bpr1y7nD3WMak69jx071pHrCy+8UK1bt3Z1O23aNEfOW7VqpTPPPFObNm3SxIkTXbkAVfyMM85I3BTQBoPBYDDECckKBCvkQMmEXEGSHn74YX344YdOuQ0qKKQOwoiKCjGF/EECIWYomJA9yBXhI4FQBUDQIGBs07t3b7ceAo8qSljBZ5995ggzqvTUqVMdQeY4kO5GjRo5Aof6SfgIJPWUU05xtkGmKQd7IIko2tgKqYOUEv6AP3xTJqEQ9erVc36yD6p5UNpDHQRi+fTTTzsiie3UASovx4bMcxxUd45BBwGCC7klTIVjUzadAvyibiC7EFTqiu2xCRIOqSaUhO35YCekFZ/Yj+0hwdQbJPmLL75w9cU3tkC+IeVDhgxxxDu8NsQn2oY6g+xC/PEhKOEbN2509kN0sY19OdbKlStdB2HOnDmuHiDfEGnsos7owFBe7dq1XWgOYSWUR51S/2xLGYTP0D4tWrRw25pKbTAY8gpJv58k3T9DwcFIdT4CQomied555zlyBoFFlYWMQtIgb5BIyPTMmTMd8WI5RA1VF3X39NNPd9ugoKaGfkA2IYGQZAgaqi/kjhsI/6NmUgZkDsJIaAjkFaUTIg5BhIzz/8CBA9WuXTunREPeUJ5D/DfKKmQQEhpCL1BoIaMAlfX88893ZDCorAEQ5quuusqRdkjx22+/rRdeeOGQCg+5Rd2mjiDZkE3qAR+puwEDBrhtIM74EGKyOSZ2YS/r8JnwF1T9Sy65xNlLnaaO/A71QrmQXxRq/MA3ll900UUuxjuQ5oAQlhPCVEAIE8FuyoGYQ+D5jTrPb9qY7enEUJehAwSxDyEx+Amx5ryAPHM+UAb/Uw7txLnEOYGST0cpaQOlDMnLU32iA4MLG5LqF8iLgdyFEeZXvFAshuehvS/ORwRiirIIoUTFRaklBAEFFtW1bdu2KlOmzKHQAMgk/0N+ib9GXU6NI4ZkQQJRNiGUkDeIN0pshw4d3HEh0IRhQEIhiCGGG4QTFqKOsot6DVnkmxM6LMcO9sUO/sfGENtMWXzoALCeY7I/inDUVtYzKBFFHrKOaosKHeykbtiG3xwPpZ3jQCI5NsdDeYaEUw/YwaA+jglBZj+2ByzHBspjv7A8CuoE8s82waeQzYPjhHpIJdUQY5bRmaB+ogOWqAdIMvvhJ22Hf9jHsbCRtxK0JZ8QIx0QYrYpg3YjdAU7+EaZpqOEb5QVBobG6aZjKHpIaqfP/IoXikJ7JelZUCyG7WWkOh8BAQtKJYotpBn1FCKHIss6YoIh3KiSxN2GUa/Rkyt19DLlEvqBQo3CGbJ5DB8+3IUKhIFyqaQtxHND6CCoEDVsYR9sgfRiA+Wlu2ijNkCAIbbsh1qMTfgUQhwCIKAshxCiqkMQIdXRdEDRmwL7QixRvAmhgFyjJGMTpJY6pEMRVaghs5SHH6wL5Bxym3rDSZ0Vjf0guuxDedQj5WBn1F/akA4ARJmQDOoO2/Af/yiD/yHTnTt3PmwQZzhm8DW0RRiESBvwTfmU06VLl0PhLezHMUIaxGh7GAyFFUnNUmN+xQtFob3ilCkjie1lpDofAdEkRIOYZk4SCCakkYGFIbf0yy+/7H5DwAJxiuaADv9HTzLKgZwTNkDYBQSPkAKIIKQSYsZxAgljf/7nmxAJ9iUEAwLI/yje8+bNc0opoRXE+UL4osQ3vPYM9kCoCelgv2efffZQVgp8iw6oZJAdAy8DQeQb0ohyy75RcEz2Re1FfWfwIYot+5AhA2KNDXRAqDNUcUJWIOt0KCDh7MPgSOyD3EKuQ32GOgg+BV/wl2OGTC10LkA0wwbfxDkTwsHbBmLksRWb2Ze6oINDjDmx1OyLbSjNof5DOSGrBx0Qjjl48GDXfrQHceAvvfSSU9Ih+oSkhH3i2Is3FE2ETDxxyjebG4SMSkkbJBzNDxwnQnM0mF/xwoEYnofJuhMUckDsIGKQvBCPi7oMeUKdRDFG5WQ7CDLKKkoocb0olRAvvq+44gq3PADFlthcCBvhDJAtlrEfRB4yBskLgwyJPQ5hFJBCVO4QksA2fBOvDMmDCHIs9gGc3PiAoh7CIyCT2MWxL774Yje4LoS6cNzoAwe7IJuo8eF/joEqC2EEKLxcQMR1Q/KxiZhp7MQf6ozYY+qRbVnPsVCViTMOIRbEXkNwIdKsI7QGUo+9HC+o12xP3QZFmHXEUWMDBJ7j0FHhE1WHOTbZOPAB8s0NgA4MPnNs6oLBhSjLlE+5qOhkC8EHlnF84tz5n3VkCOEc4Fj4Th3T2eD8oH5DHDwkm7cdRqwNcco1mxeTXBXGSW2SpA6CJM46CJKYozqu+ZyT6ldGZhLPsEKIaMxttMqj4Q7pTp50r3NSZ05K3S8aUhBFathGTv+nO0bqNtn9jm4btSm6Pt02OR0j1S6+CQN58MEHXYcCYhrKgiz/85//dGT35ptvdgQ09ThHOwaDI1GZeQsAKaYjcd111x0i/Nm1aWr4Srp12bVnurpPnVwind2pN5sNm6Xe10uzF0oNG67R/31jsMqU9fHzhuSBU+SzYR315uu93P8v/l264nwVGkTHDCTpDUtS/QrjQpLoV8jvH960JtGvpHRcM2PqlynV+YTsCFC6bY62PN3/uVl2LOUdyz7Z/c7u2HlhFxcaai7hLii60QuOBwFKeggfSb0Yc2NvGKCIyo/KjYqdOkPi8bZpbusyp7LjcHMxGAwGg6EowUi1IbYgHIL0e6kEk14tYRnHSz7Zh7hsQkpSB4oamTUYDElH9C1ZEmH3ccPJgpFqQ6xviule4eWkhue2XLvpGgx5g6R2SpPqV/QemjS/aK8kdhaCX0ltr4wY+WWk2mAwGAwnFUmJX02F+RUvJCU+PBXmV+FBMs8wg8FgMBQaJD3rQtJgfsUL1l6FB0aqDQaDwXDSM2UkMU2b+RXP9kpaRwifwmRxSUJmZmbs/DJSbTAYDIaTns85aWQmqX5FfUuqX0lDaqrapODAwXMwTn5ZTLXBkGDsP1BMW7eV0569ewraFMNJQ4Z27Spl9WvIM8SJxBwPku6foeBgpNpgSCDCI2P1qqr6z78uUUaGPUSSClp2966Shy8wGAwGQ77DSLXBkDRkSvVrSXMWSvv3F9emTRUK2iJDPqFKJan84XMUGQwGgyGfYNOUGwwJA2825y3O1K8ekFauJTgAxCfPZ07IjMiwSfIr1bvj8Y1sYbddKV15gVSyROEbbBRS0MUp52xR94tUbUlJ15Z0v8J03knJL54ZU7+MVBsMCQQ3oj17pb17Azcr/Dej3CEzK7whUX6duG/FMqQypT25Lszxq3F4MOYG5le8UFTaKym+ZcbUr0KkZxgMhrxEqZL+A2JwL8oVuM9GZ9hKil/J9y0zNg/FY0FS/QJxm8kutzC/4oXMmJ2HhUzTMBgMeYUkpo+KpjFLGoJv4RV1kpDUNkuqX5yDSfQrqSkQza/CAyPVBkNCEbf8nkWdVIOk5zxOkm+Wpzp+SOq9w0h14YGRaoPBYDCcdCSJUCcdSW+rpPtnKDgYqTYYDAaDwWAwGE4QRqoNBoPBYDAYDIYThGX/MBgSijiNmD4Wn5KSXzYdkuhbtM2SdE4m1a+knocg5DpOWnsl1a9ixYq5ePE4+WV5qg2GBKKo5GRNil9J9s38ihesveKFuOZzTqpfRqoNBoPBYDAYDIYTRDLf8RgMBoPBYDAYDPkII9UGg8FgMBgMBsMJwki1wWAwGAwGg8FwgjBSbTAYDAaDwWAwnCAspZ7BkDAwanrfvn3auHGj+5QoUULVqlVT5cqVC1WqLOzcsmWL1q1bpz179jgba9asecjGMPp7+/btWrt2rdumfPnybptSpUq5/zds2ODKKFmypFvO+lDu+vXrXTqmKlWquLKph/zyi+Nu3rzZ2UdblC5d2tlQsWLFw/zbuXOn1qxZo927d6ts2bKqVauW25Z9sB8/ihcvrho1aqhChQpu9PvWrVtdnbENbVq9enXnf374BTg+Nu/fv9/VadWqVV0dR/3asWOH24Y2KleunPOLNsNmbKcM/KLN8AuENmMbyuSTH36l+sj5hu2hPbAzrNu1a5dWr17t2qtMmTKqXbu2ay/qAttpc+qB9qKtQ3uxbu/eva69OA/wKz8zGeDTihUrDk3RjW9169Y9VL/4hn1cZ9u2bTvietq0aZO7l7A/9tPe1AvtTHtyHtOOnIvUS375FtoEu7GB8zGcU7RDuBcGv1LPueg1Gs45yqAs/MI/zl/akzrLD7+o43D90CZhGbaFax2/OOewkesmnHOVKlVy27MMv9iftgrXEuct+1AX+EN5tHF+tdf+/fvducSHOscG2iOcM6G9srtH5NReXGOc57QXfvFdENlCjFQbDAlCID48QN99911NmzbN3bhOP/10XXTRRYeIWWGxdfr06Xr99de1aNEinXfeebr11lsd+Qrggfnll186X7jJNmzYUIMGDdIpp5yiJUuW6I033nD78mA4++yz1bdvX/fg+OijjzRq1Cj3MGrdurUuu+wy1alTJ986Fdg9btw4DRky5BDh6N69u84999xDN3sI55QpUzR48GD3kIGgXXLJJWrTpo0jbvg2b948Vx89e/Z0+2L/p59+quHDh7tjNG/e3PnWuHHjfPGN+pw9e7ZrM/ziQd2lSxcNGDDAPdDxi+UTJkzQ22+/7R7e1PsVV1zhbF21apVeffVV12b4RXv17t3b7ffxxx9r9OjRzi/ajHZu1KhRvp6vtAnn27PPPqtWrVrpzjvvPERUOK9orzfffNM93HlwX3755c5WHvSvvfaa5s6d69oBn/ANwk17jRw50j3wW7ZsqYEDB7q64PzPL9/mzJmj+++/3xF9CAzny0033eQIciA7ixcvdm2zbNkyt82FF16oM844w6177733XJtSP507d3b3EsjO+PHjXbtBaCDpF198sTp27OjIUH74xrnCPe6DDz5wxJm24rzBBnzgfF2+fLnza+HChe58Pf/88931hH0ffvihxo4d68rp0KGD86tevXqaNGmSu4dwvnJdUhddu3Z1BO5k+0V9c2/jGqNesQ0fuDdceuml7rzDL2xjG65H6rtfv37uHoiPn3zyib744gt3znE/wa8mTZocqivamHKoC+5L+dHJy8zMdNcN9zvu+xB+zkeuIeqe+wF+YVu493H98Fzo1auXK4P7KX5xLbJP//791aBBA02dOtW1Jc892ot75Zlnnpkv7ZUKI9UGQ8JAL56bFg/J66+/3t1oJk+erHbt2jkCkF+KbW7Ag5ib5rBhw5y6kpqblBssDzhISPv27d2DnW0hAzwgIKM33nijli5dqs8//9xtw417zJgxuuCCCxyBhRDMmjXLKTb8nx/gRt60aVNde+217sEBqcIm7OPhxkOQhyIErn79+o5oQdh4GEJWsHflypW65pprnEKIz23btnVtB6GGFPDwgLjOmDHjMDXnZALCCDH86le/6nzEfogVJCacW/iFr5BSOj+0HzbT8eE8pHN09dVXOyI6YsQINWvWzNUH5Cb4xUOVOuA35Cg/wAOd84jOEA98zq2g7ALUMx7otB/XEu2F/ajPEBvW08GhU/HZZ5+59ueco6MAIWM/CDntRZvnl18AYkbbcT7RUeHYnJcBtAn1H7bhnoFvEEwIDPeTPn36OGXwrbfecm0GEeOao6ML2YPU0NaUD2E72eBewbkG0aKuIWcICBDrcI9D8cUv2vPKK690JJVzE7/YBjIGqeR//OKewnnK+co9hk4CnaKJEye69uN8PNnALo51yy23uLqnM/DII4+4e2W4f7Gc645OK+cc39iIH/jPdUZnl/sm9wjaBX84fyGqt99+u/vNPmzDfvnRWVi1apW7viD5XANcD9Q55wz3MPzCLq67q666ym3PdcYbI+yjc0hHDyI9dOhQVwe0F9+c03fccYc7b2lzOhP5cR6movC8CzYYDHkCSCVKJzdRSBxkjBstN6TwOrEwgJskN9ZOnTq5h1W6mzoPdx6EkBIeEjzAUQO52UK4IXgQHAgcQN1ABeXBgd/cWFHl5s+f7x48+QVu8DwYIZsQEPwLr3VDx4HXu/h36qmnOvWvRYsWzjfajgcp+wUfIDAsww8IKMtYxwORzhME8GQjtA8kMrQXyiUPyyhoL9rgtNNOc35hK0QSv/AvtBnnJkoaKhznJp2C4BcPTZbnh18BnB8QeWwKylkU2ML5FdqLtoVM4xffEDv84nyGHNC2LIfocX6yjvOXc5c6KqgZICFt1HUIawH4jO90jPALH6l/bMUHQgtoF9qM9g9tFt6WhA47HUA6g/kBzjvqnnMNUga54kNnIfiGfTNnznQ20i6ck+yDjfiFL+Fc5H4Z/OU6De3JOcm5wf0m3YQkJ6OdIM9cA7zl4VyCUOMj9zXAdcc1xfmEX7yJpJPKOcc1xv7BLwgp9xr8ovNEOayjPSmH+0d++BUNjcMnnkW0IffK0AliGR04ngucgxBo/MJG/OJa4vzEZ9qadmQ55y/3T/zi/oJfqP3RTnF+ofBIVgaDIU+AUsbDBJUMMsYDlE+IiSws4OGBfTwoslNJeJjhCw91tuNhgRLPjZYHBA8+yuBmy02WV8DcsHlYcrMOscyQAG60+eVX8A2gYPJAxhb8CGEatBMPg+Ab9tM+IeaQhwTELqiKEDH25Tf+Uj77BnKTX+DByIPs6aefdvXNww+SHfzCFvwK8Zqch3T08Be/ePDhEz7wYR0fOn78j8+0WdgnP/zh4Y5PfCAokKvUY3P+cM5hG+ch37xdYTuuLTpR2A+hYz3r2Idrj3oIYxsgOJC2/ATnF4TlxRdfdO1Bp+Ccc85xyjPtFpR57AvXEsu5/mhjrid8om3Yn/aljigX//CN9qb+qKP8QBhTwfX1/vvvu3bkPEQFDUp6GFsS3lJxfdE+2M9+XEv4yrZsQ7vgF/+zLrQZ+9Ge+Qn8of5R0yGK0XsH5yu+Q5qxn7rAVvzi+sPXYD9tR9tCuLkvcZ0Ff/mf6yw/SHWxYsXcOULbELYCsB0CHRT4cP/jnML+EOuPX3w437Cf85BtwnkIQpw/6/nOL7+O8DPfj2gwGE4qwo0kSlQLSxz18SLYHwhruvVhoEthmGY5OqiP15koLcQF8oAO9qS2U9TOdPG2QeVJt31+guNC+HmFTEwjD34ISmqHLWpnaJdUv6Lrsmvb/AAdFl5DQ0h4WNNufHgwB7/StVdOfoGwb0G3GUTm+9//vu666y7XaeAVPIogHdCA7GK8091PQDgXC8qnMNCXT4jrh4ARehN9w5Fd2+TkV1hekP5hB8R5wYIF7i0ApDGK7O4fuW3H/PYr8+AActqLUJ2vfe1rLuyEtz9cZ6l2Rm3M6R6R7horyOedkWqDIWFAaaJHz40KpQb1hR59Ycv+kR2CIgjBCcplGMnODZkbJg8YVA5UKHwMqi9KCOvYn3KCAofqkd+ZJLCJeFrijlFzefWM7ZBQ1gW1Ft+wNSijKC188A37IT7sg6oIKce38PoU36iH8Fr4ZCI87HiIQTx5fYzqjCrEgxF7aTPaC+WJ//GJB2lQ14Nqhr/4wLmJr6hw+MX2tCfbhPM4P0D98rqYmH3iVxlMRewt8booy2FQJnWNbUF1px5ox6DG4xO+4RfriBPlN5+Q+QCf8C2/QLtR/4S0hDajzokfxx6uG+4LoW3wgXbEXvzlmgptwzlHe4bMKGzL/sE3lFH2yQ/QHlwT1DG+hfEKvBUKGS4AfmEzPoXzK2SICG3DMrahLfGL/9k/nIvUT36MWYgCW1H+OS5qLv5iK3bRppxz/GYZvtE2IaNHuB/SLrQd++IX1y7/B3/DuZEfJHT37t3uGsMmzkE6QijwKM2EcWAv9nBuhmdWOKdoL9qRMoL9rGddiHPn+gv+8p1ffqXCwj8MhoSBmw8khRhJyA4PGYgbI6IL0yDFoDSFtFA8FFAMIWPEQRILzQOTBycDbdgeXwj5INYQlYMBOcQZE1fJ/sROcnNlcBG+czMmFplX3fn1UAzhBJBpRtoTD0lMLQ8CFGsG3rAMgowf+AYRxY8wGArfGXDDMtqOemId7Ue2BXzjoRLCFWjz/AAPtUCKsSU8DFnGgFDiHXmYEQ/KICjs5jzEf9qStiMWlHai3SGYtCOkJfjLA5WHL9kzUtW5kwXag0G9DBjl/GFgKQ974k8h1tiPLbQB5xxtjLKNYg9Z4RtCTnvgM/7QtuzDoDf8ArQ/nauQdSM/EIgUBAy78Iv/IRzYho34hw9hcCjXGd/4BskhBAHfIGycj926dXODULnOuPbYln3DOZ0fgChyXI4XUjwSqsJ5SWeW6x7yhp3UP8SUcw4f2C9k+SB8KqQGZFvqgnORtkIlxi/IKvvnZ6pA2oh6R6WmXiHOvPXim+sMO7GPeyVtSztRF3xz7RFDTTnEkNPhoBwG9NGZoj7wiw5xfmXYKVasmGszri/OQf6n3bAhXG9hfAzherxJ4f7C+UnsODbSptw/uOfgM+0FMcdf6oIPvlF22Ce/UXiesAaDIU/AjQtFipvLo48+6ggbqkAgZYUF3PB5aKAKQkB5KIacsBBriBk3fFQoYiYZ0c1DA+LDNtyAeaCgLKIw9ejRwz0sIZgow4wsh1DgNw+U/FQHeXBAvvjwoOfhAKHEPh4MEEyIHO1C1gG2C9kGWEf7Qdqeeuop12YQMeqDhwWDdyB6EFse9NRDfqmDHJMHGNlI+M0DkQc2fvHA5zd+QfRJg8iykHqO5cTy8rB/8skn3XlKto/w8GPwUfArtFl+ZMgIA8MIkQCce3TuWEZHjAc+hJN24RyjvQifgLyQeQFyxjUGSXnuuedcndBGtDfnHG0MScM3fKVt8/NcpDMHIeY6g4zgL50aPthFx4aOEDa//PLLeuKJJ5w/dMKxl+uSbbkGKYt24UO70n5krKE+OH/JEJJfHYYw0JnUadhGhw8/OPe4L9B2tGHw65lnnnFtg420DdcSpAz7OefCAFrsp51pr3//+9+O1BHmRPvnd750OjDYyz0N4k9nmt+0GX5C/F944QXnC+Fl+MA1Q/tw7dHpwVeuLcQJ6oJUgQ888ICrK8SG7AaJ5zVKlSrl7OM6494MaB/8495OBw7bOafI/sOYjZAqMAxEpwPEvYfzkLZjADvnIdcYfoX2CuMFCoJUZ2QWRCS3wWA4aeCS5iEBmUOlgLxARrn5REf8FwY7IS8MoOEBAiAqdAZQMMg3C3lGxUa5QKFhPeSSmy8PUcgqD56gePLAoVyWsQ5STRk8OFKzOZzs+scv/AhhJxBf/IB8kYIMm3hQogqGcAFIDISL/UOWCEg1vvGQAKjClMODBQIAWc2v8I8wMQPnFWSLOuVhiA+ontddd52rb9oTRYw2Cn7RZqFewqREkKKgRoc24xihzfIr/CMK3niEUBY6RzysSY3INRTaCzUaQoBfYfAsfuEDBCe0F79DRgzqIupXfk64gR/YjZ3UO3bgH+nWyFVMpyGkFAyTKeEb1xvtHu4llIX9EEzKQS3Eb7659jgX83syEXzDBtotZDXBL8gamTsAvodQAu4f4c1OOJepF87jMLFU8Au1GPKJX/kZThAmUKI9uEbCQPPnn3/eEWOUas4t7gMs5zfbBSLJfYP7B9cbPoVJpcLAvhC6xDlNXeSXX/v27XP1Tb2H8CLq9ZVXXnF+QZLxPfgV7hHh3sd+2E85wa/QXiznXCiI9orCSLXBYCg04IYaYnHDZC1xH2SZOvkBD2pu+vk1QUZ+ACJGu/EALExvQ04UYRBmiGlNEsJsnvlN8k826LxAsCBd+TULYn4AgkznLL9nQTzZ2Lt3r+vAQJzDREtxhpFqg8FgMBgMBoPhBFH4UwEYDAaDwWAwGAyFHEaqDQaDwWAwGAyGE4SRaoPBYDAYDAaD4QRhpNpgMBgMBoPBYDhBGKk2GAwGg8FgMBhOEEaqDQaDwWAwGAyGE4SRaoPBYDAYDAaD4QRhpNpgMBgMBoPBYDhBGKk2GAwGg8FgMBhOEEaqDQaDwWAwGAyGE4SRaoPBYDAYDAaD4QRhpNpgMBgMBoPBYDhBGKk2GAwGg8FgMBhOEEaqDQaDwWAwGAyGE4SRaoPBYDAYDAaD4QRhpNpgMBgMBoPBYDhBGKk2GAwGg8FgMBhOEEaqDQaDwWAwGAyGE0SJEy3AYDAYDIbCgszMzEPffDIyMg59koD89i8cJ+51GertwIED7rtYsWI5+pHObxBH3w35ByPVBoPBEBNEH/SBGCTxQR/1MXynIieis3r1ao0bN07r1q3Tqaeeqvbt26t48eLHZUPq8VNJ5cms+9Q6CMfatm2bJk6cqBkzZqhNmzbq0aOHSpYseVKOv2fPHo0fP17z5s3TaaedppYtW6pECU8dovWT2haF7Zzct2+f5s+fr7Fjx7pzoU+fPqpfv3622+/fv/9QHXP+dOzY8ZDfBkN2sDPEYDAYYgDIy5YtW/TJJ59o+fLlKlOmjHr37q2mTZueFEJVkNi7d68mT56sqVOnOgKZCkgRfnfr1k01a9Y8op42bNigL774wpGoKlWqqG3btsdMqrdv365p06Zp0qRJjliyf+nSpVW1alV37FatWqlcuXKHlMxjRSoZzW6bmTNnOlJbrVo1R2pr1aqlHTt2uPp5//33nW2nn376SSPVK1eu1FNPPaXZs2erdu3aatGihWsfSDaEc/369W7bChUquHqB5FPnhQ3YPGXKFP3rX/9SqVKlnK05kWoUbXx84oknXL1Xr15djRs3zlebDfGDkWqDwWCIAVDa5s6dq7/97W9OQYO4/OhHP9JXvvIVR7hAOoKXjrxF1dectk/dN6f9ovtHt0+3XTqbor/xdfr06XrjjTec6rx27VpHlCGxkMqKFSvqrLPOcsSoRo0ah44TlFO2GTBggDZt2uTIL4Q4+io/nW2pdtKB+eijj/Tf//7Xratbt64jWvyGpA8aNEjnnXeea4fUsnOq96id6eo1ug/HQ3H/61//6vzAL/yFwPbq1cuRwtCpipaRHWHPqW3Tbb97927XqYCMQpabNGni3o7MmjVLTz75pD7//HOn6HJ86phOzm233XaoTo5mT27WH21dah1mtx0fbKUTEm2D1PoP++NP586dVa9ePY0cOdLVd8OGDY8aNmIo2jBSbTAYDIUcPPRRJ7/88kstW7bMPdi3bt2q4cOHO2JXuXJlLVmyxJFt1FSUS5Q1FO0JEyY4EgDhYRnqLQrc5s2bndqN8sgr/fLlyzvSDolCyYO4Qmbr1KmjZs2aufKXLl2qXbt2OcIB2YBcsp7y16xZ49RTQi6wh/0XLVrklN2+ffs6QgwxRt1csWKFI86ozLxaRwHl1XogK5A07KWcjRs3OkX2s88+c3YMHDjQKYYQSsp47733nJpNx4I6wnYIMKQYUo291BWqM75TB2wDWYf8tWvXTo0aNUpLligfYksdXX311dq5c6dGjRqloUOHunZg/65duzqSSf1AcCkPMkrbcNx+/fq5Yw4bNsz5DTHFJpTwLl26uG1RgdmWY1WqVMkRaHyl/lCpaQfq/M0333Rtynp8pm4g2iFMAxtQtvEbH/GLNqJM2oU6RLFt0KCB+5/6oh0JkWGb1A4A/o4YMcKp0djKsTgOyz788EPXfueff76re2yhzTmnANth/5w5cw7Zg0+nnHKKOxa+cs5gL2o4dU35nA/YxD7UK+ccZXEM/Kb+8IF17EtZZcuWdWVxDPYPHQ3K4Jyk3vmfNuM4XCPBRsrhvKf+OQc5TiDT1BNl0eYci/MYHw2G7GCk2mAwGGIASDBkBiJw5plnuoc84REQFx7+EIcHH3zQEbb77rvPEWuUxP/85z+OhEI0Fy5cqBdeeMERDbYDKJA33nijunfvrjFjxuj+++93ih6qHKQLhY4P5JXjsYwPRBGied111zmi8vbbb+uZZ55xBAziAyCEnTp1ch8I2uuvv+62g9BxDIj8BRdcoOuvv94dL5A6yA12QcAgn4sXL3ZlQRLpRHTo0MGRMsgOPlMXEDb245v1EEiWf+Mb33CEHkL67LPPOpJER2DBggVu+8svv1w33XSTI1HpFEi2of7YDpIPAV21apUji0OGDHEdAhR1iP+ll17q6hky949//MPZDfnH/0cffdSRcToLkEBIPP5D9KkTSDL1ig3ESN98882OBNLJoYNAu7/11luuMwARpwP10ksvufrHX9r26aefdmEvkE5AndJGF198sTtP/vznPzvyCWnkeNhHh+pb3/qWU/6xJwraDMLPsak3CCXHpo1pF+qaemvdurWrB9ZTBm3LOca5RrtxrkHS6ZzwZoWOBucA9cZ5hU0Q3ebNm7tzgQ7Ep59+qldeecXZSJ2wnnAn1nPuffzxx3r44Yddp406pkOBnbyhuOeee9xytiF8gzKoC9oS8h9s5Bx47LHH3HUFOAYk/Tvf+Y7zC5LOtUV7UX/YyVsCU6oN2cFItcFgMBRyQJIgBqitPOAvueQSRxB4LY96DWkLBAcijfoGCWIdKuBFF13k9oOEQS4hlRAYVECIIUQB8gA5hkhBCiG1qJAor6h3lA8RhCCh7EHqKBMCCBl87rnn/r+9+1exIuvCMO5clYGBgQYaiooGBgoiimBmYOItmJgJxiIaGAje3Qy/gtXU1Jw+fN31zXTP9PPA4XTXqf1v7d36rrVX7XONsCGYCBgCknAjwrxEx6UMiLQSgQQMwagcYUco6QeIFsLKa/KZXdO+iKOXvk40ldBUx61btxYhPtv8+sp2BLjfJ3KtfeMl6Aha0dy7d++eRDDXTLsTvVe/aKj5YGfict2WPmnPmPVNX1zzu3sJZDZjf3PEdvrjcxFpOwvmSFT25s2biwhnO2JdlJ6zZD6IVfVr2w6AyPH3798Xh4aINhe/fv1aPid69c392tcnjpk2pdkQsNbQWlQbg/mbKLOxW3PKsoH+cGrMp9+1cf369SVyDw4AUSxdxdxYh6L1bMz2diwIWra5ffv2Yg/tGBuH5fPnzyfryXrlJHHK9OPhw4fLeDia+slOHJ+vX78uzo3xsytRb42pwzq2e2DMsH7MH0fSmNShHfNIkMO8+5ldOBJsEXGMRHVExCWG6LA17T9//6kTt04i8LMoonxPIoIoIWqIXScc2EonTgjVSUkgIgiw2a4nPIgIAkfUbnKGCbMHDx4sYpzQmWihNpXXH0JEtNFnBI6oMGHz7NmzRXDpt/ZATBJvIq/uVV7bhI06OAc3btw4EdVnQb9EkEUonz59eiLWD0UTiXGR5pcvXy79Ft0nYo1fBPyQqN4yDyxiBPtp87aFLbUj73gEHAeFLYlOdhmRzFFwD8FPSIrGKktki5iux+deNtQ3KQrGxwFzjc2Nbx7KI3I5ZXYm2N/n7KDdLfplfMTlnDRjDHYurB8iWXkCn3NG+L59+3bp96w1fbduxvmwZs2P9WYO5Ka/efNmWTOT6/zjx4+l79bt8+fPlyg4B87zBHLMORfTF86He9hOZNq7nQS21YY5F90271JTOCgwHo6cvrK9vw/1+TvS3vqEHXZlC6+IYySqIyIuMevTLCbKSGATUoQDsSqFgNgmqkU5CQ/liCViwmdEAxFIuBA6hIMX0SbC7Zo6QWwQOYTM5NB+/PhxERiiqrbI/aw+YgkEGgFD4IrsqW+EGGGmr97dIxeXgNYuwSJyedbTOQbjkdtsLCPKT3uYzHXCSjqIPnpnT7Y57ei+Ne4VTZYKAP1X3/SdDdwjwuvnLTNWwlbUV8qGlBmOkWgvuxDsYy91HIrSj10H8zC57sZl3rz0jcic9Au4RmBPqoa6zfHWOXB9bMQ+6zpc53SJMFt71uOXL1+Wdce5Mg+TgmKtzFoTzebsKT9t6qc14x2uKzvrSXn3q3O9jvRl1tLkaBPFovGzO2Iu2ERZ4/A+x+J5t/alz/jbIsRFut3/4sWLJd1Hn6xvdbLXeZy+uFokqiMiLjFEhogbseI/d5G2T58+LaJjcnCJGhFM4plwEaWUfkE4OA5MLrJooagcAeKhM+kORIjrRIsoM4EEwmLEBxEjkkd0KCcqTgxOFJrAI4qIJuJf9JJwFDGfrXZCTv3EL6Fy586dJfVB3bbwJxp7XvR1hO2xfFe2ZD8RVQ6ESL52j4l6wsy45AjD+OSWczxEbKUHzGkXxLYorGjsHDV3qK9sRgSyq5ffpWOwA3tIexgBa46Ix3nIU7tbAawP7GsdiPAS6frAqZqj4GY+J7Vmfd72IYfCZ4SotcNm6rLe9EV0X7Rcu+ZTeofdj3kgkNCdtSZVRmTcGrDWvLuf/X1uDqSuWLv6pew4ddqQmuJnqUwcDvexyfR/Oxa4pg59Mg/sQRyrg33N+aS3aE9eP4dVhJwD6e/HOdbW9OwgcETcWz51HCNRHRFxiSECRNIIAHnOtveJWNE8wkmeqNxWkTUCxrY+IUIIeSCNUCP6iBm5pbbrCQdixjViQxliZVh/gYd75Eh7EXuieYTmRCLdQ7QR6fKT5cISYvK1Cf8RZwS5vFUCR241waMOAujVq1dLpPbvRltSDvSRqCMC2fPYOc+EOJHlwUO24lyIUBNi7GkcovdEJEdiTmoh0g7VObYlpJVhO3NFrBPlcpTX9xJz5oZY12/tm6+1sFaPcRD+BK851ldz57o0CuM+C9ommNlGegdHQl2EpbUjf5vTRKAaKwEsV9x6s1bcy/lSVtsT9bVzwqHi7HGuOAJsK4JNxBLgRLeHPuVHy7sWITZfylpn2wcqD82zOZJjzxmRt+9vyC7DPKBrDXMi7RSwKafDmvW3Yv1qQ1lzou/STC7j+dtxuUhUR0RccogKDw1K75DnLEI4eczzZSATXXaPPFW5usSXHNERx6LMhAERTqQQdh5QE3FVDzFBiBAkxOKUk+9M+BKNE0UkgolGok85easij4Q30a88cUec6Jc6X79+vZTjDOgzQUaseJ2Wz6ysz6UaiMJrA/oujYKQ43isT+9gn/miFAJu0iWMhcD0MB1BJRrJrvq0jVS7V3vEM/Gof8Sr9og7NiEC57SOJ0+eLPaZL0FhE4JcH0RWzYvxuj4PYRrX48ePF5vaheAEuTbf4kfMeX/06NFSD8fKWFw3DqLU59rUH7Yizglc/Sf2jW/KcgLgd3UYN7sSsRyfLeqwhohbgp04Nma7IgQyZ4Cg1n/tE9Jsq5x2jZcTJdqLcfrMlfatB46itTonjBDk3p1+4j4ODSGsnBNK2HoelpRjrk7tsYH29cuatDacNGL9+TuxHjl12tKvSbXRX20oN+lQ5twatttjl8g9/k7Wxz5GHOK33/+XRLKIiLgQCAiCS9SXOCMgCCv/dE8KiJ+JIiL3tPvhPmKcgJmHroi7STFY5+auc4XnNAvl5sGtiUK7z88ieoQ6oUJEybH1wOT9+/evvXv3bhE5k7885z+ri1BRZrbxt+izPs0pINsc5smxJdImMqwd172rWyTyw4cPy2kQxJovzZmUEZ8rt217xjyRTUy6gfsnBWHdx4neq3tOJyHqlCHaXDNPyg7GpZ3JN/c+ZynPmc+TI6y+sZd7lFWXsW/nVt/U5152dm3y3/VBn2ZO/ayOrWOhTmL827dvS+qEUzc4B3Mqy8zj2GVseWytrW03Yxi7zfwa49h/TlSZdeo1p6ko694Zv/EpZ3yur+dlu26V8b5uY20zv//8+XN5+JFYnxN0EtVxjER1RETswgkeUj8cUTfHj4liOpfYmcHOF54H0f5piCMR1hHVTt54//79wchs/JV5OJCANYdrZ+K/zAjy2aUYB+cqjD3OT+kfERGxi8m7tn0+36h47969JcInsjmC5KKYnFjb/1IdznvSyFVEhJcDctWckIlmX5QzGP9OilRHRMQu5stV5stOCBLb78T0RUc258tY9E3kUZ/mKLmIiP8nieqIiIiIiJ38+QT5iIiIiIg4M4nqiIiIiIidJKojIiIiInaSqI6IiIiI2EmiOiIiIiJiJ4nqiIiIiIidJKojIiIiInaSqI6IiIiI2EmiOiIiIiJiJ4nqiIiIiIidJKojIiIiInaSqI6IiIiI2EmiOiIiIiJiJ4nqiIiIiIidJKojIiIiInaSqI6IiIiI2EmiOiIiIiLi2j7+ANBpJe7cCbN8AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "from ultralytics import YOLO\n", + "import os\n", + "\n", + "# 1. Load your trained model (You only need to run this line once)\n", + "model_path = \"./train2/weights/best.pt\" \n", + "model = YOLO(model_path)\n", + "\n", + "def test_single_chart(image_path, confidence=0.5):\n", + " if not os.path.exists(image_path):\n", + " print(f\"❌ Error: Could not find image at {image_path}\")\n", + " return\n", + "\n", + " print(f\"🔍 Analyzing: {image_path}\")\n", + " \n", + " # --- THE INFERENCE STEP ---\n", + " # Run the model on your specific image\n", + " results = model(image_path, conf=0.8, imgsz=1024)\n", + " \n", + " # Extract the image with the predicted boxes drawn on it\n", + " annotated_img = results[0].plot() \n", + " \n", + " # Convert from BGR (OpenCV) to RGB (Matplotlib) so colors look correct\n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " # Display the result beautifully\n", + " plt.figure(figsize=(10, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " plt.title(\"STEM Sight Prediction\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + "# ==========================================\n", + "# 👇 PASTE YOUR IMAGE PATH HERE 👇\n", + "# ==========================================\n", + "my_image_path = \"./Real_Test_Graph/hbar2.png\" \n", + "\n", + "# Run the test!\n", + "test_single_chart(my_image_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "6029a846-0550-47e0-bba9-b1fe52722f6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🚀 Processing: ./Real_Test_Graph/hbar2.png\n", + "📊 Chart Type Detected: HBAR_CATEGORICAL\n", + "📏 Extracting Horizontal Bar Widths...\n", + " Bar 1 (Top-to-Bottom): 752.1 pixels wide\n", + " Bar 2 (Top-to-Bottom): 490.1 pixels wide\n", + " Bar 3 (Top-to-Bottom): 485.9 pixels wide\n", + " Bar 4 (Top-to-Bottom): 468.8 pixels wide\n", + " Bar 5 (Top-to-Bottom): 446.4 pixels wide\n", + " Bar 6 (Top-to-Bottom): 443.1 pixels wide\n", + " Bar 7 (Top-to-Bottom): 420.3 pixels wide\n", + " Bar 8 (Top-to-Bottom): 340.2 pixels wide\n", + " Bar 9 (Top-to-Bottom): 290.2 pixels wide\n", + " Bar 10 (Top-to-Bottom): 264.0 pixels wide\n", + " Bar 11 (Top-to-Bottom): 263.4 pixels wide\n", + " Bar 12 (Top-to-Bottom): 258.6 pixels wide\n", + " Bar 13 (Top-to-Bottom): 256.5 pixels wide\n", + " Bar 14 (Top-to-Bottom): 254.5 pixels wide\n", + " Bar 15 (Top-to-Bottom): 244.4 pixels wide\n" + ] + } + ], + "source": [ + "import torch\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "\n", + "# ==========================================\n", + "# 1. LOAD THE CLASSIFIER (Chart Type)\n", + "# ==========================================\n", + "classifier = models.resnet18() \n", + "num_ftrs = classifier.fc.in_features\n", + "\n", + "# --- THE FIX ---\n", + "# Your saved weights expect 5 output classes, not 2!\n", + "classifier.fc = torch.nn.Linear(num_ftrs, 5) \n", + "\n", + "# Now it will load perfectly\n", + "classifier.load_state_dict(torch.load('graph_classifier_real.pth', map_location='cpu'))\n", + "classifier.eval()\n", + "\n", + "# --- CRITICAL STEP ---\n", + "# You must update this list to match the EXACT order of the 5 classes you used during training!\n", + "# I am guessing based on the dataset, but if this order is wrong, it will call a pie chart a bar chart.\n", + "CLASS_NAMES = ['vbar_categorical', 'hbar_categorical', 'line', 'pie', 'dot_line']\n", + "\n", + "# Standard image transformation for PyTorch classifiers\n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# ==========================================\n", + "# 2. LOAD YOLO (Bar Detector)\n", + "# ==========================================\n", + "yolo_model = YOLO(\"./train2/weights/best.pt\")\n", + "\n", + "# ==========================================\n", + "# 3. THE EXTRACTION PIPELINE\n", + "# ==========================================\n", + "def extract_chart_data(image_path):\n", + " print(f\"\\n🚀 Processing: {image_path}\")\n", + " \n", + " # --- STEP A: Classify the Chart ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " img_tensor = transform(img_pil).unsqueeze(0)\n", + " \n", + " with torch.no_grad():\n", + " outputs = classifier(img_tensor)\n", + " _, predicted = torch.max(outputs, 1)\n", + " chart_type = CLASS_NAMES[predicted.item()]\n", + " \n", + " print(f\"📊 Chart Type Detected: {chart_type.upper()}\")\n", + "\n", + " # --- STEP B: Detect the Bars (Lowered conf/imgsz for accuracy) ---\n", + " results = yolo_model(image_path, conf=0.8, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy() # [x1, y1, x2, y2]\n", + " \n", + " if len(boxes) == 0:\n", + " print(\"❌ No bars detected in this image.\")\n", + " return []\n", + "\n", + " # --- STEP C: Mathematical Extraction & Sorting ---\n", + " extracted_data = []\n", + " \n", + " # Use 'in' to catch both 'hbar' and 'hbar_categorical' safely\n", + " if 'vbar' in chart_type.lower():\n", + " print(\"📏 Extracting Vertical Bar Heights...\")\n", + " # Vertical: Sort left-to-right (by x1)\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[0])\n", + " for idx, box in enumerate(sorted_boxes):\n", + " x1, y1, x2, y2 = box\n", + " pixel_height = y2 - y1\n", + " extracted_data.append(pixel_height)\n", + " print(f\" Bar {idx+1} (Left-to-Right): {pixel_height:.1f} pixels tall\")\n", + " \n", + " elif 'hbar' in chart_type.lower():\n", + " print(\"📏 Extracting Horizontal Bar Widths...\")\n", + " # Horizontal: Sort top-to-bottom (by y1)\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[1])\n", + " for idx, box in enumerate(sorted_boxes):\n", + " x1, y1, x2, y2 = box\n", + " pixel_width = x2 - x1\n", + " extracted_data.append(pixel_width)\n", + " print(f\" Bar {idx+1} (Top-to-Bottom): {pixel_width:.1f} pixels wide\")\n", + " \n", + " else:\n", + " print(f\"⚠️ YOLO extraction is currently only for bars. Detected: {chart_type}\")\n", + "\n", + " return extracted_data\n", + "\n", + "# Run it on your test image!\n", + "my_image = \"./Real_Test_Graph/hbar2.png\" \n", + "pixel_values = extract_chart_data(my_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "a3e06f8f-c31c-44e8-ab3d-4cdc6e6e56e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up STEM Sight AI Models...\n", + "\n", + "🚀 Analyzing: ./Real_Test_Graph/hbar2.png\n", + "----------------------------------------\n", + "📊 Type Detected: HBAR_CATEGORICAL\n", + "\n", + "📈 FINAL EXTRACTED DATA:\n", + " University and Emerson: 7072\n", + " Califomia Ave Caltrain Station: 4609\n", + " Redwood City Public Library: 4569\n", + " Park at Olive: 4408\n", + " San Jose Civic Center: 4197\n", + " Rengstorff Avenue / California Street: 4167\n", + " Redwood City Medical Center: 3952\n", + " Palo Alto Caltrain Station: 3198\n", + " San Mateo County Center: 2729\n", + " Broadway at Main: 2482\n", + " Cowper at University: 2477\n", + " Redwood City Caltrain Station: 2431\n", + " South Van Ness at Market: 2411\n", + " San Antonio Caltrain Station: 2392\n", + " San Antonio Shopping Center: 2298\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "from PIL import Image\n", + "from ultralytics import YOLO\n", + "import easyocr\n", + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "import os\n", + "\n", + "# Suppress annoying Mac/MPS warnings to keep the terminal clean\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# ==========================================\n", + "# 1. LOAD ALL AI MODELS\n", + "# ==========================================\n", + "print(\"🧠 Booting up STEM Sight AI Models...\")\n", + "\n", + "# A. Chart Classifier\n", + "classifier = models.resnet18() \n", + "classifier.fc = torch.nn.Linear(classifier.fc.in_features, 5) \n", + "classifier.load_state_dict(torch.load('graph_classifier_real.pth', map_location='cpu'))\n", + "classifier.eval()\n", + "CLASS_NAMES = ['vbar_categorical', 'hbar_categorical', 'line', 'pie', 'dot_line'] \n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# B. YOLO Bar Detector\n", + "yolo_model = YOLO(\"./train2/weights/best.pt\") # Update path if needed\n", + "\n", + "# C. OCR Text Reader\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "\n", + "# ==========================================\n", + "# 2. THE EXTRACTION ENGINE\n", + "# ==========================================\n", + "def extract_full_chart_data(image_path):\n", + " print(f\"\\n🚀 Analyzing: {image_path}\")\n", + " print(\"-\" * 40)\n", + " \n", + " # --- STEP 1: Classify Chart Type ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " img_tensor = transform(img_pil).unsqueeze(0)\n", + " with torch.no_grad():\n", + " outputs = classifier(img_tensor)\n", + " _, predicted = torch.max(outputs, 1)\n", + " chart_type = CLASS_NAMES[predicted.item()]\n", + " print(f\"📊 Type Detected: {chart_type.upper()}\")\n", + "\n", + " # --- STEP 2: Detect Bars (YOLO) ---\n", + " results = yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + " \n", + " if len(boxes) == 0:\n", + " print(\"❌ No bars detected.\")\n", + " return\n", + " \n", + " # --- STEP 3: Read Text & Numbers (OCR) ---\n", + " ocr_results = ocr_reader.readtext(image_path)\n", + " numbers = []\n", + " text_labels = []\n", + " \n", + " for (bbox, text, prob) in ocr_results:\n", + " # Calculate center coordinates of the text box\n", + " cx = (bbox[0][0] + bbox[1][0]) / 2\n", + " cy = (bbox[0][1] + bbox[2][1]) / 2\n", + " clean_text = text.replace(',', '').replace('.', '').strip()\n", + " \n", + " if clean_text.isdigit():\n", + " numbers.append({'val': float(clean_text), 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + "\n", + " # --- STEP 4: Process based on Chart Type ---\n", + " final_data = []\n", + " \n", + " if 'hbar' in chart_type.lower():\n", + " # Calculate Scale Ratio from X-axis numbers \n", + " axis_nums = sorted([n for n in numbers if n['y'] > boxes[:, 3].max() - 50], key=lambda d: d['x'])\n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x'])\n", + " else:\n", + " print(\"⚠️ Not enough axis numbers found. Defaulting to 1 pixel = 1 unit.\")\n", + " units_per_pixel = 1.0\n", + "\n", + " # Sort bars Top-to-Bottom\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[1])\n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cy = (y1 + y2) / 2\n", + " pixel_val = x2 - x1\n", + " if pixel_val < 10 or (y2-y1) < 5: continue # Sanity Filter\n", + " \n", + " # Find the closest text label on the left side of the bar\n", + " possible_labels = [l for l in text_labels if l['x'] < x1]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = pixel_val * units_per_pixel\n", + " final_data.append((label_text, int(round(real_val))))\n", + "\n", + " elif 'vbar' in chart_type.lower():\n", + " # Calculate Scale Ratio from Y-axis numbers\n", + " axis_nums = sorted([n for n in numbers if n['x'] < boxes[:, 0].min() + 50], key=lambda d: d['y'], reverse=True)\n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y']))\n", + " else:\n", + " print(\"⚠️ Not enough axis numbers found. Defaulting to 1 pixel = 1 unit.\")\n", + " units_per_pixel = 1.0\n", + "\n", + " # Sort bars Left-to-Right\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[0])\n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cx = (x1 + x2) / 2\n", + " pixel_val = y2 - y1\n", + " if pixel_val < 10 or (x2-x1) < 5: continue # Sanity Filter\n", + " \n", + " # Find the closest text label below the bar\n", + " possible_labels = [l for l in text_labels if l['y'] > y2]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = pixel_val * units_per_pixel\n", + " final_data.append((label_text, int(round(real_val))))\n", + "\n", + " else:\n", + " print(\"⚠️ Not a bar chart.\")\n", + " return\n", + "\n", + " # --- FINAL OUTPUT TEXT ---\n", + " print(\"\\n📈 FINAL EXTRACTED DATA:\")\n", + " for label, value in final_data:\n", + " print(f\" {label}: {value}\")\n", + " \n", + " # --- DISPLAY THE GRAPH WITH YOLO BOXES ---\n", + " annotated_img = results[0].plot() \n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " plt.figure(figsize=(12, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " \n", + " # Extract filename for the title\n", + " file_name = os.path.basename(image_path)\n", + " plt.title(f\"STEM Sight Extraction: {file_name} ({chart_type.upper()})\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " return final_data\n", + "\n", + "# ==========================================\n", + "# 3. RUN THE ENGINE\n", + "# ==========================================\n", + "my_image = \"./Real_Test_Graph/hbar2.png\" \n", + "extracted_results = extract_full_chart_data(my_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "50cdd399-3903-4c6a-8e75-16cda1b50429", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing FigureQA (train)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100000/100000 [00:12<00:00, 7749.40it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing FigureQA (val)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20000/20000 [00:02<00:00, 7979.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing PlotQA (train)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 157070/157070 [00:16<00:00, 9331.87it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing PlotQA (val)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 33650/33650 [00:03<00:00, 9500.86it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ TRULY Pristine Dot-Line Dataset Generated!\n" + ] + } + ], + "source": [ + "import json\n", + "import os\n", + "import shutil\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "\n", + "dataset_configs = [\n", + " {\"name\": \"FigureQA\", \"base\": \"./../FigureQA_Dataset/train1\", \"split\": \"train\"},\n", + " {\"name\": \"FigureQA\", \"base\": \"./../FigureQA_Dataset/validation1\", \"split\": \"val\"},\n", + " {\"name\": \"PlotQA\", \"base\": \"./../PlotQA_Dataset/train\", \"split\": \"train\"},\n", + " {\"name\": \"PlotQA\", \"base\": \"./../PlotQA_Dataset/val\", \"split\": \"val\"}\n", + "]\n", + "\n", + "CLASS_DOT = 0 \n", + "\n", + "def process_dot_lines():\n", + " # --- FIX 1: NUKE THE FOLDER ---\n", + " # Guarantee we don't have leftover bar graphs from old runs\n", + " if os.path.exists(\"./datasets/yolo_dataset_dots\"):\n", + " shutil.rmtree(\"./datasets/yolo_dataset_dots\")\n", + " \n", + " for split in ['train', 'val']:\n", + " os.makedirs(f\"./datasets/yolo_dataset_dots/images/{split}\")\n", + " os.makedirs(f\"./datasets/yolo_dataset_dots/labels/{split}\")\n", + "\n", + " for config in dataset_configs:\n", + " print(f\"\\nProcessing {config['name']} ({config['split']})...\")\n", + " anno_path = os.path.join(config['base'], \"annotations.json\")\n", + " \n", + " if not os.path.exists(anno_path): continue\n", + " \n", + " with open(anno_path, 'r') as f:\n", + " data = json.load(f)\n", + " \n", + " for item in tqdm(data):\n", + " # Only process dot-line charts\n", + " if item['type'] != 'dot_line':\n", + " continue\n", + " \n", + " img_path = os.path.join(config['base'], \"png\", f\"{item['image_index']}.png\")\n", + " if not os.path.exists(img_path): continue\n", + " \n", + " try:\n", + " with Image.open(img_path) as img:\n", + " w_img, h_img = img.size\n", + " \n", + " yolo_lines = []\n", + " \n", + " for model in item['models']:\n", + " # --- FIX 2: FILTER OUT TEXT & AXIS BOXES ---\n", + " # We ONLY want the data points!\n", + " model_name = model.get('name', '').lower()\n", + " forbidden_words = ['axis', 'title', 'legend', 'label', 'background']\n", + " if any(word in model_name for word in forbidden_words):\n", + " continue\n", + " \n", + " if 'bboxes' in model:\n", + " for box in model['bboxes']:\n", + " if isinstance(box, dict):\n", + " x, y, w, h = box['x'], box['y'], box['w'], box['h']\n", + " else:\n", + " x, y, w, h = box\n", + " \n", + " if w <= 0 or h <= 0: continue\n", + " \n", + " cx = (x + w / 2) / w_img\n", + " cy = (y + h / 2) / h_img\n", + " nw = w / w_img\n", + " nh = h / h_img\n", + " \n", + " yolo_lines.append(f\"{CLASS_DOT} {cx:.6f} {cy:.6f} {nw:.6f} {nh:.6f}\")\n", + "\n", + " if yolo_lines:\n", + " # --- FIX 3: PREFIX THE FILENAMES ---\n", + " # Now it will save as \"FigureQA_0.png\" so they never overwrite\n", + " base_name = f\"{config['name']}_{item['image_index']}.png\"\n", + " target_img_path = f\"./datasets/yolo_dataset_dots/images/{config['split']}/{base_name}\"\n", + " \n", + " shutil.copy(img_path, target_img_path)\n", + " \n", + " txt_filename = base_name.rsplit('.', 1)[0] + \".txt\"\n", + " with open(f\"./datasets/yolo_dataset_dots/labels/{config['split']}/{txt_filename}\", 'w') as f:\n", + " f.write(\"\\n\".join(yolo_lines))\n", + " \n", + " except Exception as e:\n", + " pass\n", + "\n", + "# Run it!\n", + "process_dot_lines()\n", + "print(\"\\n✅ TRULY Pristine Dot-Line Dataset Generated!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "23579f00-1531-4f8d-bb61-048a43ca3621", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up STEM Sight Continuous Line Sweeper...\n", + "\n", + "🚀 Analyzing Line Chart: ./../FigureQA_Dataset/validation1/png/65.png\n", + "--------------------------------------------------\n", + "📏 Scale Established: 1 Pixel = 0.0506 Units\n", + "\n", + "✅ Extraction Complete! Continuous Waveforms Generated.\n", + "\n", + "🔵 Line: RGB(240, 120, 0)\n", + " Total Data Points: 387\n", + " Start Sequence: [np.float64(9.13), np.float64(9.08), np.float64(9.03), np.float64(8.97), np.float64(8.92)]...\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0QAAAHWCAYAAABXKElPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgWNJREFUeJzt3Qd4U9X7B/BvdtLB3kOm7CXgAGXIVBCRJTKUIU7c668/J6IibkVFEUVkbzcoKlOG7KUisgWUDW2zk/t/3lMT21KgLW1vxvfzPJHcm+Tm5NzTeN+cc95j0DRNAxERERERURwy6l0AIiIiIiIivTAgIiIiIiKiuMWAiIiIiIiI4hYDIiIiIiIiilsMiIiIiIiIKG4xICIiIiIiorjFgIiIiIiIiOIWAyIiIiIiIopbDIiIiIiIiChuMSAiopizZ88eGAwGfPrpp3l+7WuvvVYgZaPY1rZtW3WL9L+H5557Tu0j4NVXX0X16tVhMpnQpEkTVglRHGJARBQHtmzZgt69e6NKlSqw2+2oWLEiOnbsiDFjxmS6ODrfLXShN3jw4LM+R44fsnjx4vD+yZMnZ1u2K6+8Uj3eoEGDHH2Wr776Cm3atEGZMmWQkJCgLmRuvPFGLFiwAIXt22+/VXV3obLWYZEiRdRn/OabbxBrVqxYoers5MmTcV2GkEAggAoVKqjzPn/+fESjV155RZV/w4YNmfZrmobixYurx3bv3p3pMbfbDZvNhv79+0NP33//PR577DH1PTRhwgS89NJLupaHiPRh1ul9iagQL/6uvvpqXHTRRbjttttQrlw57N+/H6tWrcLbb7+Ne++9Fz179kTNmjXDr0lNTcVdd92FHj16qMdCypYtG74vFzPjx48/4/3kV9asJEiaOnUqBg4ceMYv11K+jEHUuUivzaOPPqqChSeeeEIFRH/++Sd++OEHTJ8+Hddcc416ngR+LpcLFosFBR0Qvffee/kSFEmAesstt6iLyL1792Ls2LHo1q2bukju3LkzYoWc7xEjRqigulixYnFbhpCffvoJhw4dQtWqVTFlyhRce+21hfK+Tz31FB5//PF8OdZVV12l/l2+fDkuueSS8P5t27apoNNsNuPnn39GtWrVwo+tWbMGXq83/Fo9699oNOLjjz+G1WrVtSxEpB8GREQx7sUXX0TRokXVBUjWi7/Dhw+rfxs1aqRuIUePHlUBkezLGsSEyEXO2R7LqkuXLvjyyy/VcUuVKhXeL0GSBFkXX3wxTpw4cc5j+P1+jBw5UgUO8qtuVqHPIrL2VEWDWrVqZarPXr16oV69eipojaWAKDeCwaC6aI62c5kb0nPatGlTDBo0CP/73/+QlpaGxMTEAn9f+fuVW35o3ry5OkcSEMkPLCESBJUsWVI9Lo9lbN+yLfQOiOR7w+Fw5FswJD9oSO+XHJOIogeHzBHFuJ07d6J+/frZ/hIuw84KQ/fu3VWP0qxZszLtl4BIhrtl16uUlQRTp0+fVkNbspPxs5xtDpG8vwQZcvEmQ/TmzZunegnk1/nsjBs3DjVq1FBlv/TSS1VQGSKvk94hkXG4W4j86v/777/D5/MhL+rWrauCRzl/GXk8Hjz77LOqR0/KVblyZTXkR/Znd7F92WWXqZ40GbrUunXrM4LJ999/X7UPOZYM3Ro+fPgZQ8lkqKTU16+//qp6G+V4MuxShkplJcMw5Xih95SLYTnPQnrSpIdPSG9BqM7kfIXq8Z577lE9JaEyyVDI0NBL+Tejs51nqXdpV6VLl1YXprVr18aTTz6ZozKE6q1Zs2bqtSVKlMBNN92kelXP1j7keVLPy5YtQ25IL6a0QTm+lFe2v/jiixzPS8qu7cq5k/3yI4j8zUugld3QwOzmEIV+dAi1eTm2BGnZta2MJJiQvw8JgDKS7RYtWqi/2ewek/KFhspK72/Lli1VACX1KfU/e/bsTK+R50r7yy5wlvYow4Iz7nvrrbdUO5K/d/nh5Y477sj0w4t8fhkmJ0FoqB2E2lJO60L2X3fddfjuu+9UW5eyf/jhh+E2O3PmTNUbKeVLTk5WZTx16pQ6zgMPPKC+t5KSkjBkyJAzjr1w4UIVMEo9yXOkHUsZiCj/sYeIKMbJ8LGVK1di69atOZ6nk1MSpGR3cSRzYDKSi2MJiqZNm6Z6nsSmTZvUkBoZdrd58+bzvpdcOMjFhswhkl+h5UI1N2Q+Tt++fdGwYUOMGjVKXRjdeuut6kIlO3IRn5KSoi6i5MJGLv5l+OCuXbvUUDzZf/DgQXXRMmnSpDNeL0P6Jk6cqOZOnC3gOhe5aJIyygVZxou866+/Xv26fvvtt6ugSeaHvfnmm/jjjz/w+eefh58rF2Fy0SsXmc8//7w6L6tXr1ZDhDp16qSeI4/L8zp06KDOy/bt29VQPQn85II145BDKYsMSZQ6kIt3uVj9v//7P1WfoWFeH330Ee677z510Xf//ferX8rl3Mr7ylwRea2UU9qBlDnUWyiBS4iUTy4iJTCSx6XucjPXR96vVatWquxSR/J6CSql3Uhv6fnKIM95+umn1WccNmwYjhw5ooI8CSZljkzohwUZYiVtQOpXLmylXci5kXYpQWpOSK+pDE+VgEiGskrQI8FgXufVSO+E/J1J+7jzzjtV+5CAS4KinJDPK21Wzt/DDz+szpv8rfz222/qOOciF+4SEEpgGWrv0obkmBIsShAv51HqT8opwxYlWJLhakJ6QqX+BgwYoHoFZQhsnz598PXXX6Nr167qOfL3K23277//VvUVIp9X/halHkPk3EhwI4GGtEn5O3z33XfVOQy1bfm7laD2l19+CQ//lfOZ27qQv5t+/fqp95RhyRK4hMhr5HtLhifK8F5pS/Le8rnlb0o+jwxflrJKgP7MM8+o18l3owRa0ksvf78SlMnrswaWRJRPNCKKad9//71mMpnUrUWLFtpjjz2mfffdd5rX6z3ra44cOaLJ18Ozzz6b7eODBg1Sj2d369y5c/h5ixYtUvtmzZqlff3115rBYND27dunHnv00Ue16tWrq/tt2rTR6tevf97P8swzz6jjJSYmatdee6324osvauvWrTvjebt371bPmzBhQnhfw4YNtUqVKmkpKSnhfYsXL1bPq1KlyhmvLVmypHb8+PHw/i+++ELt/+qrr8L7hg8frvadq47keOcjz7v11ltVvR8+fFhbu3atds0116j9r776avh5kyZN0oxGo7Zs2bJMr//ggw/Uc3/++We1vWPHDvW8Hj16aIFAINNzg8Gg+lfex2q1ap06dcr0nHfffVcd65NPPgnvk/Mj+z777LPwPo/Ho5UrV07r1atXeF/37t3Pex7l85ytXmS/lHvbtm2Z9ofakfx7vvPcunVrLTk5Wdu7d2+2n/tcZdizZ4/6O5F2ldGWLVs0s9kc3i9/O2XKlNGaNGmi6iFk3Lhx6rhSXzlx3XXXaVdeeWWm18v7yLnJSI6X3TGljWVsu59//rl6/1deeSW8z+/3a61atTqjnuRvO2Pb3bhxo9oeNmxYpvd45JFH1P6ffvrpnJ/lm2++Uc+TNioOHTqktpcsWaL+5qRe5Tli69at6rGM9ex0OjMdT+q4QYMGWrt27cL7tm/frl43ZsyYTM+9++67taSkpPAx5O9DnjdlypRMz1uwYMEZ+6UO5fsko9zUhdS/7JNjZ9dm5TNk/K7t16+f+h6U76+M5Ls547l888031evlO4GICh6HzBHFOJlzIz1E8uur9MpIT4fMSZGeEfmFOq9kGIr0jmS9vfzyy9k+X3ol5Ndz+eVXrn3lX/lVNTekN0N6bmTitgxRkWFQMrRG5mDIL7dnI78eS0+KJC2QoSchkpxBejiyI79Gy5CvEOl1ENITkBPyi698zpz2DkmPg/RSSE+YDL358ccf1VC4hx56KNOQP/nVv06dOqp3LnRr166denzRokXqX+kpkt4k+bU59At8SGiYlCSikF/ipXcj43PkF27p4cua4U7qLeMcEOlxkl/+M9aH/Pr/119/ZRpamFtyTmRYY15Ib87SpUsxdOhQlUQko5ykmJ47d66qN+kdyli/0hsh89xC9bt27Vo190R6YTLOPQkNVcuJY8eOqTac8W9A5o2FhlnlNcmHzAsK9cIKGY6acV7PuV4rMrY3Ib0j4nwZD6VnRdpRaG5QqBdGhtJJ25GejlDvRujfjPOHMs65kZ4T6SGVv7n169dnmmcnabFnzJiRKUuf9FZKApLQMeTvRM6DfPdlPI/yXSFlCZ3H/KoL6dk52zw/+c7J2NN6+eWXq+8FaaMZyX4ZlilD9USoJ1KGUEqbJKKCxYCIKA7IRYlc7MmFhgwPkeFcMhxMhoPIvJC8kAstGWqV9Xa2dTzkokCGwEhAIxet8j//vAwNkgtIGZojn0Xmw8gxZBiMXBDJEK3sSNY2kTGTXkh2+0TWC+pQcHS+5A95JUOdJKCUi63Q/A6n05kpWNmxY4caSiOBU8abXChmTCwhQ8TkdecKLEJ1knF4j5ALfEllHno8pFKlSmcEFVInGetDhtDJBacEShJAyHyk3A7xyZiJLLdCwVleh4ZK/crFqpQ9ax1LwB2q31DdyPOytnGpu5yQi3qZXybBvQyFktvx48fVhbEMm8sLKVf58uUzBf3ZneOzvVbaTNa/BwkG5eI8a3vISp4j83UyBj3y2UJBigRMGR8LBdQhMjTuiiuuUD+0yA8nUucyfFMCo6w/VMjrDxw4oLZlro6cF9mf8TzK6+THhaznUYYoZkzAkh91ca42m/V7JBQwZx1WKfsl8Al9Xvk8MvdKhu7J/CcZDiiBMoMjooLBOUREcSQ0+VluchEt4+vl11QZ318YJHj54IMP1AV/48aN89wTIKQXQ34BlptciMp4fxnnLz0M+eFsiR7SR3blPwk4JKAMZeWTuS0yj0YmkYdSn8vFkPRovfHGG9keI6dzVwqqPqT3SuZTyMWtJEOYM2eOStogPVXSu5cT2WXnOlvvjvQO5Cep39B6QNl93qyBxoUIBT1nSxIiwV0ouJIyZdfu8vvzh94rr6THR/6+Za6QBC2h+ThC7n/yyScqCJReJOmtCWUPlB84pAdb5mlJe5GgTv6mJeFBKCFHiAQK8oOOfG9J76YECRJMhFLuh86jBENnCywzzlnLj7o4V0a5s/3dnO/vSY4pPxxJb5b8SCJ/TxJES2+w/BCUk0Q0RJRzDIiI4pQMywplQysscsEkv5jKr7qjR4/O188iAdHZPosklhDyK3xW2e0rjIvH85EJ2jLpX9aLkfWg5L0kwYIMe2zfvv0531ueJxeF0vt3th67UJ1IAJOxV0OG0ckE9FBwlluSMlouWuUmx5JgThIVyEWsXADnpc5CvXNZkytk/aU+9Dkkgci5nK0MUm9yQSq/+Id63c5Vd9ITERquKORiX+pOgv1zkedIUgEJeLMG8HLebr75ZhUIyLkPff7shmpm/fxSLhlqKb0gGYM3OcfnI6+V95bPJIFtyD///KPqPfSZz/f3Lb06MhxTem1D2fxCAZFk0ZOLe/ksMjwwRAJnaRsyhFCSB4RIQJSVnBvpWZLgQOpPer5vuOGGTK+T8yhlkGAzL+mv86Mu8oP0UsnfutzkRxBZNFaGCUuQlNe/TyLKHofMEcU4+Z9ndr8uh8bJ52Q4TX6RC9F33nlH9UjJRV9uyPAxmQuVHflF/1yfRdJJyzCqzz77TF0shixZskTNLcqr0Hox2WVBu9C02zIXROYsyFCtUCpmmdsiQ4Ukm1tWcrEp6YOFXCDKxZRkp8o6xCbUFuSCSnoM5XxkbB8yl0mG7YQye+WGzIvJSI4vvYBy/FA9nKvOzkYuQOUXcfnFPCPpTcj6y7/0MkhPxL59+zI9lvEznq0MErzJ+0hvVta/GdkOfT4JwOW9pDdEgr6M88Zy8rlCPRcyR0yGrWa8yTmWIClj74Zc4EtbkjlSIRIYZx2OKD2LMgdFgpKMvUiS2ex85LVCUlVnFOqNzEl7CM0JktfI+c7YQyRz6aTnJ5SqPeP8Ialz+W7I2OMl2eoyZk3MSIJtycwm51nmBmUcLiekDuVYkjY7K6mf852j/KiLCyXDJ7MK/bhxvjToRJR77CEiinEyoVqCCellkMn4cgEnv07LL6xykSLD5vJCLixkvZbsyHudbXFJmSsjt9ySzyAXWDLPQIbHyPAwubCRiyYZciNBgMxZOBv5dVXeV341ls8sc18kDa8EShmDpNyQYT9C0vrKpGq5sAul/r3QtNuhSfoy3Ex60+TzSRApQ4RkMr8EuvJZ5MJPLpZlf2gtFJn7IL8kywWhTEyXC335BV2SHUhwKKmA5YJeyigX/1KfMmRJehIkyJAhlTlddDdr4gyZZyHlknkPEsxJHcsFpKzBkrHOpHxSVzI0SuZ/nWsxUhkSJfPP5MI+1FMmw/KymwsiAZ5cbEuiDUm7LT0KcnEtPRMbN248ZxnkuC+88IKqF3mN1LmUW86hpFqW4z3yyCPq+fI86cWTHiK5IJfnSI9GTuYQSbAjF7dnG+Io50L+biWhgHwOmYAvF+PSxiRVvHxuCcZkzo6szRUin0HqXlI8S/klGJUelKzzcLIjvVqSnlvSUMvflQRlMt9Q2rDUQ3br/2Qlvb/ymeSHC2nz0tYykr9f6Q2Sc5hxqKC0D/l80g5lWK18PlnjS9pxdin5JeCR8yA3mW+UtbdEyi7nRtq5nHNpl3LOpMdHhtpJiu+MaxYVRF1cKPkxQ34AkLqRHwSkTuRvU4bW6r2YLVFMKoRMdkSko/nz52tDhw7V6tSpo1LTSqrlmjVravfee6/2zz//5Hva7YzpjDOm3T6XnKTd9vl82kcffaTdcMMNKj2tzWbTEhIStEsuuUSlUc6Y/ji7dMxi+vTpqh7ktZIO98svv1Rpo2Vf1tdmTHcdkrVOJKWx1GPp0qVVKt2MX6m5TbstKbyz89xzz2VKOS0pfEePHq3qSz5H8eLFtWbNmmkjRozQTp06lem1kjpb6if0PKnnhQsXZnqOpNmWz2+xWLSyZctqd911l3bixIkcnZ+saZ8//PBDlfZaUpbLe9aoUUOlV89arpEjR2oVK1ZUKbYz1tG56kHapJwrOefyWe64445w+uas51n2S8rxYsWKaXa7Xatdu7b29NNP56gMYs6cOdpVV12l0jHLTepHyiVpnzN6//33tWrVqqnP2rx5c23p0qVnTZEdImni5f2ylidr+m95zoMPPhjeN3nyZJWmXv5+Jd23pM7PWv/i2LFj2s0336wVKVJEK1q0qLq/YcOG86bdDv2NSTuSzyTtoXLlytoTTzyhud1uLackrbQct3///mc89sYbb6jH6tate8ZjH3/8sXbxxRerupT6lrJmV8YQSVeeXWrsjCSNufxtOBwOlYpdUu/LsgMHDx48Z9rt3NSF1H/Xrl3PeP3Zvvvkc8n+NWvWZNof+qyhNNs//vijSmNfoUIFdc7lX6nbP/7446yfl4jyziD/0TsoIyLSi/xSL70lkuGNiIiI4g/nEBFRXJA5DaE1PkIkuYPMxWjbtq1u5SIiIiJ9sYeIiOKCzKmQuQYyN0bmNsi8G5mHIfNTJCtZyZIl9S4iERER6YBJFYgoLkjqYplMP378eJWtSybxy4Tll19+mcEQERFRHGMPERERERERxS3OISIiIiIiorjFgIiIiIiIiOJWVM8hkhXYDx48qBbOk4XeiIiIiIgoPmmahpSUFJU8yWg0xkdAJMHQ2Vb6JiIiIiKi+LN//35UqlQpPgIi6RkKfegiRYro3lslmatkgcfcRKTE+o50bNus61jEds36jlVs26zreG7Xp0+fVp0loRghLgKi0DA5CYYiISByu92qHAyIWN+xhG2bdR2L2K5Z37GKbZt1HYuCubzOzu1UGnZlEBERERFR3GJAREREREREcYsBERERERERxS0GREREREREFLcYEBERERERUdxiQERERERERHGLAREREREREcUtBkRERERERBS3GBAREREREVHcYkBERERERERxiwERERERERHFLQZEREREREQUtxgQ5RPN64R59RvQ/N78OiQRERERERUwc0G/QTwIHNsJ5+SesPy9GR4tDQk3vKd3kYiIiIiIKAfYQ5QPNNcJBI9uV/d9q9+Hd/2k/DgsEREREREVMAZE+cBcqTls3caEt13zbkfg4Mb8ODQREREREcVqQJSSkoIHHngAVapUgcPhQMuWLbFmzRpEI2vzW+FvMCB9w+9G2uSequeIiIiIiIgil64B0bBhw7Bw4UJMmjQJW7ZsQadOndChQwccOHAA0cjX5kUYK16q7msndsM5YyC0YFDvYhERERERUaQFRC6XC3PmzMErr7yC1q1bo2bNmnjuuefUv2PHjkVUMtvg6D8ThsRSatO//Vt4f35L71JFhGDqEQRP7gvfNPcpvYtERERERKRfljm/349AIAC73Z5pvwydW758ebav8Xg86hZy+vRp9W8wGFQ3Pcn7a5oGFKkEe9+pcE3oDGga3AufgqnOdTCWrIl45f7mIfhWvJ15p9EEe68JsDT5d5hhHutb7/MeD1jXrOtYxHbN+o5VbNus63hu18E8XhfqFhAlJyejRYsWGDlyJOrWrYuyZcti2rRpWLlypeolys6oUaMwYsSIM/YfOXIEbrcbepITcOrUKXWyjMkNYWk0FOZNHwM+F07PHAJvz1mAIf5yWJi2TYM1azAkggG45t6Gk+ay0Mo0urD6NsZfvRYm1jXrOhaxXbO+YxXbNus6ntt1SkpKno5v0FS3hj527tyJoUOHYunSpTCZTGjatClq1aqFdevW4bfffstRD1HlypVx4sQJFClSBHqfKAnMSpcurU6U5klF2pjG0E7sUY9b24+Ard1TiCeBv9bC+VFrwJ9+zky1u8JgTUDw1F8I7lup9hmKVUHi8DUwJJS8oPqmgsO6Ljysa9Z1rGLbZl3HIrbryKtriQ2KFy+ugqfcxAa6Lsxao0YNLFmyBGlpaeoDlC9fHn379kX16tWzfb7NZlO3rKRiIuGi2GAw/FcWRxEk9PoYaR93UEPnvD89B3Ply2CpfQ3iQTDtKFzT+oSDIesVd8PRPX3BWs3vQdq4NgjsXw3t5F64Z96MhMHfwGA05b2+qUCxrgsP65p1HavYtlnXsYjtOrLqOq/XhBFxJZmYmKiCIenp+e6779C9e3fEAnONdrB1fCF9Q9PgmtEfweO7Ecv8f/4Iz5JX4JzcA9rJfWqfqfIVsHd9M/wcg9mGhAGzYUgsnf6aHd/B88NzupWZiIiIiOKXrgGRBD8LFizA7t27Vfrtq6++GnXq1MGQIUMQK2xtHoe5XnqAJ+sSqfWJfC7EIu+m6apHzL3g/xDYk54Yw5BUJj34MVszPddYtBIS+s0Iz6vyLHoBvl+/1KXcRERERBS/dA2IZHzf8OHDVRB0yy234KqrrlJBksViQawwGI1I6DMRxpIXq+3goY1wfX5Xeka6GBL4ewtcc27NvNNkVUGPsWjFbF9jrnE17NeMDm87Z96MwNEdBV1UIiIiIqLICIhuvPFGlVhBEiUcOnQI7777LooWLYpYY7AXRcLAuYAlQW371k+Ed/UHiBWBgxuRNrEb4HOqbUujvurzJj2wFebqbc/5Wmurh2Fp2Cd9w3MaTulB86YVRrGJiIiIiCJjDlE8MJVrAEfvT8Lb7q/vh3fzzKjuKdJ8bniWvYHUsS1UcgRhrNAUjt4TYKnfA6ZS6b1i55sg5+j1MYxl6qrt4D9bVTruaK4XIiIiIooeDIgKkbVRX1ivfDB9I+CDa1pfpL13aVQmWpDkCSmv1YD724cBf/oaUKaKzZB4y5cwWBy5OpbBloyEAXMBW7La9m2aBu+Kdwqk3EREREREGTEgKmT2a0fDXLdbeDtwYB3SJnWPqmFigSN/IE2yyJ0+GN4nabUT7/z5rPOFzsdUpg4Sen8a3nZ/+wj8u5flS3mJiIiIiM6GAVEhM5gsSLj5CyQM+hrGEunrLQUlIcHc26NimJgsOOuc0hPwpK8EbKreFkn3bVRrDEk67QthadATtjb/l74R9MM57UYETx/Kj2ITEREREWWLAZEOZN6MpU5XJAz6BrAmqX2+TVPhXfkuIr1nKPWDlgj+s01tG8vWR+ItX8FUvnG+vYes22Sq0V7d11L+hnNqH2h+b74dn4iIiIgoIwZEOlLDxPpkGCb2zUPw/7t+T6SRoX2p7zVXvVmKZM4bMBcGW3pAl18MJjMSbpoGQ9HK6e+792c1fI6IiIiIqCAwINKZpUEvWFs/+t8wsal9Im6YWDDtqFpQNjRMzlimHpLuWglT6VoF8n7GpNJIGDBHrWMkvCvHwLthSoG8FxERERHFNwZEEcDe6SWYql/93zCxaTdCC/gQCYIn9sI5pTe0k/vUtqlKSyTdvRqmf9NkFxRz5UvVvKQQ17zbEDi0uUDfk4iIiIjiDwOiCKCGifWbDkPRSmo7sGc5XF8Mhxbw61ou948jkfL6xQjsXpJezuRySOg/K9+HyZ2N9dJhsDS/NX3D50pftNV1slDem4iIiIjiAwOiCGFMKpNpmJhvzUdI+6Qjgin/6FIe369fwPPDM2q9JMVeDAn9Z8NYpEKhlsNx/bswVWyu7geP74SL84mIiIiIKB8xIIog5sqXwdFzPGA0q+3ArsVI+7hDoa9RpLlOwPX5XeFtWUy2yGO7YK56JQqbwWJHwoDZ/y3auvZj+P/8odDLQURERESxiQFRhLE2vRmJty2G4d+emOA/W+Gae1uhrVGUvlDsDdBS0hM7mGt3hb3r6zA4ikMvxuJVYL/21fC2U+rDfUq38hARERFR7GBAFIGkJybx1h//6xXZNA3eFWMK9D01vweuL+9F6rvNEdi9NH2nrQgcPT5Q6ybpzXrpbWoRWKGd2AP37MGAFtS7WEREREQU5RgQRfIaRb0zrFH07cMFtkZRMOVvpH3YKtPCsLIOUOLAOTD+m+hBbwajEQm9J8DgKKG2/b99CfOagg0SiYiIiCj2MSCKYJYGPWFt/ViBrlGk+b0qe1vgrzXpO8w22Lu+ieRHdsBcswMiibF4VThumgr822NlXjka/h3f610sIiIiIopiDIginL3TizDVaPffGkVT+6ggJj/IvCT3Nw8hsG+l2jYUqagWXLVd9QAMZhsikaVWZ9g6PK/uG6DBNWMAgif26F0sIiIiIopSDIiiYY2im2SNospqO7D3Z7jnP3rBx/XvXoa0sS3gXfXv4qcmKxIGzoOpwiWIdLa2/4OpznXpG67jSJvcC5rPpXexiIiIiCgKMSCKAsak0pnWKPKueAfejVPzfDz/zkVIG381AvtXh/c5ur8Hc+VLEQ1kPpGj90QEi1ZT28GD69MXsi2kTHxEREREFDsYEEUJCVZkkdIQ19xhCBzanOvjBE/uh3NaXyAYUNvGsg2QcMuXsF46DNHE4CgG73UfA5YEte1bN0EtZktERERElBsMiKKI5dJhsDQfmr7hc6lkCJrrZI5fHzy+G2kTu0JLO6K2zRd3RtJ9G2Gp2w3RSCtVF/Ye48Lbkjbcv/8XXctERERERNGFAVEUkfWAHNe/B1PFZmo7eHwnnDNvhhY893o8WsAP77pPkTKmKYJ/b0k/1r8Z2wxGE6KZpXE/WFven74R8MI5pReCqYf1LhYRERERRQkGRFHGYLGr+USGhJJq2//71/B8/7+zzp8JHNyA1LfqwzV7COBO700ylqyJxMHfwpiQvqZPtLN3eRWmqq3Ufe3UX3BOu0kFgURERERE58OAKAoZi1eB46Zpkl1AbXuWjIZzco8zhs+pBVcnXofg0T/C+ywN+yDpnrUwlamLWGEwWZDQfyYMyeXVdmDXIri/e5xJFoiIiIjovBgQRSnLxR1h7/pGeNv/6xfp84P+XaNIC/hU8gTt9EG1bSzfBIm3L0kPHOxFEWuMyeWQ0H8WYDSrbe+y15H2wZXw7/lZ76IRERERUQRjQBTFbFfej4RB38DgSB/6Fti7In2h1WM7kfZxBwR2Lw0vuJo4ZAHM1VojlpmrXgn7dW+Ft2XBWUkv7t+7QtdyEREREVHkYkAU5Sx1uiBhyIL/1iha9R5SX6sZDobUgqsDZsOYXBbxwNZiOBJu/hzGsvXTd0hP2ZTeavggEREREVFWDIhigFqjqPt7Z+w3FK2ExNsWw3zRFYgnlnrdkXTvRpiqt1XbWsohOKfeqIYREhERERFllD7hgqKeLKyq+dzw/7FAQgAYS9WC7eonYUwshXhkMJmRcNN0pL7bDNrpAwjsWQb3/MfguO5NvYtGRERERBGEAVEMsbW8R90onQwTlOGCaeNaq6Fz3p/fgqny5bA2volVREREREQKh8xRTJPhgvbr3g5vuz6/C8HTh3QtExERERFFDgZEFPOsl98JS+N+6Rvuk3B9cTfXKCIiIiIihQERxTyDwQB7t3dgSCyttv2/fg7fpml6F4uIiIiIIgADIooLklzCfv274W3XvNsR+OdXXctERERERPpjQERxw9KwDyxNBqZveNPgnNwDmvu03sUiIiIiIh0xIKK4Gjrn6PEhjOUaqe3g0T/gnD2Y84mIiIiI4hgDIoorBmsCEgbOBezF1LZ/2zx4lozWu1hEREREFI8BUSAQwNNPP41q1arB4XCgRo0aGDlyJH+xpwJlKlkDCX0nh7c93z8J/58/sNaJiIiI4pCuAdHo0aMxduxYvPvuu/jtt9/U9iuvvIIxY8boWSyKA5Y6XWFr/2z6hhaEc3o/BE/u07tYRERERFTIzNDRihUr0L17d3Tt2lVtV61aFdOmTcMvv/yiZ7EoTtjaPYPAX2vg3/4ttLSjSPu4I+zXvgpz3W5qvlF+CqYdBfzuCzqGIbkCDEaOciUiIiKKmYCoZcuWGDduHP744w/UqlULmzZtwvLly/HGG29k+3yPx6NuIadPp2cICwaD6qYneX9N03QvR7zIr/q29/kMae9fBu34rvQkC5O6w1SzA+w3Tobx33WLLqicqYfhnj0YgR3fXfCxDMWqwN77U5irtUZhYttmXccitmvWd6xi22Zdx3O7DubxulDXgOjxxx9XQU2dOnVgMpnUnKIXX3wRAwYMyPb5o0aNwogRI87Yf+TIEbjdF/br+4WSE3Dq1Cl1soz8FT+q6ttw3URYF9wD4+FNajvw5w9IfasRgqUbXHA5jUe2wuA8jPygndwL58cd4Gv1LAKX3IbCwrZdeFjXrOtYxbbNuo5FbNeRV9cpKSnRFxDNnDkTU6ZMwdSpU1G/fn1s3LgRDzzwACpUqIBBgwad8fwnnngCDz30UHhbgqnKlSujdOnSKFKkCPQ+UTLMSsrCgCjK6rtMGWi11sH/2xfwfHE3tNR/VBBj2vtTfhUXhqRyMFW9Ms+vDx7fg+DBdTBoAViXPgN7xdqwNOidb+U753uzbRca1jXrOlaxbbOuYxHbdeTVtd1uj76A6NFHH1W9RDfddJPabtiwIfbu3at6grILiGw2m7plJRUTCUGInKhIKUs8yO/6NjXoCUuVlnDNHgL/HwuQX8y1roWj9ycwJpfL8zG0YACe75+CZ8nLats951aYyzWEqUxdFAa27cLDumZdxyq2bdZ1LGK7jqy6zus1oa4BkdPpPKPgMnSO83BILxK0JA6ZD82TAgT9+XBAMwy25As+jMFogq3zSwie+gu+jZMBbyqck3sg6e5fYLDr2ztKREREFM10DYi6deum5gxddNFFasjchg0bVEKFoUOH6lksonwJYgrilxFHjw8R+GcLgoc2IXhkO5yzhyBhwOx8z4pHREREFC90Hdsl6w317t0bd999N+rWrYtHHnkEd9xxh1qclYjOZLAmIGHAHMBeTG37t82Fa1pfBI5sZ3URERERRVtAlJycjLfeekvNG3K5XNi5cydeeOEFWK1WPYtFFNFMJWsgoe/k8LZvyyykvtUAvl+/1LVcRERERNGIs/+JopClTlc4en8KQ0LJ9B1BP1xzh6UvAEtEREREOcaAiChKWZsNQvJju2Gu3VVta2lH4P7qfr2LRURERBRVGBARRXnyB0fPj2BwFFfbvk1T4d08U+9iEREREUUNBkREUc5YpDzs170V3nbNGYrAP9t0LRMRERFRtGBARBQDLJfcrG6KNw3OyT2huU/rXSwiIiKiiMeAiCgGqDWKbvgAxvKN1Xbw6B9wzh4MTdP0LhoRERFRRGNARBRDaxQlDpybYY2iefAsGa13sYiIiIgiGgMiohhiLFEdCX2nSJeR2vZ8/yT8f/6gd7GIiIiIIhYDIqIYY6nTBbZ2z6ZvaEE4p92E4Ml9eheLiIiIKCIxICKKQbZ2T/+3PpHzGJyTe0HzufUuFhEREVHEYUBEFIMMRiMS+k5SQ+hE4MBauL66V+9iEREREUUcBkREMUoWa02QJAsWh9r2rRkP75rxeheLiIiIKKIwICKKYabyjeHoMS687fpiOPz71+haJiIiIqJIwoCIKMZZLxkIa4t70jcCXjin9kYw7ajexSIiIiKKCAyIiOKAvcvrMFVpqe5rJ/fBNb0ftGBA72IRERER6Y4BEVEcMJitSOg/C4bkcmpb1ibyfP+U3sUiIiIi0h0DIqI4YSxSAQn9ZgJGs9r2LHkZvm3z9C4WERERka4YEBHFEXO1VrB3eS287Zw1CIEj23UtExEREZGeGBARxRlry/tgaXRT+oYnBc7JPaF5UvUuFhEREZEuGBARxRmDwQBHr/Ewlm2gtoOHf4VrzlBomqZ30YiIiIgKHQMiojhksCamL9pqK6K2fVtmwbN4FIMiIiIiijsMiIjilKnUxUjoOzm87fn+SbhmDYbmTdO1XERERESFiQERURyz1O0GW6cXwtu+DZ8h7bPu0AJ+XctFREREVFgYEBHFOfvVT8LRbzpgTVLbgZ0/wv39k3oXi4iIiKhQMCAiIlgb9UXikPnhNYq8S1+Bb+sc1gwRERHFPAZERKSYq14Fe5fXw7XhnDUYgcO/s3aIiIgopjEgIqIwa8t7YWncP33Dmwrn5B7QPCmsISIiIopZDIiIKPMaRT3HwViuodoOHvkd7jlDAa5RRERERDGKARERnblG0YC5gL2o2vZvmwvz+g9YS0RERBSTGBAR0RlMpWoi4cZJ4W3zzy/Av2sRa4qIiIhiDgMiIjr7GkVXP6XuG7Qg3NP7IXhyP2uLiIiIYgoDIiI6K1uH52C6uJO6r6UdQdqEzvBtXwCNc4qIiIgoRjAgIqKzMhhNcNw4BcEildV28PBvcH56LVwzb4YWDLLmiIiIKOoxICKiczIklID3+kkwlmsc3ufbOAWepaNZc0RERBT1GBAR0XlpJWsjYfhaOHpPkNzcap/n+6fg27GQtUdERERRTdeAqGrVqmrdk6y34cOH61ksIsqGwWiEtdlg2No/l75DC8IliRZO7GV9ERERUdTSNSBas2YNDh06FL4tXJj+a3OfPn30LBYRnYNknjPX7qrua85jcE7pBc3nZp0RERFRVNI1ICpdujTKlSsXvn399deoUaMG2rRpo2exiOg8PUUJfSfBWKK62g4cWAf3gsdZZ0RERBSVzIgQXq8XkydPxkMPPaSGzWXH4/GoW8jp06fVv8FgUN30JO8vqYj1Lke8YH3rXNe2orD3nw3nBy0Bvxvele/A3KA3TFVaFmLJYg/bNes6VrFts65jEdt15NV1Xq/DIyYg+vzzz3Hy5EkMHjz4rM8ZNWoURowYccb+I0eOwO3Wd8iOnIBTp06pk2U0MlcF6zt2nLVtm8rDfMVjsCx/HtA0pM4aDE+vOUBiWT2LG9X4PcK6jlVs26zrWMR2HXl1nZKSkqfjG7QIWWGxc+fOsFqt+Oqrr876nOx6iCpXrowTJ06gSJEi0PtESWAmwwAZELG+Y8m52rYW8MP54VUIHliTvsNsh7XVo7C2e0YNraP8q2vKX6zrwsX6Zl3HIrbryKtriQ2KFy+ugqfcxAYR0UO0d+9e/PDDD5g7d+45n2ez2dQtK6mYSLh4kKF+kVKWeMD6joC6NlqR0OdTpH3YCprrePrwuUUjYbA6YG/7RCGWMHawXbOuYxXbNus6FrFdR1Zd5/UaPCKu3CdMmIAyZcqga9f0zFVEFD1MZesh6cFfYb3ywUxrFHmWvgrvxqnQXCf0LiIRERFR5PYQSReYBESDBg2C2ax7cYgoD4zJZeG47g0YHMXh+eEZtUaRe/5j6jFPuYZIumslDNZE1i0RERFFHN17iGSo3L59+zB06FC9i0JEF8h29ZMw1+2WaV/w7y1wzRmmJkISERERRRrdu2Q6derECyWiWFqjqP8s+LbOVYu2ur//H+BJgW/zdBiKVoK98ygYTLp/7RARERGF8cqEiPKVwWyDtUk/dd9YtCKck3uq+95lr6lFXB3d34epTB3WOhEREUUE3YfMEVHsstTvAXu3MYDRpLYDuxYh9a36cM4eAs11Uu/iERERETEgIqKCZWt5DxKHLYKhSIX0HVoQvnWfIvXdZggcWM/qJyIiIl2xh4iICpy5WiskP7Qdts6jAHtRtS94fBdS37sUzpm3IHh8N88CERER6YIBEREVCoMtCfa2jyP5vk0wVbr0v96iDZOQ8k5j+LbM4pkgIiKiQseAiIgK90uneBUk3rEM9mtehsFRIn2nJwXOqTfCOX0AAkd38IwQERFRoWFARES6ZKKztfk/JD+2G5YmA8L7fZumIvXNunD/8By0YIBnhoiIiAocAyIi0o3BXgSOGyfB0WMcDAkl03cGA/D8OALOCdcgcGQ7zw4REREVKAZERKQrg8EA62W3qd4iW7unZXVXtd//5w9IfbMenHNuheY+zbNEREREBYIBERFFBIMtGfaOzyNx2I8wJJf7L+nC2k+Q+m5zBA5t1ruIREREFIMuKCByu935VxIiIknRXb0tkh/+A7ZOLwK2IqpOgsd2IPX9y+Fd9ynriIiIiPQNiILBIEaOHImKFSsiKSkJu3btUvuffvppfPzxx/lbOiKK396iq/+H5Ps2wFihafpOvxuu2UPg+vpBvYtHRERE8RwQvfDCC/j000/xyiuvwGq1hvc3aNAA48ePz+/yEVEcM5aojqQ7f4b1sjvC+7w/vwXvLx/pWi4iIiKK44Dos88+w7hx4zBgwACYTKbw/saNG+P333/P7/IRUZwzWOxw9PgA9hs+CO9zfXkPnDMHwfXtIwimHdW1fERERBTdzLl9wYEDB1CzZs1sh9L5fL78KhcRUSa2y+9A8J9t8K4cAwS88G34TO0P7FuJxGGLYDD/12NNREREVGA9RPXq1cOyZcvO2D979mxccskluT0cEVGO2bu8BlON9pn2BfaugPvbh6OqFrWAH/69KxBMPaJ3UYiIiOJernuInnnmGQwaNEj1FEmv0Ny5c7F9+3Y1lO7rr7+O+wolooIjvUCJQ79H8MRuBI/ugHNSd9Vb5F35LoJHfoet4wswX3R5RJ4CSRseOLQJmvuU6uUKHv0DsDhgvfwumMo3gcGWBOPF1+pdTCIioriT64Coe/fu+Oqrr/D8888jMTFRBUhNmzZV+zp27FgwpSQi+pfBaISpZA11c3R/D665t4UXcvXv/BG29s/BdvVT6nmRQAv44F7wOLzL3zjzQZ8r035z3e5Ax/cLt4BERERxLtcBkWjVqhUWLlyY/6UhIsoF66XDAFsyPN/9D8HjuwBNg+eHZ1VgZO88CuYqLS+4PrVgQPVCBY/thGfRC/D9/g0QzMV8SS0IBM58vqQTDx7+VaUTD/H/9gXMxeoC1714weUmIiKiAgyIiIgihbVRX1jq94RnyWgVDEkAEti9FGkfXAlL435w9PhQrWuUW5qmwbtqLDw/PAPNeezCC2qywNb6MRiSK8BUoQlMF7WAlnII/j8WIHj6oHofCejMK0fDX7sNrLWvufD3JCIiovwPiIxGIwwGw1kfDwQCuT0kEdEFMZgssLd7SvUIuebejuDxnWq/b9M0BA6uh6PneBhL1YJ31fsIHvszR8eUICWwa9GZ7+UoAUOxyrkqn7FIRdjaPwtz5csyH6tIBVibDw1vexY+DQM0uGYMgPnedTAWr5qr9yEiIqJCCIjmzZuXaVtSbW/YsAETJ07EiBEj8lAEIqL8Ya7RDkkP/Qbf+s/gksxz7lMIHtmOtA9bASarGvqWF6YqLWGwJMJ8cSdYr7gLBmtivp8yW9v/wb9/NQK/fw24jiNtci+1KK2sw0REREQRllQhq969e6N+/fqYMWMGbr311vwqGxFRnnqLrJfeClP1tnBO7YPgwQ3pD+QhGJLeIEfPcbA06FXgZ0KSQDh6T8TpMc1hPLUbwYPrVfY8W+tHCvy9iYiI4lm+zSG64oorcPvtt+fX4YiILohkoUu6+xf4NkxSyRBkCJz1stvVDeac9boYi1Yu1AVfDY5i8Hb5EPbpndMTRCx7DdYWw2GwOAqtDERERPEmXwIil8uFd955BxUrVsyPwxER5QuDyQxr8yGwNBsMBP2q9yjSaWUawly/F/xbZ0NL/QfeXz6C7cr79C4WERFRzMp1QFS8ePFMSRUkE1NKSgoSEhIwefLk/C4fEdEFU99ZURAMhVivflIFRMKzdLTq1eJcIiIioggJiN58881MAZFknStdujQuv/xyFSwREdGFMZVrBHO9G+D/9XNopw/Cu+Id2No8xmolIiKKhIBo8ODBBVEOIiLKwN7xeaT+9qVaV8m96EVYmg2BMak064iIiEiPgGjz5s05PmCjRo0upDxERKR6iRrC0nwofGvGA57TatFZxw3vs26IiIj0CIiaNGmihsnJfKFzkedwYVYiovxh7zhSLS4Lbxq8v3yokkNkXdyViIiICiEg2r179wW+DRER5ZYxuRzs7Z6Ge8Hjauica85QJN2zDgazjZVJRERUmAFRlSpV8uv9iIgoF6xXPQTv5plqodbgP9vg+ekF2DuNZB0SERHpvQ7Rr7/+in379sHrzbz6+/XXX58f5SIiIrWWkgUJvT9B6rvN1VpKnsUvwlTlSlhqX8P6ISIi0iMg2rVrF3r06IEtW7ZkmlcUSsXNOURERPnLVL4xbB2fh+e7/8nib3DN6A/TPetgLFGNVU1ERHSBjLl9wf33349q1arh8OHDajHWbdu2YenSpWjevDkWL158oeUhIqJs2Fr/H8z1uqv7musE0qb0guZzsa6IiIgKOyBauXIlnn/+eZQqVUotyiq3q666CqNGjcJ99913oeUhIqJsGIxGJPSZCGPJi9V28OAGuL64+7zZP4mIiCifAyIZEpecnKzuS1B08ODBcOKF7du35/ZwOHDgAAYOHIiSJUvC4XCgYcOGWLt2ba6PQ0QU6wz2okgYOBewJKht37pPVTpuIiIiKsSAqEGDBti0aZO6f/nll+OVV17Bzz//rHqNqlevnqtjnThxAldeeSUsFgvmz5+vEjW8/vrrKF68eG6LRUQUF0zlGsDR6+Pwtvur++Dft0rXMhEREcVVUoWnnnoKaWlp6r4EQddddx1atWqlenhmzJiRq2ONHj0alStXxoQJE8L7ZH4SERGdnbXxTQjsXw3vz28BAR+cU3qr9YmMyWVZbURERAUVEEnShGHDhqF///4oUqSI2lezZk38/vvvOH78uOrVCWWay6kvv/wSnTt3Rp8+fbBkyRJUrFgRd999N2677bZsn+/xeNQt5PTp0+rfYDCobnqS95ex/HqXI16wvlnX8d6urZ1fRuDAegT2LIV2+gCc026CY8h3MJjyvJpCXOF3COs7VrFts67juV0H83gdbtByOCP31ltvxaxZs9Qcol69emHo0KFo27YtLoTdblf/PvTQQyooWrNmjcpi98EHH2DQoEFnPP+5557DiBEjztj/xx9/hOc16UVOwKlTp1C0aFGVaIJY37GCbTuC6zrtMOzTOsGQ9o/a9DW9E/5WzxZ8QWMA2zXrO1axbbOu47ldp6SkoFatWuq5oQ6cfA2IhNPpxMyZM/Hpp59i2bJlanibBEYSvEjvTm5ZrVbV87RixYrwPslUJ4GRZLPLSQ+RDLmTuUi5+dAFdaKOHDmC0qVLMyBifccUtu3IruvA3hVwjr9aLdoqEu74GaaLrijgkkY/tmvWd6xi22Zdx3O7Pn36tBq1ltuAKFdjK2TdocGDB6vbzp071dyfDz/8EM8++yw6deqkepF69uyZ4+OVL18e9erVy7Svbt26mDNnTrbPt9ls6pZVKP233mTIYKSUJR6wvlnXsSi37dpY7SrYrxkN97cPq23P/EeQeOfPuR7CHI/4HcL6jlVs26zreG3Xxjxeg+f5yr1GjRp44YUXsGfPHkybNg2rVq1Sw95yQzLMZU3VLcPfJIU3ERHljLXlfTCWqavuB/athH/rbFYdERFRDl1QV8bixYvDPUYyt+hsyRDO5sEHH1SB1EsvvYQ///wTU6dOxbhx4zB8+PALKRYRUVyRRAr2a18Nb7sXPA4t4NO1TERERDEbEP3111+qZ0gyzLVr1071EL3//vs4dOiQSoaQG5deeinmzZunephkfaORI0firbfewoABA3JbLCKiuGau3QWmGu3V/eDxXfBtnKJ3kYiIiKJCjucQSTKFTz75BD/++CPKlCmjEilIQgUJjC6ErGMkNyIiurCx1fYOI5C280e17Vn0EixNBjINNxERUX71EA0cOBAOh0P16Ozfv18Nc7vQYIiIiPKPueqVMFW/Wt0PHtsB3+bcLZZNREQUj4y5GSonwZD05oQyOHTt2lUNlSMioshgb/9M+L57/iMInuZ3NBERUb4ERDJMLqulS5fC5XLl9BBERFTATNXawHxxZ3VfS/kbzml9mWCBiIgoPwKiXKzfSkREOs4lctz4GQxFK6ntwJ5lcH/7KM8HERHRhQZEsmaQpMbOSNYLslgsOT0EEREVAmNSGST0nw2YrGrbu+JteDdOY90TERFdSEBUqVIlNGnSBO+9915439atW1G5cuWcHoKIiAqJ+aLLYe/2TnjbNXcYAn9vian6926egZTXayNtYjdo7tN6F4eIiGI9IJK02xMmTMDzzz+Pjh07qiQLREQUuayX3Q5LsyHpGz4nnJN7QnOdRLTS/B54f/kIrnl3Im1yT7im3YTg0T/g//1rOOcM5dBuIiIq2HWIRJ8+fdC2bVsMHz4cDRs2xM033wyzOfMh3njjjbyVhIiI8n8+Uff3EDi0CcGD6xE89iecs25BwsDPYfg3W2i08G6YAvd3j0M7lf2Pcf6tc+Bd9hpsrTlfioiIcifX/0csUaIE6tati9TUVGzYsCHTbePGjbk9HBERFSCDxYHEgXNgcJRQ2/7fvoJn8UtRU+eazwXnnGFwzRx4ZjBkccB6xfDwpnvB4/Dv/KnwC0lERPHTQ7Rt2zbccsstOH78OL7//ntcfXX6AoBERBS5jMWrwnHTNDg/vUZShsLzwzMwVWwOS+1rEKm0gB/etePh+ekFaKcPhPeb61wHW6uHYXAUh7FEdRhsyTAklIDnp5GAFoRz2k1IumcdjMU4v5WIiPK5h+jll19Gs2bN0LhxY2zevJnBEBFRFLHU6gRbx5HpG5oG14z+CB7fjUgUPHUAaeOvhvvzu/4LhiwJcNw4CYmDvoK5eluYyjdWwZCwtX8W5lrpwZ2WdgTOKb3VfCMiIqJ8DYjefvttzJo1C5988gmSk9P/J0RERNHD1uYJmOter+5rrhNIm9JLDUmLFBLEeFa+j9QxlyCwZ3l4v5Q56Z61sF4yMNvXGYwmOPpOgaF4VbUd+OsXuL+6v9DKTUREcRIQSYrtbt26FWxpiIiowEgihYQbP4OxZE21HTy4Aa4ICRz8+39B6pv14P5yuOrlEYailZF4x3Ik3vIFTGXqnvP1xoQSSBw4FzDb1bb3lw9VIgYiIqJ8C4hKliyZ06cSEVGEMtiLImHgPDUETfjWjkfg8G+6lMW/eylc8+6Ac8ZApH14FYLHd4UfMzfohaR7N8Bc9cocH89U4RI4bvggvK2y0nHoHBERnUd05V0lIqILZirXAPYOz6VvSJKFRS8Weq0GDm5A2ied4f1lHHwbpwABX3rZLmqBxOFrkDhgNoyJuf8hztpskEq8ICQrnW/9xHwvOxERxRYGREREcch6+V0wJKQHHL5N0xA4uqPA31PTNPj3rYbv92+QNrkX4Hf/96DBCOtVDyHx9iUwV2p+Qe9ja/dM+L578Sho/wZbRERE2WFAREQUhwy2JBWAKFowPW11AfN89wTSxl4B58TroJ1Iz3BnqnQZkh7YiuQn/4Gj6+swmCwX/D7mypfCfHFndV87sYe9REREdOEB0enTp3N8IyKi6GBrcY9az0f4Nk5G4MD6Ansv7+aZ8CwZnWmfIbEUEgbMhqlsfRgTS+Xr+9naZ+glWvgMNE9qvh6fiIjibGHWYsWKwWAw5OiAgUDgQstERESFwGAvAlu7p+H+5qH0tYm+fRiJw37K8ff9eYfH/fo5PItHIfDP1kzD4yzNb4WxZA1YGvQusAVUzVVawlzvBlUGLeUQPEtfhb3jiAJ5LyIiioOAaNGiReH7e/bsweOPP47BgwejRYsWat/KlSsxceJEjBo1quBKSkRE+c56xXB4V76H4PGdCOxarAIIS/0eF3TM4Ml9cE7vj8Den894zHLJzXD0/Chfgq7zsV8zGqm/fw0E/fAsexXWS4cVWABGREQxHhC1adMmfP/555/HG2+8gX79+oX3XX/99WjYsCHGjRuHQYMGFUxJiYgo3xnMVtivfQXOKb3UtuvLe2Gu0U6l584L3/YFcM0cCM157L/3KF5NzVkyVWgKR/f3CyUYEqbStdIDvhVvAz4XXJ/fhYRBXxXa+xMRUYwmVZDeoObNz8wAJPt++eWX/CoXEREVEnP9Hv8lITh9AK5vH831MbRgAO6Fz8I5sUs4GDIUr4qEW75C8qM7kXz/ZiT0+RQGa/r6R4XF3uFZGJLLqfv+7d/At3Fqob4/ERHFYEBUuXJlfPTRR2fsHz9+vHqMiIiii/SYOHp8CFiT1LZvzUfw/f5tjucK+bbOQeo7jeH56Xk1F0nIWkDJ966Hpe51uvbISNIIR/ex4W33V/epIX1ERES5GjKX0ZtvvolevXph/vz5uPzyy9U+6RnasWMH5syZk9vDERFRBDAWrwL7NS/D/eU9aluGvZnuWQtjiepnfY3mPgXn7KHwb5v7306DEfbOL8Ha6lEYjJGxsoOl/g2wNLwRvi0zobmOwzmlNxzDFutdLCIiihC5/r9Vly5d8Mcff6Bbt244fvy4usl92SePERFR9C7Waq7XXd3XXCfU4qma13nG87RgEL4ts5E6plmmYMhU+Qok3r4Utjb/FzHBUIj9hrFqLpMI/LUGnq/v17tIREQUrT1EQobGvfTSS/lfGiIi0o0EMQl9JiL13UsRPLYDwUMbVSICR59PVYDk/mI4fL99AQR8KnNbmL0YEnqNh7l+z4hNWGBMKIHEgXOQOralSgHuWzsepqJ1gXYP6F00IiLSWZ5+wlu2bBkGDhyIli1b4sCBA2rfpEmTsHz58vwuHxERFSLJLpcwcC5gSU9+4NvwGVzTbkLqmKbwbZ6usrVlDIZMVa9KnyvUoFfEBkMhpgqXpM+V+pdl8f8Q+GutrmUiIqIoDIhknlDnzp3hcDiwfv16eDwetf/UqVPsNSIiigGmcg3g6P1JeFvNvTm5N33DXgzGCk1hrt0FCUMWqCFyxhLpQ9GigbXpLbBecbe6bwh44P5yuN5FIiKiaAuIXnjhBXzwwQcq05zFYgnvv/LKK1WARERE0c/aqC9sbR7PtE/1Bj2wBcn3rkPi4G9gqdU54nuFsmPv+iaMZRuq+8EDaxE4wP93ERHFs1zPIdq+fTtat259xv6iRYvi5MmT+VUuIiLSma3zS7A0Hwp4UgBrIoylakVlAJTdYrSWK+6C54v0niLv2o/hqNhU72IREVG09BCVK1cOf/755xn7Zf5Q9epnT89KRETRRYIfU6mLYarYFKbStWMiGAqxNOoHzexQ970bp2SbTY+IiOJDrgOi2267Dffffz9Wr16t/ud48OBBTJkyBY888gjuuuuugiklERFRPjLYiyBQKz3FONyn0hNGEBFRXMr1kLnHH38cwWAQ7du3h9PpVMPnbDabCojuvffegiklERFRPgvU7w/zr+mBkPvbR2Gu0Q7G4lVZz0REcSbXPUTSK/Tkk0+qBVm3bt2KVatW4ciRIxg5cmTBlJCIiKgABMs3h7lON3Vfcx1PX4hW0ooTEVFcyXVANHToUKSkpMBqtaJevXq47LLLkJSUhLS0NPUYERFRVDAYYO/9KYwla6rN4MH1cH0xHJqm6V0yIiKK5IBo4sSJcLnO/AVN9n322Wf5VS4iIqICZ3AUy7wQ7boJ8P4yjjVPRBRHchwQnT59Wi2+Kr+cSQ+RbIduJ06cwLfffosyZcrk6s2fe+45NQQv461OnTp5+RxERER5YirXEI6e48Pb7q/uhX/fatYmEVGcyHFShWLFioWDllq1ap3xuOwfMWJErgtQv359/PDDD/8VyJzrPA9EREQXxNqkHwL7V8G74h0g4INzam8k3bMOxqTc/dBHRETRJ8fRx6JFi1TvULt27TBnzhyUKFEi/JjMJ6pSpQoqVKiQ+wKYzWpto5zweDzqFiK9U0Ky3slNT/L+Uj96lyNesL5Z17GI7VrfurZe8woCB9YjsHc5tFN/wTntJjgGL4DBxB/qCqK+qWCwrgsP6zry6jqv3zE5/pZv06aN+nf37t246KKL8m2Bvh07dqhAym63o0WLFhg1apQ6fnbksex6oSTLndvthp7kBISGFBqNuZ6aRazviMW2zbqOq3bd8V3Yp3aCwXkYgV2LcOKLB+G/6mk9ixoT+D3Cuo5FbNeRV9cyrScvDFou0+lMmDBBZZXr06dPpv2zZs1S6xINGjQox8eaP38+UlNTUbt2bRw6dEgFOwcOHFDpvJOTk3PUQ1S5cmU1h6lIkSLQ+0RJYFa6dGkGRKzvmMK2zbqOt3bt3/szXOPbAUG/2rb3mwFLg946lTQ28HuEdR2L2K4jr64lNihevLgKnnITG+R6HID00nz44Ydn7JeECrfffnuuAqJrr702fL9Ro0a4/PLL1dC7mTNn4tZbbz3j+bIArNyykoqJhF4Z6TWLlLLEA9Y36zoWsV3rX9fWaq2gdX0D7q/uU9ueL++BtV53GMxn/v+HLry+Kf+xrgsP6zqy6jqv3y+5ftW+fftQrVq1M/ZLICOPXQhJ3CAJG/78888LOg4REdGFsLa4B+a6/y7amnYE/t++ZIUSEcWoXAdE0hO0efPmM/Zv2rQJJUuWvKDCyPC5nTt3onz58hd0HCIiogv9JdLW8v7wtnfNf2m5iYgozgOifv364b777lNZ5wKBgLr99NNPuP/++3HTTTfl6liPPPIIlixZgj179mDFihXo0aMHTCaTeg8iIiI9mapfDWOJ6uq+/8+FCJ7YwxNCRBSDch0QjRw5Us31ad++PRwOh7p16tRJpeN+6aWXcnWsv/76SwU/klThxhtvVD1Mq1atUhOmiIiI9GQwGmFp/u98Vk2D95dxPCFERDEo10kVZM2hGTNmqMBIhslJQNSwYUM1hyi3pk+fnuvXEBERFRZrsyHw/PAMEAzAs/RVmOtcB3OVljwBREQxJM+rzUnyA7kRERHFKmOR8rBe9TC8S19RabidU3oj6d71MCbnbEFxIiKK0YBIhrp9+eWXKquc1+vN9Ngbb7yRX2UjIiLSnb3Tiwj89QsCuxZDSzkE59QbkTjsRxhMFr2LRkREegREP/74I66//npUr14dv//+Oxo0aKCSIsj6rk2bNs2PMhEREUUMg8mMhH4zkDqmKbTTBxDYswzu+Y/Bcd2beheNiIj0SKrwxBNPqOxwW7Zsgd1ux5w5c7B//360adMGffr0yY8yERERRRRjUhkkDJgN/Nsr5P35LXg3cR4sEVFcBkS//fYbbrnlFnXfbDbD5XIhKSkJzz//PEaPHl0QZSQiItKd+aIrYO/2TnjbNedWBP7eqmuZiIhIh4AoMTExPG9IFlCVhVRDjh49mg9FIiIiikzWy+6Apdng9A2fE87JPaG5T+ldLCIiKsyA6IorrsDy5cvV/S5duuDhhx/Giy++iKFDh6rHiIiIYpXBYICj+/swVrhEbQeP7YBz5i3QgkG9i0ZERIUVEEkWOVmYVYwYMUIt0CrrElWtWhUff/xxXstBREQUFQwWBxIHzIHBUVxt+3/7Ep4lo/QuFhERFUaWuUAgoFJuN2rUKDx87oMPPsjrexMREUUlY4lqcPSdCufELoCmwfPDc7A2HwZjclm9i0ZERAXZQ2QymdCpUyecOHEit+9DREQUUyy1r4G15f3pG0E/fJtn6F0kIiIqjCFzsu7Qrl278vJeREREMcV66bDwfd/GKbqWhYiICikgeuGFF9Q6RF9//TUOHTqE06dPZ7oRERHFC1PZ+jCWb6LuB/76BYGjO/QuEhERFeQcolBmOXH99derbDshmqapbZlnREREFC+sTQbAfWijuu/bOBWmDs/qXSQiIirIgGjRokW5fQkREVHMsjTuB/eCx1RyBe/qsbBedjuMRcrrXSwiIiqogKhatWqoXLlypt6hUA/R/v37c3s4IiKiqGYsWhHmut3h//VzaKn/wDntRiQO+wkGk0XvohERUUHMIZKA6MiRI2fsP378uHqMiIgo3jh6fAhD0UrqfmDPcri/fVTvIhERUUEFRKG5QlmlpqbCbrfn9nBERERRz5hUBgn9ZwMmq9r2rngb3o3T9C4WERHl55C5hx56SP0rwdDTTz+NhISE8GOSSGH16tVo0iQ90w4REVG8MV90Oezd3oH78zvVtmvuMJjKNYCpXEO9i0ZERPkREG3YsCHcQ7RlyxZYrem/ggm537hxY5WOm4iIKF5JQoXA/tXwrZsA+JxwTuqBpHvWwuAopnfRiIjoQgOiUHa5IUOG4O2330aRIkVy+lIiIqK4IKMoHN3fQ+DQJgQPrkfw+E44ZwxEQv8ZMFgT9S4eERHlxxyiV1555azBkPQcERERxTODxYHEgXNgcJRQ2/7t3yDl1erw/vKR3kUjIqL8CIgaNmyIb7755oz9r732Gi677LLcHo6IiCjmGItXhaPf9HCSBS31MFzzbod3/Wd6F42IiC40IJLkCr169cJdd90Fl8uFAwcOoH379qrnaOrUqbk9HBERUUyyXNwRSfdtgqXhjeF9rnl3IHBwo67lIiKiCwyIHnvsMaxcuRLLli1Do0aN1M1ms2Hz5s3o0aNHbg9HREQUs0xl6qj5Q5JsQfG7kTbhGvh3LdG7aERElNeASNSsWRMNGjTAnj17cPr0afTt2xflypXLy6GIiIhinqTjNlW6VN3XUv9B2vh2cH37CIKpZy50TkREER4Q/fzzz6pXaMeOHapXaOzYsbj33ntVUHTixImCKSUREVEUM5htSBj8Lcw1O6Tv0ILwLnv932QL49SSFkREFCUBUbt27VTws2rVKtStWxfDhg1TaxTt27dPJVwgIiKibP6Hm1gKCUMWwNZhBGC2pe/0pqp5Ra6Zt7C3iIgoWgKi77//Hi+//DIsFkt4X40aNVTP0R133JHf5SMiIooZBqMJ9vbPIPmRnbBcOiy837dxMlJerQb3j89DCwZ1LSMRUbzJdUDUpk2b7A9kNOLpp5/OjzIRERHFNGPRikjo+REc/WYA1qT0nd40eH54Ft6VY/QuHhFRXMlxQNSlSxecOnUqvC29RCdPngxvHzt2DPXq1cv/EhIREcUoa6Mbkfzwdlhb3BPe5/7ufwge36VruYiI4kmOA6LvvvsOHo8nvP3SSy/h+PHj4W2/34/t27fnfwmJiIhimLFIBTiuHwPrFXen7/A54Zw+AIEj/H8qEVFEBURZM+AwIw4REVH+sV/zMgzFLlL3A/tXIfXNenB9dT80/38/RhIRUYSsQ0RERET5y2BLRsJN02FILPVfau4V7yDtw1YIntzH6iYi0jsgMhgM6pZ1HxEREeUPc5UWSH50F2ydXgin5g78tQZpn3SG5klhNRMRFQBzTp8oQ+QGDx4Mmy39C9rtduPOO+9EYmKi2s44v4iIiIjy3lNkv/pJWGp3QdrkXtBO7EbwyO9wzh6ChP6zYvrHSLnWCB7dodZnysqQXE7NtyIi0i0gGjRoUKbtgQMHnvGcW265Jc8Fkax1TzzxBO6//3689dZbeT4OERFRLDBVuASJQ79H6nvNAfcp+LfOgfOTTrB1fAHmiy5HrPH98T08C59G4K9fzvocS8M+sDQdDIPFDlPF5jDYixRqGYkozgOiCRMmFFgh1qxZgw8//BCNGjUqsPcgIiKKNqZSNZFw42Q4P+umtv1//qButjaPw9ZxJAymHP9vPGJpXidcXw6Hb92n532ub8ssdVPsRZHQZyIs9boXfCGJKKbp/k2ampqKAQMG4KOPPsILL7ygd3GIiIgiiqXudUgYMBuubx9Vw+eEZ8nL8O9ZBnuX12C+6ApEm8CB9XAvfkn9C89paM5j4ceM5RrCXLVV5hcE/fD9+jm01MP/7XOfgnPSDTAUryoD6jI93Vi0EmxXPQRzve4xPcSQiGIkIBo+fDi6du2KDh06nDcgknlKGecqnT59Wv0bDAbVTU/y/mrss87liBesb9Z1LGK7Zl2fjaleDyTW6grvirfhXfgkEAwgsPdnpI1tAXODXrDf8CEMjuKI9LYdcJ2C6+v74N84+cwnWRJg7/YOzJcMgsF4Zs4n67WvwbdpKrST+xE4tBGB7d+o/dqJPWc8N3BiN5x7lsFY+XI4+kyCsWQNxAt+j7Cu47ldB/N4Ha5rQDR9+nSsX79eDZnLiVGjRmHEiBFn7D9y5IhK8qAnOQGnTp1SJ8uYzRc5sb6jFds26zoWRW27rjMIxiJ1Yfn+PhhP7VW7ZG7R6X1r4L3uY2ilGyDSGE7tg/G3WQimHEPqwaUwntwZfkyzJAJmB4Kl6sLXZiRcJWsDR4+e/WBVugNVADTSYCo/AeaNH8PgSf9x9L+DBmBwn1B3g/tXI/Xd5gjU6wvNmOWSx1EC/ro3AollEEuitm1HIdZ15NV1SkresnEaNJ1WWN2/fz+aN2+OhQsXhucOtW3bFk2aNDlrUoXseogqV66MEydOoEiRIrqfKAnMSpcuzS8g1ndMYdtmXceiaG/XWsAH3/pP4fnuf4DruNpnSCiFhOFrYSxWGZFAc52E57sn4Fv3iRrylomtCGydXoSl+a0w/JtePN/eV3qitn8D9/xHoR3949xPtjhgbXEvrO2egcHiQCyI9rYdTVjXkVfXEhsUL15cBU+5iQ106yFat24dDh8+jKZNm4b3BQIBLF26FO+++64KfEwmU6bXSMrvUNrvjKRiIuGPXsYpR0pZ4gHrm3Udi9iuWdc5YrTBdPkdsNa+Fs4pvdVaRZrzKNzTbkTiHUvzPcjIKc19GoEjv0NLOwrXl/eE5zxlKnr5JmpOlKkAh7GZ6l0PS42r4ZozDL4tM8/+RJ8L3qWvwL/jezi6vqGG7WUkWeyMpetE3Twkfo+wrmORIQfX2Xm9BtctIGrfvj22bNmSad+QIUNQp04d/N///d8ZwRARERFlZix2ERKGLFDDwiT4kJTVqWNbwN5xJMy1uxTahbzqDVr2Ojw/v3XmGkK2ZFhbPoCUkk1RvEwlmCs2zXaOUEGs55TQfwYCR0ZCSzucpcBB+LbNg3f1WMDvQfDQRqSNb5ftcUyVLlMZ/Sy1OhV4mYlIH7oFRMnJyWjQIPNYZ1nktWTJkmfsJyIiouwZE0ogceAcpI5tCfjdCB7cAOfE62BpMgCOHh/CYE1fQL2g+PeuhHPajdBO/ZVtMJEwYBZQpBJOHT4MU5kyhRIMZSpD6VqA3LIwV2sNa/Nb4ZzaG8Ej28/6egkynRM6w9J8KBzXvxszQ+uIKIKyzBEREVE+LOJ660K4vrofwYPr1T7fxikIHFgH+7WvwFznunzrLdJ8bnjXfKRumusEtJRDKutdekEssDS8Uc1nMpapA2uzoTCYrRGbgdVUrgGShq+Bd814BE+kJ6n4jwb/rkUI/p0+msW39hP4t80DQgGm0QxzzY6wX/0/GFXqbyKKVhEVEC1evFjvIhAREUUlc9WrkHTPWvg2ToXr8zvV0LXgkd/h/Ox6mKpciYS+U2AsLina8s6/azGcM2+Bdmr/GY+ZqrZCwo2fRV1wIEPrbFc9mO1jWjAI3/qJaj4UfE4VAEJu//Kt+Qi+dRPSF8rt8BwMRg73J4pGERUQERERUd5JL5D1kgEwVWoO18ybVbIFIWsWpY5pCsdNU2Gp1TlHxwoc2gTvxilAwKe2NfcpFRzI/Jvw+xWpAIPZAcslA2G7+ikYTLF1WSHD+6zNh8BU+TK4v34AgcO/hR9TwZHPqTLoeRa9AP++FUi4aRqMSbGVxpsoHsTWNxcRERHBVLo2Eu9eDf9vX8L19YMq4YLmOg7npO5IvGM5zJWan7OWAsd2InVcW8B9MtvHTdWvhqPr62qoXjwwla2vhiRmJAGRZ+lr8Cwdnb5Q7s6fkDrmEiT0m6F664goejA/NBERUYz2FlnqdUfyvethrtstfaffA+eUXgimZV78NJjyD/x7lqffdi+Dc3LP7IMhgxG29s+p4CBegqGzMTiKw975RSQOWwRDcnm1Tzt9EGnj2sA5ewiCx3fpXUQiyiH2EBEREcUwg6MYEvrPRtpHbRHYtxLayX1I+6SzykxnKHoRPEtehmfh05mGwoXIGjyOnuOBf+fGyPwgY3I5HT5F5DJXa4WkezfAOaO/6iVSKb3XfQrfpmkqK51afDbK1jEiijcMiIiIiGKcZHpL6D8Lqe82hZZ6WGWiS3mrIQwJJaGdzJpd7V/WJCQMnAtTmbqFXdyoY0wui8Sh38O77HW4F49K713ze+Caexv8f/4AW6cXC3QhWiK6MAyIiIiI4oCxaEUk3voDnJN6IHh8p8pCp4UWUZXhdU0HqwBJbRrNsDTszWAoFyTDnK3NY7BefgfcC55IX/RVMtFtngHf1tmwXvkA7J1eUsEpEUUWBkRERERxwlSuIZLuXQfX1w/A/+uX0IJ+NQzO3uU1WC7uqHfxYoLBXhSOG95XacjdXw5Pz0YXDKjeo8DeFXD0+QymUjX1LiYRZcCAiIiIKM4u2BN6T9C7GDHP2qQfLHW6wLP8TXhkGF3Aq+Zwpb5ZR/XG2a95GcbEUnoXk4iYZY6IiIio4IJPe4fnkHjnzzCEFqwNBuBb+7FK0e3ft4pVTxQBmHabiIiIqADJuk/J922CrcPzgL2o2qed+gtpH14F5+yhCB7fzfon0hEDIiIiIqICZrAXgb3900h+8DeYqrX+r7do3QSkvFUf3nUTeQ6IdMKAiIiIiKiwLryKlEfirT/C1vklwF4sfafPBdfswXBO788FXYl0wICIiIiIqBAZTGbY2z6BIo/thuXS28L7ZTHXlNdrw73gcWgBH88JUSFhQERERESkA4OjGBJ6jlOpuMO9RUE/PEtGI218OwSO7eR5ISoEDIiIiIiIdGRtejOK/N8e2No9DZgsal9gz3KkvlEbzrm3I+g8zvNDVIAYEBERERFFQorujs8j8falMBSt/F/ShTUfIXVMU/j3r9G7iEQxiwERERERUYQwX3QFkh/YClv75wBbEbVPO7kXaR+0gHPOMARP7NW7iEQxhwERERERUaSl6O7wLJIf3AZTlZaZFnRNebMevBun6l1EopjCgIiIiIgoAhmLVkLibYth6/RCeEFX+JxwzRgA54ybuaArUT5hQEREREQUoQwmC+xXP4kij+2BpdmQ8H7fxslIeb0W3N8/BS3g17WMRNGOARERERFRNKTo7v0JHL0+/q+3SFJ0L3oRaZ90RDDlb72LSBS1GBARERERRQlr86Gqt8h29ZOA0aT2BXYtRuqYS+DfvVTv4hFFJQZERERERFHWW2Tv9IKaX2QoUkHt01L+RtpHV8M1ewgMp5iJjig3GBARERERRSFz1auQdO8GmGt2SN+hBeHf8Blsk9rA+8s4aJqmdxGJooJZ7wIQERERUd4Yk8ogYcgCeJe/Ac/iUdBcJ2AIeOD54i74lr8BmG3Zv65oJVivfBDmizvCYDCw+imuMSAiIiIiimIGowm21o/CetntcH33JHyr3lP7g8d2nPU1wX+2wv/HApiqt0VCn4kwFruoEEtMFFkYEBERERHFAIO9KOzd3kFa8Uaw/fIatJSD2T8xGAD87gwJGZrCevmdgNFy/jcxmmCu1gbmaq3yufRE+mFARERERBRDArWuR9JVw2A0Zj9VXAsG4ds6G+75j0E7uRea85hK351THkD1LJnKNYIhoaTKfCdD8IiiFQMiIiIiojhiMBphbXQjLBd3hHPWIPh/+yrXx5CeJbkJ74p34OgxDsbStc/9vvaiDJwoIjEgIiIiIopDBkdxJNz8BYKHNiKY8k+OXqOd/gueJaMRPPbnf/ucx+Cc0itHrzdf3Am2jiNhrnxZnstNlN8YEBERERHFKckwZ6pwCdKXeM0ZS9PBCB7eBs3ngmfxS7nqYfLv+B7+PxfC0WcSrJcMyFOZifIbAyIiIiIiyjGDyQxT+cbqvmng5/BtnAz/nmXAOdc90uDf+RO0E3vU81xzh8FUtj5MFZqw5kl3DIiIiIiIKO/zkZreom7no/m9cH1+J3zrJqgsd2mTeyL5vg1qbhGRnrJPP0JERERElI8MZiscN4yFqVL6/CHtxG54fn6bdUy6Y0BERERERIXCYLbBcdNUtZ6R8Cx/E5r7NGufdMWAiIiIiIgKjalkDVguuTl9w30SnlXvsfYpfgOisWPHolGjRihSpIi6tWjRAvPnz9ezSERERERUwGxt/ycTkNR977LXoXlSWecUnwFRpUqV8PLLL2PdunVYu3Yt2rVrh+7du2Pbtm16FouIiIiICpCp1MWwNO4XXsfIu/oD1jfpRteAqFu3bujSpQsuvvhi1KpVCy+++CKSkpKwatUqPYtFRERERAXMdvWTshCSuu9Z9io0r5N1TvGddjsQCGDWrFlIS0tTQ+ey4/F41C3k9On0SXjBYFDd9CTvr2ma7uWIF6xv1nUsYrtmXccqtm3WdXYMpWrD3KA3/FtmQUs9DM8v42BteR+iBdt15NV1Xq/DdQ+ItmzZogIgt9uteofmzZuHevXqZfvcUaNGYcSIEWfsP3LkiHq9nuQEnDp1Sp0so5G5KljfsYNtm3Udi9iuWd+xKtratqHRXbBvmaXuu38aiZNlWwPJFRANoq2uo1kwh3WdkpKSp+MbNDmyjrxeL/bt26c+5OzZszF+/HgsWbIk26Aoux6iypUr48SJEyopg94nSgKz0qVL84+C9R1T2LZZ17GI7Zr1HauisW27pvWFf+tsdd9Y+QokDPtJpeeOdNFY19EqmMO6ltigePHiKq7ITWygew+R1WpFzZo11f1mzZphzZo1ePvtt/Hhhx+e8VybzaZuWUnFREJDNBgMEVOWeMD6Zl3HIrZr1nWsYttmXZ+N44YPkPrXGmgn9yK4fxW8PzwDR5dXEQ3YriOrrvN6DW6MxAgwYy8QEREREcUuY2JJJA6cC/zbK+RdPRaaJ29Dn4iiLiB64oknsHTpUuzZs0fNJZLtxYsXY8CAAXoWi4iIiIgKkaliU1ibDk7f8KbBt3kG65/iIyA6fPgwbrnlFtSuXRvt27dXw+W+++47dOzYUc9iEREREVEhs1w6LHzfu2Y8658Kja5ziD7++GM9356IiIiIIoSpYjMYyzdG8NAmBPavRuDvLTCVa6h3sSgORNwcIiIiIiKKPzJp3nrpbeFt9/dPqTTLRAWNARERERERRQRrkwEwOEqo+/7fvoR36St6F4niAAMiIiIiIooIBkcxOG6cJN1Fatv93f/g37dK72JRjGNAREREREQRw1KnC2ztnk3f0ILw/vyW3kWiGMeAiIiIiIgiiq3tEzAkllb3fdvmIZh2VO8iUQxjQEREREREEcVgtsLSdFD6RsAL34ZJeheJYhgDIiIiIiKKONbmt2Zal4gZ56igMCAiIiIioohjKlMHpqqt1P3g4V/h2zhV7yJRjGJAREREREQRydbyvvB917zb1WKtRPmNARERERERRSRzg16wNBuSvuFzwjmlN7SAT+9iUYxhQEREREREEclgMMDR/T0YKzRV28Gjf8D/+zd6F4tiDAMiIiIiIopYBosD9s4vhbe9az7StTwUexgQEREREVFEM9fsAEOxi9R9/x8LEDy5X+8iUQxhQEREREREEc1gNMHabGj6hhaEd92neheJYggDIiIiIiKKeNbmQ2VSkbrvXTkGwVMH9C4SxQgGREREREQU8YzFKsNcv5e6r6UdgXNqH2h+r97FohjAgIiIiIiIooLjhrHhuUSBfSvhXvi03kWiGMCAiIiIiIiigjGxFBIHzgXMNrXtXfEOgil/610sinIMiIiIiIgoapgqNoO1xT3pG343PMte07tIFOUYEBERERFRVLG1egQw29V976qxCKYe0btIFMUYEBERERFRVDEml4P10tvSN3xOeJaO1rtIFMUYEBERERFR1LG1eey/XqIVYxA8vguxStM0lWY8cHRH+MZesfxjzsdjEREREREVCmPRSrBd9SA8i0cBAS/cCx5HQv+ZMVn77m8fgXf5G2fsN9fvCXuHETCVa6BLuWIFe4iIiIiIKCrZ2jwOQ1IZdd+3ZRZ8OxYi1njXTcw2GBL+bXOR+k5juBe9CC0YLPSyxQoGREREREQUlQz2IrB3HBneds3oj+DJ/YgFEuB4N06D6/M7w/vM9W6ApclAWJoMgCG5XOiJ8Hz/FFJfvxgp71wC15f3xkwdFBYOmSMiIiKiqGVpPgy+bZ/D/8d8aGlH4ZzSG4l3/gyDKXovcyWgSfvsegQPbQzvs152Bxw9Pghvaz4XPItfhmfRSJlkFJ5D5T20Ed5fxqneM1v7Z2AwmnT5DNGEPUREREREFLUMRiMcfSfDULya2g789Qv8279BtNJ8bjgn98wUDJlrd4W929uZnmewOGDvOAKJQ7+HsWx9wOIAQsFPwAvPT88jbXx7uH8cCc+qsdBcJwv7o0QNBkREREREFNWMCSXguH5MeNu3cQqiNZuc68t7EDiwVm0bildFwtDvkTDoKxjMtmxfY67ZAckPbEXR551I/t8/sLZ+LBwYBXYvgeeHZ+D+4m6cfqUa3IteghbwFepnigYMiIiIiIgo6pkv7gxDYml13/fbl9DcpxBNpLzOKb3gW/tx+g6LA4k3fw7LxR1hMBhydAxjYkk4rh2NxGGLYEgun/lB90l4vn8SaR+1ReDAOpW6WwIwYkBERERERDFA5gxZGt2UvuH3wLd1LqJF4OBGpI5pBv+2eeF9jh4fwVS+cZ6OZ67WCsmP/InEWxci4ZavYGk+9L9eo70rkPpuc6S+XgupbzdE4J9tiHfsISIiIiKimCDZ10K8GycjGkgmudSxVyB4fKfaNjiKI2HQ17Be8t9nyQuDNUENp7PUvQ4JvT5G4p0rYCh2UabnBP/ZhtT3LoPn57fV3KV4xYCIiIiIiGKCqfJlMJaooe4Hdv6k1iaKZP69K+CadYvq0RKmis2RdO96WOp0zff3Mle+DEn3rIet/XOwNBuSnohB+Jxwf/0AUkZXRsqb9ZA6vn04Y128YEBERERERDFB5trY2j4e3nbOHhKxQ8KCpw6oFOEI+tW2pdlgJN65HMbiVQvsPWWOkb3Ds0jo/QmShq+B9bLbw49JyvLg4d9UICkpvzVPKuIFAyIiIiIiihmW5rfCcsnN6RveNLhmD0Uk0fweuL9/Gilv1IaWckjtM1Vvq+YMnS2TXEGQtN2OHh+qHilZ8BX2YoDJEh5KlzbpBrgXPgv/rsWIdQyIiIiIiCimeokcN3wAY5m64XWJAgfWI2LSas8eAs+iF1SwJgxFKyHhpum6LSRrqnAJEm+eh6LPnkDS/VsAW7LaH9j5Y/paRh9dDddX90PzexGrdA2IRo0ahUsvvRTJyckoU6YMbrjhBmzfvl3PIhERERFRlJOEArYrHwhve9eMRyTwrngHvk3T0jdMFlivuFsNXTMml0UkMJWujYQbJ/23wGuGcqeOuQTezTMQOLQZwdPpPVuxQteAaMmSJRg+fDhWrVqFhQsXwufzoVOnTkhLS4+YiYiIiIjyQqXgtiSo+96NU6B5nbr2DHl/GQf3t4+E90mvkKP7ezAml0MksdTrjqQHf1cLwtq7vA6YrGp/8PCvcE27CanvNEbKqApwzr09ZjLT6dM3968FCxZk2v70009VT9G6devQunVr3cpFRERERNHNYC8CS6O+8K2bAHhOq4xz1maDCr0cweO74f7uCfg2zwjvs7X5P1ga9ESkMpWqqW64uCPM1dvC9cVwBPavyvQc35qPEPhrDRzd3oa5WnRft+saEGV16lT6isIlSpTI9nGPx6NuIadPn1b/BoNBddOTvL9E/3qXI16wvlnXsYjtmnUdq9i2Wdd6JlhQAREA94LHYazRAcYi5QulXateoR9HwLtkVDiTnCpTi3th6TAyaq4ZDeWbwHHHcgR2fAf/9m9Vmm7f5umAz4XgoY1IG9cGphrtYevwPEwXXaHrd0he6zRiAiL5AA888ACuvPJKNGjQ4KxzjkaMGHHG/iNHjsDtdutefgno5GQZjcxVwfqOHWzbrOtYxHbN+o5VbNtZ2KrDelFrmPYthZb6N05P6glvz9nhbGoFWdemrZNhXTQyvK3ZisLX7hW4al0PHD2GqFOsKXB5U3XXUOcWWBfcCeOx7eEEDKdKNYHfXr1A3jqn7TolJSVPxzdocuQIcNddd2H+/PlYvnw5KlWqlOMeosqVK+PEiRMoUqQI9CQnSgKz0qVLMyBifccUtm3WdSxiu2Z9xyq27WzqJO0InO81h3bqL7Vtu/Y1WK96sEDrOrB/NZwftQUC6ZnZrK3/D9bWj8HgKIZYoQX88G+aojLmac7jSHpkZ4F9vpy2a4kNihcvroKn3MQGEdFDdM899+Drr7/G0qVLzxoMCZvNpm5ZScVEQq+MpHmMlLLEA9Y36zoWsV2zrmMV2zbrWi+SwS2h/2ykjU0fzuX75UPYWj2k2mRBtGvvxmlwzbvtv2Co5X1wXPsyYo7RClPzIbBeMlCtW2RKzH7KS2F+h+T1GlzXK3fpnJJgaN68efjpp59QrVo1PYtDRERERDHIfNHlMNVop+4Hj+1AYPfSAnkfz5JX4JrRP7zGkKlaa9i7vIZYZjBZYKrQBNFM14BIUm5PnjwZU6dOVWsR/f333+rmcrn0LBYRERERxRhr82EFui6R74/v4P7u8fC2pekgJA6erwIGimy6BkRjx45VY/zatm2L8uXLh28zZvyXlpCIiIiI6EJZ6veAwZE+rMu3dTaCzuP5NuJJgiHX9P6yofbZ2j8LR+8JaoFYiny6ziGKkHwORERERBTjDBY7LJfcDO+KtwG/G+7P74Kj3/QLm0vkOQ3XhIEqy1qIuW432No9ky9zlKhwcPY/EREREcUF21UPALb07GO+LTPhXf7mBR3PsmxEpmDIVPlyJPT5DAYm2IoqDIiIiIiIKC4Yi1dFwo2fhbfdCx5D4OiOPB3L/+cPMG+bmr5hS0ZC/5lIvHNFTKXWjhcMiIiIiIgobljqdVdrAinBADyLX8r1+jvedZ/CPWtQeJ/92ldgadiHPUNRigEREREREcUV+9VPwuAoru77NkxC8PiuHL1OnifrGblmD4GW+rfaZ6rWFtZLby/Q8lLBYkBERERERHHFYC8C65UPpG8EA3AvfjlHQ+RSxjRD4MC68L5Albaw953CnqEox4CIiIiIiOKOreV9/yVYWDcBgSN/nPW5gSPbkTa5J+A+qbaNJWvCMWwRvDdMgzG5XKGVmQoGAyIiIiIiijuS/MB21UPpG0G/SrCQHc19Ck4JhjwpattcuwuS7lkLc7XWhVlcKkAMiIiIiIgoLtlaPwJDkQrqvv/XL+DftTj8mBYMwrPsDaS8VhPBw7+qfcay9ZHQbwYM9qK6lZnyHwMiIiIiIopLBmsi7B1fCG+75t0BzX1a3Xd/9zjc3z4MLe1o+oP2YkgYOA8GW5JexaUCwoCIiIiIiOKWpektMFVspu4Hj/4B5+zB8K4ZD+/SV9OfYDDA0ri/GiZnKnWxvoWlAsGAiIiIiIjilsFogqPfDNUDJPzb5sE197bw4/br3kHCTVNgKllDx1JSQWJARERERERxTYKdhL6Tz9hvaTIQ1hbDdSkTFR5zIb4XEREREVFEstTpquYI+bZ/KxkVYCx2EWytH4PBYNC7aFTAGBAREREREUlQVP8GdaP4wiFzREREREQUtxgQERERERFR3GJAREREREREcYsBERERERERxS0GREREREREFLcYEBERERERUdxiQERERERERHGLAREREREREcUtBkRERERERBS3GBAREREREVHcYkBERERERERxiwERERERERHFLQZEREREREQUtxgQERERERFR3DIjimmapv49ffq03kVBMBhESkoK7HY7jEbGmazv2MG2zbqORWzXrO9YxbbNuo7ndn3635ggFCPERUAkFSMqV66sd1GIiIiIiChCYoSiRYvm+PkGLbchVIRFiwcPHkRycjIMBoOuZZGIVAKz/fv3o0iRIrqWJR6wvlnXsYjtmnUdq9i2WdexiO068upawhoJhipUqJCrEVtR3UMkH7RSpUqIJHKSGBCxvmMR2zbrOhaxXbO+YxXbNus6Xtt10Vz0DIVwsgsREREREcUtBkRERERERBS3GBDlE5vNhmeffVb9SwWP9V14WNes61jEds36jlVs26zrWGQr4OvsqE6qQEREREREdCHYQ0RERERERHGLAREREREREcUtBkRERERERBS3GBAREREREVHcYkCUT9577z1UrVoVdrsdl19+OX755Zf8OnTceu6552AwGDLd6tSpE37c7XZj+PDhKFmyJJKSktCrVy/8888/upY5WixduhTdunVTKzlLvX7++eeZHpdcK8888wzKly8Ph8OBDh06YMeOHZmec/z4cQwYMEAtkFasWDHceuutSE1NLeRPEhv1PXjw4DPa+jXXXJPpOazv8xs1ahQuvfRSJCcno0yZMrjhhhuwffv2TM/JyffGvn370LVrVyQkJKjjPProo/D7/RfQAuK3vtu2bXtG277zzjszPYf1fX5jx45Fo0aNwotStmjRAvPnzw8/znZdeHXNNl1wXn75ZfUd8cADDxR622ZAlA9mzJiBhx56SKUDXL9+PRo3bozOnTvj8OHD+XH4uFa/fn0cOnQofFu+fHn4sQcffBBfffUVZs2ahSVLluDgwYPo2bOnruWNFmlpaaqdSiCfnVdeeQXvvPMOPvjgA6xevRqJiYmqTcsXU4gEQ9u2bcPChQvx9ddfq4v+22+/vRA/RezUt5AAKGNbnzZtWqbHWd/nJ98D8j/OVatWqXbp8/nQqVMnVf85/d4IBALqf6xerxcrVqzAxIkT8emnn6ofCCj39S1uu+22TG1bvl9Y37lTqVIldbG4bt06rF27Fu3atUP37t3VdzDbdeHWtWCbzn9r1qzBhx9+qILRjArtO1vSbtOFueyyy7Thw4eHtwOBgFahQgVt1KhRrNoL8Oyzz2qNGzfO9rGTJ09qFotFmzVrVnjfb7/9JinktZUrV7Lec0HqbN68eeHtYDColStXTnv11Vcz1bfNZtOmTZumtn/99Vf1ujVr1oSfM3/+fM1gMGgHDhxg/eeivsWgQYO07t27n/U1rO+8OXz4sKrvJUuW5Ph749tvv9WMRqP2999/h58zduxYrUiRIprH42HbzkV9izZt2mj333//WV/D+s674sWLa+PHj2e7LsS6FmzT+S8lJUW7+OKLtYULF2aq38L8zmYP0QWSiFR+RZAhRSFGo1Ftr1y58kIPH/dkmJYMM6pevbr6hVy6RYXUufwambHeZTjdRRddxHq/QLt378bff/+dqW6LFi2qhoKG2rT8K8PkmjdvHn6OPF/avvQoUe4tXrxYdfXXrl0bd911F44dOxZ+jPWdN6dOnVL/lihRIsffG/Jvw4YNUbZs2fBzpHf09OnTmX4hpvPXd8iUKVNQqlQpNGjQAE888QScTmemts36zh35RXz69OmqJ06Gc7FdF15dh7BN5y/paZZenozfzaIw27Y5Xz5JHDt69Kj6g8l4IoRs//7777qVKxbIBbh0e8oFogyzGDFiBFq1aoWtW7eqC3ar1aouyrPWuzxGeReqv+zadOgx+Vcu3jMym83qQoj1n3syXE6GAFSrVg07d+7E//73P1x77bXqi95kMrG+8yAYDKpx6FdeeaW6EA+12/N9b8i/2bX90GOU8/oW/fv3R5UqVdQPW5s3b8b//d//qXlGc+fOZX3n0pYtW9RFuQxdlrkU8+bNQ7169bBx40a260Kqa7bp/CcBp0w3kSFzWRXmdzYDIopYckEYImNKJUCS/7HOnDlTTfQnihU33XRT+L780iXtvUaNGqrXqH379rqWLZp/cZQfTzLOO6TCr++M8wqlbUuiFmnTEvhLG6eckx8HJfiRnrjZs2dj0KBBak4FFV5dS1DENp1/9u/fj/vvv1/NQZSkZHrikLkLJMMA5BfcrBkvZLtcuXIXenjKQH4hqFWrFv78809VtzJc8eTJk6z3fBZqt+dq0/Jv1qQhktFFMqGx3V84GSIq3y3S1lnfuXfPPfeoRB+LFi1SE6RDcvK9If9m1/ZDj1HO6zs78sOWyNi2Wd85I7+U16xZE82aNVMZ/iRRy9tvv812XYh1nR226byTIXFyLdG0aVM1ykRuEnhKUie5Lz09hfWdzYAoH/5o5A/mxx9/zDR0QLYzjjelCycpneVXRfmFUercYrFkqncZhiFzjFjvF0aGbcmXSMa6lbG4MjcoVLfyr3xByZdZyE8//aTafuh/DpR3f/31l5pDJG2d9Z1zkrNCLs5leIu0R2nLGeXke0P+leEyGQN++fVS0u+GhsxQzuo7O/Kru8jYtlnfeSPftx6Ph+26EOs6O2zTeSe9xfL3L3UYusncZJkzHrpfaN/Z+ZomIk5Nnz5dZeD69NNPVTao22+/XStWrFimjBeUew8//LC2ePFibffu3drPP/+sdejQQStVqpTKZCTuvPNO7aKLLtJ++uknbe3atVqLFi3UjXKW0WXDhg3qJl8Db7zxhrq/d+9e9fjLL7+s2vAXX3yhbd68WWVAq1atmuZyucLHuOaaa7RLLrlEW716tbZ8+XKVIaZfv36s/lzWtzz2yCOPqIw50tZ/+OEHrWnTpqo+3W436zsX7rrrLq1o0aLqe+PQoUPhm9PpDD/nfN8bfr9fa9CggdapUydt48aN2oIFC7TSpUtrTzzxBNt2Luv7zz//1J5//nlVz9K25fukevXqWuvWrVnfufT444+r7H1Sj/KdLNuS1fP7779nuy7EumabLnhZs/gV1nc2A6J8MmbMGHXCrFarSsO9atWq/Dp03Orbt69Wvnx5VacVK1ZU2/JlFCIX53fffbdKh5mQkKD16NFD/c+Yzm/RokXqwjzrTdI/h1JvP/3001rZsmVVsN++fXtt+/btmY5x7NgxFQAlJSWp9JZDhgxRF/eUu/qWi0f5IpcvcEkvWqVKFe2222474wcV1vf5ZVfHcpswYUKuvjf27NmjXXvttZrD4VA/wsiPMz6fj007l/W9b98+FfyUKFFCfY/UrFlTe/TRR7VTp06xvnNp6NCh6rtB/n8o3xXynRwKhtiuC6+u2aYLPyAqrO9sg/znAnq7iIiIiIiIohbnEBERERERUdxiQERERERERHGLAREREREREcUtBkRERERERBS3GBAREREREVHcYkBERERERERxiwERERERERHFLQZEREREREQUtxgQERFRxBg8eDBuuOEGvYtBRERxhAERERGFBQIBtGzZEj179sxUK6dOnULlypXx5JNPnre26tSpA5vNhr///jvXNfv222/j008/zfMZmTdvHq644goULVoUycnJqF+/Ph544IE8H4+IiGIfAyIiIgozmUwqIFmwYAGmTJkS3n/vvfeiRIkSePbZZ89ZW8uXL4fL5ULv3r0xceLEXNesBDLFihXL0xn58ccf0bdvX/Tq1Qu//PIL1q1bhxdffBE+ny9PxyMiovjAgIiIiDKpVasWXn75ZRUEHTp0CF988QWmT5+Ozz77DFar9Zy19fHHH6N///64+eab8cknn2R67Pfff0dCQgKmTp0a3jdz5kw4HA78+uuv2Q6Zmz17Nho2bKieU7JkSXTo0AFpaWnZvvdXX32FK6+8Eo8++ihq166tPocc67333gv3cknAt3btWrUdDAZVkCc9SiGTJ09WPWEh+/fvx4033qiCNHlu9+7dsWfPnkzvO378eNStWxd2u131jr3//vvhx+S5BoNB1Z/0vMlzGjRogCVLlrDVERFFCAZERER0BgmGGjdurAKb22+/Hc8884zaPpeUlBTMmjULAwcORMeOHVUAsmzZsvDjEiy89tpruPvuu7Fv3z789ddfuPPOOzF69GjUq1fvjONJMNavXz8MHToUv/32GxYvXqyG8mmalu37lytXDtu2bcPWrVvP2vvUpEkTdRyxZcsWFaxs2LABqampap8EKm3atFH3pWepc+fOauidfI6ff/4ZSUlJuOaaa+D1etVzpBdN6kZ6oqSML730Ep5++ukzesckSHv44YfVe7Vo0QLdunXDsWPH2PKIiCKBRkRElI3ffvtNIg+tYcOGms/nO28djRs3TmvSpEl4+/7779cGDRp0xvO6du2qtWrVSmvfvr3WqVMnLRgMhh+T53fv3l3dX7dunXr/PXv25Oj8pKamal26dFGvqVKlita3b1/t448/1txud/g5Dz30kHp/8dZbb6nnNG7cWJs/f77aV7NmTfU5xKRJk7TatWtnKp/H49EcDof23Xffqe0aNWpoU6dOzVSOkSNHai1atFD3d+/ercrz8ssvhx+XuqxUqZI2evToHH0uIiIqWOwhIiKibMmQNxnitnv3btWbEyK9OtJTErplfL70DoXIfekxkp6jrMfdvHkz1q9fr+YrSS9NdqRHqn379mrIXJ8+ffDRRx/hxIkTZz1biYmJ+Oabb/Dnn3/iqaeeUmWTXpnLLrsMTqdTPUd6f2SekySPkN6gtm3bqpv0Gh08eFC9VrbFpk2b1Lb0EIU+qwybc7vd2Llzpxq6J//eeuutmerjhRdeUPszkl6hELPZjObNm6seJSIi0h8DIiIiOsOKFSvw5ptv4uuvv1YBhVz0h4aqPf/889i4cWP4JmQO0KpVq/DYY4+pC365ydwcCURk/kxGEmhIMCE3GRZ3NjLfZ+HChZg/f74aUjdmzBg1N0gCtHOpUaMGhg0bpub2SNAlZZsxY4Z6rHXr1ipAk/1Lly7NFBBJgFShQgVcfPHF6rkyjK5Zs2aZPqvc/vjjDzVPKjTMTgK1jI/LkD2pCyIiig4MiIiIKBMJYiS5wV133YWrr75aJUqQrG0ffPCBerxMmTKoWbNm+CbkORJsSLCTMTh46KGH1GMhx48fV8eW9N3y74ABA1RWurOR3iNJlDBixAg1/0aSOkhq7ZyqWrWq6uUKJWKQ5AiNGjXCu+++C4vFouY1Sbnl2BL8heYPiaZNm2LHjh1nfF65yXyksmXLqgBq165dZzxerVq1TOXIGCD5/X6VAU8SMRARkf4YEBERUSZPPPGE6g2STHOhoEKSIUjvT9YMa6HkA5MmTVIJECSDWsab9NSsXr1aJTsIDbeTLG4ypO2NN95QQ9ceeeSRbM+AvE6SFEhWOEnCMHfuXBw5cuSsgcRzzz2nyii9PdKLJEGOJGSQ8kmShxDpEZJkCKHgR4bByTGlFyljQCTBWqlSpVRmOUmqIMeUY993333hIYQSqI0aNQrvvPOO6jmSRA0TJkxQny0jyXQngZxk2hs+fLga+idlIyKiCFDAc5SIiCiKLF68WDOZTNqyZcvOeEwSILRr1y5TkgExe/ZszWg0an///Xe2x6xbt6724IMPahMnTtQSExO1P/74I/zY6tWrNYvFon377bdnJFX49ddftc6dO2ulS5fWbDabVqtWLW3MmDFnLftPP/2k9erVS6tcubJmtVq1smXLatdcc80Zn2XevHkq0cHYsWMzJYCQfb///num5x46dEi75ZZbtFKlSqkyVK9eXbvtttu0U6dOhZ8zZcoUlUxC3rN48eJa69attblz52ZKqiCJFy677DL1nHr16qmyEhFRZDDIf/QOyoiIiGKR9KjJ8DnprZKU30REFHk4ZI6IiIiIiOIWAyIiIiIiIopbHDJHRERERERxiz1EREREREQUtxgQERERERFR3GJAREREREREcYsBERERERERxS0GREREREREFLcYEBERERERUdxiQERERERERHGLARERERERESFe/T/YM8ovsQQx/gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cv2\n", + "import numpy as np\n", + "import easyocr\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import os\n", + "import random\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "print(\"🧠 Booting up STEM Sight Continuous Line Sweeper...\")\n", + "ocr_reader = easyocr.Reader(['en']) \n", + "\n", + "def extract_pure_line_data(image_path):\n", + " print(f\"\\n🚀 Analyzing Line Chart: {image_path}\")\n", + " print(\"-\" * 50)\n", + " \n", + " img = cv2.imread(image_path)\n", + " img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + " img_h, img_w, _ = img.shape\n", + " \n", + " # --- STEP 1: OCR FOR Y-AXIS SCALE ---\n", + " ocr_results = ocr_reader.readtext(\n", + " image_path, \n", + " mag_ratio=3, \n", + " contrast_ths=0.1, \n", + " adjust_contrast=0.5\n", + " )\n", + " \n", + " y_axis_nums = []\n", + " \n", + " for (bbox, text, prob) in ocr_results:\n", + " tcx = (bbox[0][0] + bbox[1][0]) / 2\n", + " tcy = (bbox[0][1] + bbox[2][1]) / 2\n", + " \n", + " if tcx < (img_w * 0.20):\n", + " numbers_found = re.findall(r\"[-+]?\\d*\\.\\d+|\\d+\", text)\n", + " if numbers_found:\n", + " y_axis_nums.append({'val': float(numbers_found[0]), 'y': tcy})\n", + " \n", + " y_axis_nums = sorted(y_axis_nums, key=lambda d: d['y'], reverse=True)\n", + " unique_y = []\n", + " for y in y_axis_nums:\n", + " if not unique_y or abs(unique_y[-1]['val'] - y['val']) > 0:\n", + " unique_y.append(y)\n", + " \n", + " if len(unique_y) >= 2:\n", + " base_y = unique_y[0]['y']\n", + " base_val = unique_y[0]['val']\n", + " top_y = unique_y[-1]['y']\n", + " top_val = unique_y[-1]['val']\n", + " \n", + " pixel_diff = abs(top_y - base_y)\n", + " units_per_pixel = abs(top_val - base_val) / pixel_diff if pixel_diff > 5 else 0\n", + " print(f\"📏 Scale Established: 1 Pixel = {units_per_pixel:.4f} Units\")\n", + " else:\n", + " # 🔥 THE SAFETY NET\n", + " print(\"⚠️ OCR failed to read the Y-axis text.\")\n", + " print(\"👉 Falling back to default scale (1 pixel = 1 unit) to demonstrate extraction.\")\n", + " base_y = img_h * 0.85\n", + " base_val = 0\n", + " units_per_pixel = 1.0\n", + " \n", + " # --- STEP 2: THE ARTIFACT FILTER ---\n", + " hsv = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2HSV)\n", + " color_mask = (hsv[:, :, 1] > 50) & (hsv[:, :, 2] > 50)\n", + " colored_pixels = img_rgb[color_mask]\n", + " \n", + " if len(colored_pixels) == 0:\n", + " print(\"❌ No colored lines found in the image.\")\n", + " return None\n", + " \n", + " # Cast to integer to prevent underflow during math operations\n", + " binned_colors = (colored_pixels.astype(int) // 40) * 40\n", + " unique_colors, counts = np.unique(binned_colors, axis=0, return_counts=True)\n", + " valid_colors = unique_colors[counts > 500]\n", + " \n", + " # --- STEP 3: THE PIXEL SWEEPER ---\n", + " extracted_data = {}\n", + " start_x = int(img_w * 0.15)\n", + " end_x = int(img_w * 0.95)\n", + " \n", + " for color in valid_colors:\n", + " color_int = color.astype(int)\n", + " line_name = f\"RGB({color_int[0]}, {color_int[1]}, {color_int[2]})\"\n", + " extracted_data[line_name] = []\n", + " \n", + " # 🔥 THE UNDERFLOW FIX: Do math in standard integers, then clip back to uint8\n", + " lower_bound = np.clip(color_int - 30, 0, 255).astype(np.uint8)\n", + " upper_bound = np.clip(color_int + 30, 0, 255).astype(np.uint8)\n", + " \n", + " specific_line_mask = cv2.inRange(img_rgb, lower_bound, upper_bound)\n", + " \n", + " for x in range(start_x, end_x):\n", + " column = specific_line_mask[:, x]\n", + " active_pixels = np.where(column == 255)[0]\n", + " \n", + " if len(active_pixels) > 0:\n", + " median_y = np.median(active_pixels)\n", + " pixel_height = base_y - median_y \n", + " real_value = base_val + (pixel_height * units_per_pixel)\n", + " extracted_data[line_name].append(round(real_value, 2))\n", + " \n", + " # --- OUTPUT SUMMARY ---\n", + " print(\"\\n✅ Extraction Complete! Continuous Waveforms Generated.\")\n", + " for line, array in extracted_data.items():\n", + " if len(array) > 0:\n", + " print(f\"\\n🔵 Line: {line}\")\n", + " print(f\" Total Data Points: {len(array)}\")\n", + " print(f\" Start Sequence: {array[:5]}...\")\n", + " \n", + " # --- PROVE IT ---\n", + " plt.figure(figsize=(10, 5))\n", + " for line_color, data_array in extracted_data.items():\n", + " if len(data_array) > 0:\n", + " r, g, b = map(int, re.findall(r'\\d+', line_color))\n", + " hex_color = '#%02x%02x%02x' % (r, g, b)\n", + " plt.plot(data_array, color=hex_color, linewidth=2, label=line_color)\n", + " \n", + " plt.title(\"STEM Sight: Reconstructed Audio Waveforms\")\n", + " plt.xlabel(\"X-Axis Sweep\")\n", + " plt.ylabel(\"Extracted Y-Value\")\n", + " plt.grid(True, alpha=0.3)\n", + " plt.show()\n", + "\n", + " return extracted_data\n", + "\n", + "test_image_path = os.path.join(\"./../FigureQA_Dataset/validation1/png\", '65.png')\n", + "output = extract_pure_line_data(test_image_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "63ca184a-6789-4a00-8bb8-15fdd4f78aa3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up STEM Sight AI Models...\n", + "\n", + "🚀 Analyzing: ./../Test/Hbar.png\n", + "----------------------------------------\n", + "📊 Type Detected: HBAR_CATEGORICAL\n", + "⚠️ Not enough axis numbers found. Defaulting to 1 pixel = 1 unit.\n", + "\n", + "📈 FINAL EXTRACTED DATA:\n", + " Indigo: 208\n", + " Yellow Green: 327\n", + " Web Purple: 251\n", + " Yellow: 351\n", + " Rebecca Purple: 103\n", + " Green: 219\n", + " Dark Seafoam: 430\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "from PIL import Image\n", + "from ultralytics import YOLO\n", + "import easyocr\n", + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "import os\n", + "\n", + "# Suppress annoying Mac/MPS warnings to keep the terminal clean\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# ==========================================\n", + "# 1. LOAD ALL AI MODELS\n", + "# ==========================================\n", + "print(\"🧠 Booting up STEM Sight AI Models...\")\n", + "\n", + "# A. Chart Classifier\n", + "classifier = models.resnet18() \n", + "classifier.fc = torch.nn.Linear(classifier.fc.in_features, 5) \n", + "classifier.load_state_dict(torch.load('graph_classifier_real.pth', map_location='cpu'))\n", + "classifier.eval()\n", + "CLASS_NAMES = ['vbar_categorical', 'hbar_categorical', 'line', 'pie', 'dot_line'] \n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# B. YOLO Bar Detector\n", + "yolo_model = YOLO(\"./Bar_Model_Final/weights/best.pt\") # Update path if needed\n", + "\n", + "# C. OCR Text Reader\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "\n", + "# ==========================================\n", + "# 2. THE EXTRACTION ENGINE\n", + "# ==========================================\n", + "def extract_full_chart_data(image_path):\n", + " print(f\"\\n🚀 Analyzing: {image_path}\")\n", + " print(\"-\" * 40)\n", + " \n", + " # --- STEP 1: Classify Chart Type ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " img_tensor = transform(img_pil).unsqueeze(0)\n", + " with torch.no_grad():\n", + " outputs = classifier(img_tensor)\n", + " _, predicted = torch.max(outputs, 1)\n", + " chart_type = CLASS_NAMES[predicted.item()]\n", + " print(f\"📊 Type Detected: {chart_type.upper()}\")\n", + "\n", + " # --- STEP 2: Detect Bars (YOLO) ---\n", + " results = yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + " \n", + " if len(boxes) == 0:\n", + " print(\"❌ No bars detected.\")\n", + " return\n", + " \n", + " # --- STEP 3: Read Text & Numbers (OCR) ---\n", + " ocr_results = ocr_reader.readtext(image_path)\n", + " numbers = []\n", + " text_labels = []\n", + " \n", + " for (bbox, text, prob) in ocr_results:\n", + " # Calculate center coordinates of the text box\n", + " cx = (bbox[0][0] + bbox[1][0]) / 2\n", + " cy = (bbox[0][1] + bbox[2][1]) / 2\n", + " clean_text = text.replace(',', '').replace('.', '').strip()\n", + " \n", + " if clean_text.isdigit():\n", + " numbers.append({'val': float(clean_text), 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + "\n", + " # --- STEP 4: Process based on Chart Type ---\n", + " final_data = []\n", + " \n", + " if 'hbar' in chart_type.lower():\n", + " # Calculate Scale Ratio from X-axis numbers \n", + " axis_nums = sorted([n for n in numbers if n['y'] > boxes[:, 3].max() - 50], key=lambda d: d['x'])\n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x'])\n", + " else:\n", + " print(\"⚠️ Not enough axis numbers found. Defaulting to 1 pixel = 1 unit.\")\n", + " units_per_pixel = 1.0\n", + "\n", + " # Sort bars Top-to-Bottom\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[1])\n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cy = (y1 + y2) / 2\n", + " pixel_val = x2 - x1\n", + " if pixel_val < 10 or (y2-y1) < 5: continue # Sanity Filter\n", + " \n", + " # Find the closest text label on the left side of the bar\n", + " possible_labels = [l for l in text_labels if l['x'] < x1]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = pixel_val * units_per_pixel\n", + " final_data.append((label_text, int(round(real_val))))\n", + "\n", + " elif 'vbar' in chart_type.lower():\n", + " # Calculate Scale Ratio from Y-axis numbers\n", + " axis_nums = sorted([n for n in numbers if n['x'] < boxes[:, 0].min() + 50], key=lambda d: d['y'], reverse=True)\n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y']))\n", + " else:\n", + " print(\"⚠️ Not enough axis numbers found. Defaulting to 1 pixel = 1 unit.\")\n", + " units_per_pixel = 1.0\n", + "\n", + " # Sort bars Left-to-Right\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[0])\n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cx = (x1 + x2) / 2\n", + " pixel_val = y2 - y1\n", + " if pixel_val < 10 or (x2-x1) < 5: continue # Sanity Filter\n", + " \n", + " # Find the closest text label below the bar\n", + " possible_labels = [l for l in text_labels if l['y'] > y2]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = pixel_val * units_per_pixel\n", + " final_data.append((label_text, int(round(real_val))))\n", + "\n", + " else:\n", + " print(\"⚠️ Not a bar chart.\")\n", + " return\n", + "\n", + " # --- FINAL OUTPUT TEXT ---\n", + " print(\"\\n📈 FINAL EXTRACTED DATA:\")\n", + " for label, value in final_data:\n", + " print(f\" {label}: {value}\")\n", + " \n", + " # --- DISPLAY THE GRAPH WITH YOLO BOXES ---\n", + " annotated_img = results[0].plot() \n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " plt.figure(figsize=(12, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " \n", + " # Extract filename for the title\n", + " file_name = os.path.basename(image_path)\n", + " plt.title(f\"STEM Sight Extraction: {file_name} ({chart_type.upper()})\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " return final_data\n", + "\n", + "# ==========================================\n", + "# 3. RUN THE ENGINE\n", + "# ==========================================\n", + "my_image = \"./../Test/Hbar.png\" \n", + "extracted_results = extract_full_chart_data(my_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ad342687-5a09-4a09-bef6-ff4c5e5fcd4a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up STEM Sight AI Models...\n", + "\n", + "🚀 Analyzing: ./Real_Test_Graph/hbar2.png\n", + "----------------------------------------\n", + "📊 Type Detected: HBAR_CATEGORICAL\n", + "\n", + "📈 FINAL EXTRACTED DATA:\n", + " University and Emerson: 7072\n", + " Califomia Ave Caltrain Station: 4609\n", + " Redwood City Public Library: 4569\n", + " Park at Olive: 4408\n", + " San Jose Civic Center: 4197\n", + " Rengstorff Avenue / California Street: 4167\n", + " Redwood City Medical Center: 3952\n", + " Palo Alto Caltrain Station: 3198\n", + " San Mateo County Center: 2729\n", + " Broadway at Main: 2482\n", + " Cowper at University: 2477\n", + " Redwood City Caltrain Station: 2431\n", + " South Van Ness at Market: 2411\n", + " San Antonio Caltrain Station: 2392\n", + " San Antonio Shopping Center: 2298\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "from PIL import Image\n", + "from ultralytics import YOLO\n", + "import easyocr\n", + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "import os\n", + "\n", + "# Suppress annoying Mac/MPS warnings to keep the terminal clean\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# ==========================================\n", + "# 1. LOAD ALL AI MODELS\n", + "# ==========================================\n", + "print(\"🧠 Booting up STEM Sight AI Models...\")\n", + "\n", + "# A. Chart Classifier\n", + "classifier = models.resnet18() \n", + "classifier.fc = torch.nn.Linear(classifier.fc.in_features, 5) \n", + "classifier.load_state_dict(torch.load('graph_classifier_real.pth', map_location='cpu'))\n", + "classifier.eval()\n", + "CLASS_NAMES = ['vbar_categorical', 'hbar_categorical', 'line', 'pie', 'dot_line'] \n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# B. YOLO Bar Detector\n", + "yolo_model = YOLO(\"./Bar_Model_Final/weights/best.pt\") # Update path if needed\n", + "\n", + "# C. OCR Text Reader\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "\n", + "# ==========================================\n", + "# 2. THE EXTRACTION ENGINE\n", + "# ==========================================\n", + "def extract_full_chart_data(image_path):\n", + " print(f\"\\n🚀 Analyzing: {image_path}\")\n", + " print(\"-\" * 40)\n", + " \n", + " # --- STEP 1: Classify Chart Type ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " img_tensor = transform(img_pil).unsqueeze(0)\n", + " with torch.no_grad():\n", + " outputs = classifier(img_tensor)\n", + " _, predicted = torch.max(outputs, 1)\n", + " chart_type = CLASS_NAMES[predicted.item()]\n", + " print(f\"📊 Type Detected: {chart_type.upper()}\")\n", + "\n", + " # --- STEP 2: Detect Bars (YOLO) ---\n", + " results = yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + " \n", + " if len(boxes) == 0:\n", + " print(\"❌ No bars detected.\")\n", + " return\n", + " \n", + " # --- STEP 3: Read Text & Numbers (OCR) ---\n", + " ocr_results = ocr_reader.readtext(image_path)\n", + " numbers = []\n", + " text_labels = []\n", + " \n", + " for (bbox, text, prob) in ocr_results:\n", + " # Calculate center coordinates of the text box\n", + " cx = (bbox[0][0] + bbox[1][0]) / 2\n", + " cy = (bbox[0][1] + bbox[2][1]) / 2\n", + " clean_text = text.replace(',', '').replace('.', '').strip()\n", + " \n", + " if clean_text.isdigit():\n", + " numbers.append({'val': float(clean_text), 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + "\n", + " # --- STEP 4: Process based on Chart Type ---\n", + " final_data = []\n", + " \n", + " if 'hbar' in chart_type.lower():\n", + " # Calculate Scale Ratio from X-axis numbers \n", + " axis_nums = sorted([n for n in numbers if n['y'] > boxes[:, 3].max() - 50], key=lambda d: d['x'])\n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x'])\n", + " else:\n", + " print(\"⚠️ Not enough axis numbers found. Defaulting to 1 pixel = 1 unit.\")\n", + " units_per_pixel = 1.0\n", + "\n", + " # Sort bars Top-to-Bottom\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[1])\n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cy = (y1 + y2) / 2\n", + " pixel_val = x2 - x1\n", + " if pixel_val < 10 or (y2-y1) < 5: continue # Sanity Filter\n", + " \n", + " # Find the closest text label on the left side of the bar\n", + " possible_labels = [l for l in text_labels if l['x'] < x1]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = pixel_val * units_per_pixel\n", + " final_data.append((label_text, int(round(real_val))))\n", + "\n", + " elif 'vbar' in chart_type.lower():\n", + " # Calculate Scale Ratio from Y-axis numbers\n", + " axis_nums = sorted([n for n in numbers if n['x'] < boxes[:, 0].min() + 50], key=lambda d: d['y'], reverse=True)\n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y']))\n", + " else:\n", + " print(\"⚠️ Not enough axis numbers found. Defaulting to 1 pixel = 1 unit.\")\n", + " units_per_pixel = 1.0\n", + "\n", + " # Sort bars Left-to-Right\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[0])\n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cx = (x1 + x2) / 2\n", + " pixel_val = y2 - y1\n", + " if pixel_val < 10 or (x2-x1) < 5: continue # Sanity Filter\n", + " \n", + " # Find the closest text label below the bar\n", + " possible_labels = [l for l in text_labels if l['y'] > y2]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = pixel_val * units_per_pixel\n", + " final_data.append((label_text, int(round(real_val))))\n", + "\n", + " else:\n", + " print(\"⚠️ Not a bar chart.\")\n", + " return\n", + "\n", + " # --- FINAL OUTPUT TEXT ---\n", + " print(\"\\n📈 FINAL EXTRACTED DATA:\")\n", + " for label, value in final_data:\n", + " print(f\" {label}: {value}\")\n", + " \n", + " # --- DISPLAY THE GRAPH WITH YOLO BOXES ---\n", + " annotated_img = results[0].plot() \n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " plt.figure(figsize=(12, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " \n", + " # Extract filename for the title\n", + " file_name = os.path.basename(image_path)\n", + " plt.title(f\"STEM Sight Extraction: {file_name} ({chart_type.upper()})\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " return final_data\n", + "\n", + "# ==========================================\n", + "# 3. RUN THE ENGINE\n", + "# ==========================================\n", + "my_image = \"./Real_Test_Graph/hbar2.png\" \n", + "extracted_results = extract_full_chart_data(my_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "73732bdb-dea1-467f-bf9e-78ca6929f81c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up STEM Sight AI Models...\n", + "\n", + "🚀 Analyzing: ./../FigureQA_Dataset/no_annot_test1/png/1.png\n", + "----------------------------------------\n", + "📊 Type Detected: HBAR_CATEGORICAL\n", + "\n", + "📈 FINAL EXTRACTED DATA:\n", + " Indian Red: 74.31\n", + " Lawn Green: 84.84\n", + " Rosy Brown: 83.02\n", + " Blue: 69.72\n", + " Magenta: 62.35\n", + " Deep Sky Blue: 87.45\n", + " Light Salmon: 59.11\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "from PIL import Image\n", + "from ultralytics import YOLO\n", + "import easyocr\n", + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "import os\n", + "import re\n", + "\n", + "# Suppress annoying Mac/MPS warnings to keep the terminal clean\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# ==========================================\n", + "# 1. LOAD ALL AI MODELS\n", + "# ==========================================\n", + "print(\"🧠 Booting up STEM Sight AI Models...\")\n", + "\n", + "# A. Chart Classifier\n", + "classifier = models.resnet18() \n", + "classifier.fc = torch.nn.Linear(classifier.fc.in_features, 5) \n", + "classifier.load_state_dict(torch.load('graph_classifier_real.pth', map_location='cpu'))\n", + "classifier.eval()\n", + "CLASS_NAMES = ['vbar_categorical', 'hbar_categorical', 'line', 'pie', 'dot_line'] \n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# B. YOLO Bar Detector\n", + "yolo_model = YOLO(\"./Bar_Model_Final/weights/best.pt\") # Update path if needed\n", + "\n", + "# C. OCR Text Reader\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "# Helper function to safely extract numbers (handles floats, negatives, and ignores text)\n", + "def extract_number(text_str):\n", + " # Find all valid numbers in the string (e.g., \"10\", \"1.5\", \"-5.2\")\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " # Common OCR fixes for single digits that get misread as letters\n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "# ==========================================\n", + "# 2. THE EXTRACTION ENGINE\n", + "# ==========================================\n", + "def extract_full_chart_data(image_path):\n", + " print(f\"\\n🚀 Analyzing: {image_path}\")\n", + " print(\"-\" * 40)\n", + " \n", + " # --- STEP 1: Classify Chart Type ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " img_tensor = transform(img_pil).unsqueeze(0)\n", + " with torch.no_grad():\n", + " outputs = classifier(img_tensor)\n", + " _, predicted = torch.max(outputs, 1)\n", + " chart_type = CLASS_NAMES[predicted.item()]\n", + " print(f\"📊 Type Detected: {chart_type.upper()}\")\n", + "\n", + " # --- STEP 2: Detect Bars (YOLO) ---\n", + " results = yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + " \n", + " if len(boxes) == 0:\n", + " print(\"❌ No bars detected.\")\n", + " return\n", + " \n", + " # --- STEP 3: Read Text & Numbers (OCR) with Upscaling ---\n", + " # Upscale the image 2x specifically for OCR to catch tiny axis numbers\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " \n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " numbers = []\n", + " text_labels = []\n", + " \n", + " for (bbox, text, prob) in ocr_results:\n", + " # Calculate center coordinates, then divide by 2 to map back to original image size\n", + " cx = ((bbox[0][0] + bbox[1][0]) / 2) / 2.0\n", + " cy = ((bbox[0][1] + bbox[2][1]) / 2) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + "\n", + " # --- STEP 4: Process based on Chart Type ---\n", + " final_data = []\n", + " \n", + " if 'hbar' in chart_type.lower():\n", + " # Get the bottom-most edge of all detected bars to find the X-axis\n", + " lowest_bar_bottom = boxes[:, 3].max()\n", + " \n", + " # Filter numbers that are roughly below the bars\n", + " axis_nums = sorted([n for n in numbers if n['y'] > lowest_bar_bottom - 20], key=lambda d: d['x'])\n", + " \n", + " if len(axis_nums) >= 2:\n", + " # Calculate Scale Ratio: (Value Difference) / (Pixel Difference)\n", + " units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x'])\n", + " \n", + " # Find where absolute Zero is on the image's X-axis space\n", + " zero_x_pixel = axis_nums[0]['x'] - (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " print(\"⚠️ Still not enough axis numbers. Defaulting scale.\")\n", + " units_per_pixel = 1.0\n", + " zero_x_pixel = boxes[:, 0].min() # Assume leftmost box edge is zero\n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[1]) # Top-to-Bottom\n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cy = (y1 + y2) / 2\n", + " if (x2 - x1) < 10 or (y2 - y1) < 5: continue # Sanity Filter\n", + " \n", + " # Find category label to the left of the bar\n", + " possible_labels = [l for l in text_labels if l['x'] < x1]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " # Calculate value based on the end of the bar (x2) relative to the zero point\n", + " real_val = (x2 - zero_x_pixel) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " elif 'vbar' in chart_type.lower():\n", + " # Get the left-most edge of all detected bars to find the Y-axis\n", + " leftmost_bar_edge = boxes[:, 0].min()\n", + " \n", + " # Filter numbers that are to the left of the bars\n", + " axis_nums = sorted([n for n in numbers if n['x'] < leftmost_bar_edge + 20], key=lambda d: d['y'], reverse=True)\n", + " \n", + " if len(axis_nums) >= 2:\n", + " # Y-coordinates decrease as you go UP the image, so we use absolute difference\n", + " units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y']))\n", + " \n", + " # Find where absolute Zero is on the image's Y-axis space\n", + " zero_y_pixel = axis_nums[0]['y'] + (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " print(\"⚠️ Still not enough axis numbers. Defaulting scale.\")\n", + " units_per_pixel = 1.0\n", + " zero_y_pixel = boxes[:, 3].max() # Assume bottom-most box edge is zero\n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[0]) # Left-to-Right\n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cx = (x1 + x2) / 2\n", + " if (x2 - x1) < 5 or (y2 - y1) < 10: continue # Sanity Filter\n", + " \n", + " # Find category label below the bar\n", + " possible_labels = [l for l in text_labels if l['y'] > y2]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " # Calculate value based on the top of the bar (y1) relative to the zero point\n", + " real_val = (zero_y_pixel - y1) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " else:\n", + " print(\"⚠️ Not a bar chart.\")\n", + " return\n", + "\n", + " # --- FINAL OUTPUT TEXT ---\n", + " print(\"\\n📈 FINAL EXTRACTED DATA:\")\n", + " for label, value in final_data:\n", + " print(f\" {label}: {value}\")\n", + " \n", + " # --- DISPLAY THE GRAPH WITH YOLO BOXES ---\n", + " annotated_img = results[0].plot() \n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " plt.figure(figsize=(12, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " \n", + " # Extract filename for the title\n", + " file_name = os.path.basename(image_path)\n", + " plt.title(f\"STEM Sight Extraction: {file_name} ({chart_type.upper()})\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " return final_data\n", + "\n", + "# ==========================================\n", + "# 3. RUN THE ENGINE\n", + "# ==========================================\n", + "if __name__ == \"__main__\":\n", + " my_image = \"./../FigureQA_Dataset/no_annot_test1/png/1.png\" \n", + " extracted_results = extract_full_chart_data(my_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "5b0d0dff-a7bb-4e29-b2b2-e57337e5a2d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up STEM Sight AI Models...\n", + "\n", + "🚀 Analyzing: ./../FigureQA_Dataset/no_annot_test1/png/2.png\n", + "----------------------------------------\n", + "📊 Top Prediction: VBAR_CATEGORICAL\n", + " Confidence Scores:\n", + " - dot_line: 0.00%\n", + " - hbar_categorical: 0.00%\n", + " - line: 0.00%\n", + " - pie: 0.00%\n", + " - vbar_categorical: 100.00%\n", + "\n", + "📈 FINAL EXTRACTED DATA:\n", + " E: 67.29\n", + " E: 32.98\n", + " E: 41.0\n", + " E: 61.55\n", + " [: 30.66\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "from PIL import Image\n", + "from ultralytics import YOLO\n", + "import easyocr\n", + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "import os\n", + "import re\n", + "import torch.nn.functional as F\n", + "\n", + "# Suppress annoying Mac/MPS warnings to keep the terminal clean\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# ==========================================\n", + "# 1. LOAD ALL AI MODELS\n", + "# ==========================================\n", + "print(\"🧠 Booting up STEM Sight AI Models...\")\n", + "\n", + "# A. Chart Classifier\n", + "classifier = models.resnet18() \n", + "classifier.fc = torch.nn.Linear(classifier.fc.in_features, 5) \n", + "classifier.load_state_dict(torch.load('graph_classifier_real.pth', map_location='cpu'))\n", + "classifier.eval()\n", + "\n", + "# 🚨 FIXED CLASS NAMES: Must perfectly match PyTorch's alphabetical sorting\n", + "CLASS_NAMES = ['dot_line', 'hbar_categorical', 'line', 'pie', 'vbar_categorical'] \n", + "\n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# B. YOLO Bar Detector\n", + "yolo_model = YOLO(\"./Bar_Model_Final/weights/best.pt\") # Update path if needed\n", + "\n", + "# C. OCR Text Reader\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "# Helper function to safely extract numbers (handles floats, negatives, and ignores text)\n", + "def extract_number(text_str):\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "# ==========================================\n", + "# 2. THE EXTRACTION ENGINE\n", + "# ==========================================\n", + "def extract_full_chart_data(image_path):\n", + " print(f\"\\n🚀 Analyzing: {image_path}\")\n", + " print(\"-\" * 40)\n", + " \n", + " # --- STEP 1: Classify Chart Type ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " img_tensor = transform(img_pil).unsqueeze(0)\n", + " with torch.no_grad():\n", + " outputs = classifier(img_tensor)\n", + " probabilities = F.softmax(outputs, dim=1)[0]\n", + " _, predicted = torch.max(outputs, 1)\n", + " chart_type = CLASS_NAMES[predicted.item()]\n", + " \n", + " print(f\"📊 Top Prediction: {chart_type.upper()}\")\n", + " print(\" Confidence Scores:\")\n", + " for i, prob in enumerate(probabilities):\n", + " print(f\" - {CLASS_NAMES[i]}: {prob.item() * 100:.2f}%\")\n", + "\n", + " # --- STEP 2: Detect Bars (YOLO) ---\n", + " results = yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + " \n", + " if len(boxes) == 0:\n", + " print(\"❌ No bars detected.\")\n", + " return\n", + " \n", + " # --- STEP 3: Read Text & Numbers (OCR) with Upscaling ---\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " \n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " numbers = []\n", + " text_labels = []\n", + " \n", + " for (bbox, text, prob) in ocr_results:\n", + " # Scale coordinates back down to match the original image size and YOLO boxes\n", + " cx = ((bbox[0][0] + bbox[1][0]) / 2) / 2.0\n", + " cy = ((bbox[0][1] + bbox[2][1]) / 2) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + "\n", + " # --- STEP 4: Process based on Chart Type ---\n", + " final_data = []\n", + " \n", + " # Blacklist of meta-words we never want to mistake for a category label\n", + " ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'y_axis', 'x_axis']\n", + " \n", + " if 'hbar' in chart_type.lower():\n", + " lowest_bar_bottom = boxes[:, 3].max()\n", + " axis_nums = sorted([n for n in numbers if n['y'] > lowest_bar_bottom - 20], key=lambda d: d['x'])\n", + " \n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x'])\n", + " zero_x_pixel = axis_nums[0]['x'] - (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " units_per_pixel = 1.0\n", + " zero_x_pixel = boxes[:, 0].min() \n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[1]) \n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cy = (y1 + y2) / 2\n", + " if (x2 - x1) < 10 or (y2 - y1) < 5: continue \n", + " \n", + " # Find category label to the left of the bar (with radius limit and blacklist)\n", + " possible_labels = [\n", + " l for l in text_labels \n", + " if l['x'] < x1 \n", + " and (x1 - l['x']) < 150 \n", + " and l['text'].lower().replace('_', ' ') not in ignore_words\n", + " ]\n", + " \n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = (x2 - zero_x_pixel) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " elif 'vbar' in chart_type.lower():\n", + " leftmost_bar_edge = boxes[:, 0].min()\n", + " axis_nums = sorted([n for n in numbers if n['x'] < leftmost_bar_edge + 20], key=lambda d: d['y'], reverse=True)\n", + " \n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y']))\n", + " zero_y_pixel = axis_nums[0]['y'] + (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " units_per_pixel = 1.0\n", + " zero_y_pixel = boxes[:, 3].max() \n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[0]) \n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cx = (x1 + x2) / 2\n", + " if (x2 - x1) < 5 or (y2 - y1) < 10: continue \n", + " \n", + " # Find category label below the bar (with radius limit and blacklist)\n", + " possible_labels = [\n", + " l for l in text_labels \n", + " if l['y'] > y2 \n", + " and (l['y'] - y2) < 150 \n", + " and l['text'].lower().replace('_', ' ') not in ignore_words\n", + " ]\n", + " \n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = (zero_y_pixel - y1) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " else:\n", + " print(\"⚠️ Not a bar chart.\")\n", + " return\n", + "\n", + " # --- FINAL OUTPUT TEXT ---\n", + " print(\"\\n📈 FINAL EXTRACTED DATA:\")\n", + " for label, value in final_data:\n", + " print(f\" {label}: {value}\")\n", + " \n", + " # --- DISPLAY THE GRAPH WITH YOLO BOXES ---\n", + " annotated_img = results[0].plot() \n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " plt.figure(figsize=(12, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " file_name = os.path.basename(image_path)\n", + " plt.title(f\"STEM Sight Extraction: {file_name} ({chart_type.upper()})\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " return final_data\n", + "\n", + "# ==========================================\n", + "# 3. RUN THE ENGINE\n", + "# ==========================================\n", + "if __name__ == \"__main__\":\n", + " # Test it on your vertical bar chart!\n", + " my_image = \"./../FigureQA_Dataset/no_annot_test1/png/2.png\" \n", + " extracted_results = extract_full_chart_data(my_image)\n", + " \n", + " # You can also test it on your horizontal bar chart:\n", + " # my_image_2 = \"./../FigureQA_Dataset/no_annot_test1/png/3.png\" \n", + " # extracted_results_2 = extract_full_chart_data(my_image_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "a5c37b85-f6de-493d-9914-39b090bce0aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🔍 Booting OCR Debugger...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "📝 RAW OCR TEXT FOUND:\n", + " - 'title'\n", + " - '70'\n", + " - '60'\n", + " - '50'\n", + " - '3'\n", + " - '40'\n", + " - '1'\n", + " - '30'\n", + " - '20'\n", + " - 'I'\n", + " - '10'\n", + " - '1'\n", + " - '1'\n", + " - '1'\n", + " - 'E'\n", + " - '['\n", + " - '2'\n", + " - '1'\n", + " - '8'\n", + " - 'xaxis label'\n" + ] + } + ], + "source": [ + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "import easyocr\n", + "\n", + "print(\"🔍 Booting OCR Debugger...\")\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "image_path = \"./../FigureQA_Dataset/no_annot_test1/png/2.png\"\n", + "img_cv = cv2.imread(image_path)\n", + "\n", + "# Upscale just like our main script\n", + "img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + "\n", + "# Standard read without the crazy sensitive thresholds\n", + "ocr_results = ocr_reader.readtext(img_upscaled)\n", + "\n", + "# Draw the boxes and text\n", + "for (bbox, text, prob) in ocr_results:\n", + " pt1 = (int(bbox[0][0]), int(bbox[0][1]))\n", + " pt2 = (int(bbox[2][0]), int(bbox[2][1]))\n", + " cv2.rectangle(img_upscaled, pt1, pt2, (0, 255, 0), 2)\n", + " cv2.putText(img_upscaled, text, (pt1[0], pt1[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 0, 0), 2)\n", + "\n", + "# Display the image\n", + "plt.figure(figsize=(15, 10))\n", + "plt.imshow(cv2.cvtColor(img_upscaled, cv2.COLOR_BGR2RGB))\n", + "plt.title(\"EasyOCR Raw Vision Debugger\")\n", + "plt.axis('off')\n", + "plt.show()\n", + "\n", + "# Print the list so we can see the exact strings\n", + "print(\"\\n📝 RAW OCR TEXT FOUND:\")\n", + "for _, text, _ in ocr_results:\n", + " print(f\" - '{text}'\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0e92b7b-6bb1-460f-b247-84efc24ca1db", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "eda2b180-780b-464c-979e-616c545d724b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up STEM Sight AI Models...\n", + "\n", + "🚀 Analyzing: ./../FigureQA_Dataset/no_annot_test1/png/1.png\n", + "----------------------------------------\n", + "📊 Top Prediction: HBAR_CATEGORICAL\n", + " Confidence Scores:\n", + " - dot_line: 0.00%\n", + " - hbar_categorical: 100.00%\n", + " - line: 0.00%\n", + " - pie: 0.00%\n", + " - vbar_categorical: 0.00%\n", + "\n", + "📈 FINAL EXTRACTED DATA:\n", + " Indian Red: 74.31\n", + " Lawn Green: 84.84\n", + " Rosy Brown: 83.02\n", + " Blue: 69.72\n", + " Magenta: 62.35\n", + " Deep Sky Blue: 87.45\n", + " Light Salmon: 59.11\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "from PIL import Image\n", + "from ultralytics import YOLO\n", + "import easyocr\n", + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "import os\n", + "import re\n", + "import torch.nn.functional as F\n", + "\n", + "# Suppress annoying Mac/MPS warnings to keep the terminal clean\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# ==========================================\n", + "# 1. LOAD ALL AI MODELS\n", + "# ==========================================\n", + "print(\"🧠 Booting up STEM Sight AI Models...\")\n", + "\n", + "# A. Chart Classifier\n", + "classifier = models.resnet18() \n", + "classifier.fc = torch.nn.Linear(classifier.fc.in_features, 5) \n", + "classifier.load_state_dict(torch.load('graph_classifier_real.pth', map_location='cpu'))\n", + "classifier.eval()\n", + "\n", + "# 🚨 FIXED CLASS NAMES: Must perfectly match PyTorch's alphabetical sorting\n", + "CLASS_NAMES = ['dot_line', 'hbar_categorical', 'line', 'pie', 'vbar_categorical'] \n", + "\n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# B. YOLO Bar Detector\n", + "yolo_model = YOLO(\"./Bar_Model_Final/weights/best.pt\") # Update path if needed\n", + "\n", + "# C. OCR Text Reader\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "# Helper function to safely extract numbers (handles floats, negatives, and ignores text)\n", + "def extract_number(text_str):\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "# ==========================================\n", + "# 2. THE EXTRACTION ENGINE\n", + "# ==========================================\n", + "def extract_full_chart_data(image_path):\n", + " print(f\"\\n🚀 Analyzing: {image_path}\")\n", + " print(\"-\" * 40)\n", + " \n", + " # --- STEP 1: Classify Chart Type ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " img_tensor = transform(img_pil).unsqueeze(0)\n", + " with torch.no_grad():\n", + " outputs = classifier(img_tensor)\n", + " probabilities = F.softmax(outputs, dim=1)[0]\n", + " _, predicted = torch.max(outputs, 1)\n", + " chart_type = CLASS_NAMES[predicted.item()]\n", + " \n", + " print(f\"📊 Top Prediction: {chart_type.upper()}\")\n", + " print(\" Confidence Scores:\")\n", + " for i, prob in enumerate(probabilities):\n", + " print(f\" - {CLASS_NAMES[i]}: {prob.item() * 100:.2f}%\")\n", + "\n", + " # --- STEP 2: Detect Bars (YOLO) ---\n", + " results = yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + " \n", + " if len(boxes) == 0:\n", + " print(\"❌ No bars detected.\")\n", + " return\n", + " \n", + " # --- STEP 3: Read Text & Numbers (OCR) with Upscaling ---\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " \n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " numbers = []\n", + " text_labels = []\n", + " \n", + " # +++ SMART LABEL MERGER +++\n", + " # This prevents short garbage reads (like \"E\") from blocking real reads (like \"Medium Blue\")\n", + " def add_or_update_label(new_text, new_cx, new_cy):\n", + " # Ignore obvious 1-character punctuation garbage like \"[\"\n", + " if len(new_text.strip()) == 1 and not new_text.isalnum():\n", + " return\n", + " \n", + " existing = next((l for l in text_labels if abs(l['x'] - new_cx) < 30 and abs(l['y'] - new_cy) < 30), None)\n", + " if existing:\n", + " # Overwrite if the new text is longer\n", + " if len(new_text) > len(existing['text']):\n", + " existing['text'] = new_text\n", + " else:\n", + " text_labels.append({'text': new_text, 'x': new_cx, 'y': new_cy})\n", + " # ++++++++++++++++++++++++++\n", + " \n", + " # Horizontal Pass\n", + " for (bbox, text, prob) in ocr_results:\n", + " cx = ((bbox[0][0] + bbox[1][0]) / 2) / 2.0\n", + " cy = ((bbox[0][1] + bbox[2][1]) / 2) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " add_or_update_label(text, cx, cy)\n", + "\n", + " # Rotated Passes for VBAR\n", + " if 'vbar' in chart_type.lower():\n", + " h_up, w_up = img_upscaled.shape[:2]\n", + " \n", + " # 1. Rotate 90 degrees counter-clockwise\n", + " img_rot_ccw = cv2.rotate(img_upscaled, cv2.ROTATE_90_COUNTERCLOCKWISE)\n", + " for (bbox, text, prob) in ocr_reader.readtext(img_rot_ccw):\n", + " cx_rot = ((bbox[0][0] + bbox[1][0]) / 2)\n", + " cy_rot = ((bbox[0][1] + bbox[2][1]) / 2)\n", + " cx = (w_up - cy_rot) / 2.0\n", + " cy = cx_rot / 2.0\n", + " \n", + " if extract_number(text) is None:\n", + " add_or_update_label(text, cx, cy)\n", + " \n", + " # 2. Rotate 90 degrees clockwise\n", + " img_rot_cw = cv2.rotate(img_upscaled, cv2.ROTATE_90_CLOCKWISE)\n", + " for (bbox, text, prob) in ocr_reader.readtext(img_rot_cw):\n", + " cx_rot = ((bbox[0][0] + bbox[1][0]) / 2)\n", + " cy_rot = ((bbox[0][1] + bbox[2][1]) / 2)\n", + " cx = cy_rot / 2.0\n", + " cy = (h_up - cx_rot) / 2.0\n", + " \n", + " if extract_number(text) is None:\n", + " add_or_update_label(text, cx, cy)\n", + "\n", + " # --- STEP 4: Process based on Chart Type ---\n", + " final_data = []\n", + " ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'y_axis', 'x_axis']\n", + " \n", + " if 'hbar' in chart_type.lower():\n", + " lowest_bar_bottom = boxes[:, 3].max()\n", + " axis_nums = sorted([n for n in numbers if n['y'] > lowest_bar_bottom - 20], key=lambda d: d['x'])\n", + " \n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x'])\n", + " zero_x_pixel = axis_nums[0]['x'] - (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " units_per_pixel = 1.0\n", + " zero_x_pixel = boxes[:, 0].min() \n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[1]) \n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cy = (y1 + y2) / 2\n", + " if (x2 - x1) < 10 or (y2 - y1) < 5: continue \n", + " \n", + " possible_labels = [\n", + " l for l in text_labels \n", + " if l['x'] < x1 \n", + " and (x1 - l['x']) < 150 \n", + " and l['text'].lower().replace('_', ' ') not in ignore_words\n", + " ]\n", + " \n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = (x2 - zero_x_pixel) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " elif 'vbar' in chart_type.lower():\n", + " leftmost_bar_edge = boxes[:, 0].min()\n", + " axis_nums = sorted([n for n in numbers if n['x'] < leftmost_bar_edge + 20], key=lambda d: d['y'], reverse=True)\n", + " \n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y']))\n", + " zero_y_pixel = axis_nums[0]['y'] + (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " units_per_pixel = 1.0\n", + " zero_y_pixel = boxes[:, 3].max() \n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[0]) \n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cx = (x1 + x2) / 2\n", + " if (x2 - x1) < 5 or (y2 - y1) < 10: continue \n", + " \n", + " possible_labels = [\n", + " l for l in text_labels \n", + " if l['y'] > y2 \n", + " and (l['y'] - y2) < 150 \n", + " and l['text'].lower().replace('_', ' ') not in ignore_words\n", + " ]\n", + " \n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = (zero_y_pixel - y1) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " else:\n", + " print(\"⚠️ Not a bar chart.\")\n", + " return\n", + "\n", + " # --- FINAL OUTPUT TEXT ---\n", + " print(\"\\n📈 FINAL EXTRACTED DATA:\")\n", + " for label, value in final_data:\n", + " print(f\" {label}: {value}\")\n", + " \n", + " # --- DISPLAY THE GRAPH WITH YOLO BOXES ---\n", + " annotated_img = results[0].plot() \n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " plt.figure(figsize=(12, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " file_name = os.path.basename(image_path)\n", + " plt.title(f\"STEM Sight Extraction: {file_name} ({chart_type.upper()})\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " return final_data\n", + "\n", + "# ==========================================\n", + "# 3. RUN THE ENGINE\n", + "# ==========================================\n", + "if __name__ == \"__main__\":\n", + " my_image = \"./../FigureQA_Dataset/no_annot_test1/png/1.png\" \n", + " extracted_results = extract_full_chart_data(my_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "dc375862-b678-4bf8-a6b3-154bf7e1f254", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up STEM Sight AI Models...\n", + "\n", + "🚀 Analyzing: ./Real_Test_Graph/hbar2.png\n", + "----------------------------------------\n", + "📊 Top Prediction: HBAR_CATEGORICAL\n", + " Confidence Scores:\n", + " - dot_line: 1.39%\n", + " - hbar_categorical: 95.42%\n", + " - line: 0.26%\n", + " - pie: 0.01%\n", + " - vbar_categorical: 2.92%\n", + "\n", + "📈 FINAL EXTRACTED DATA (JSON):\n", + "{\n", + " \"chart_type\": \"hbar_categorical\",\n", + " \"x_axis_label\": \"Average Trip Duration (Seconds)\",\n", + " \"y_axis_label\": \"Redwood\",\n", + " \"data\": [\n", + " {\n", + " \"category\": \"University and Emerson\",\n", + " \"value\": 7083.24\n", + " },\n", + " {\n", + " \"category\": \"University and Emerson\",\n", + " \"value\": 4628.5\n", + " },\n", + " {\n", + " \"category\": \"Public Library\",\n", + " \"value\": 4590.05\n", + " },\n", + " {\n", + " \"category\": \"Park at Olive\",\n", + " \"value\": 4432.25\n", + " },\n", + " {\n", + " \"category\": \"San Jose Civic Center\",\n", + " \"value\": 4210.28\n", + " },\n", + " {\n", + " \"category\": \"San Jose Civic Center\",\n", + " \"value\": 4174.3\n", + " },\n", + " {\n", + " \"category\": \"Medical Center\",\n", + " \"value\": 3970.58\n", + " },\n", + " {\n", + " \"category\": \"Palo Alto Caltrain Station\",\n", + " \"value\": 3218.71\n", + " },\n", + " {\n", + " \"category\": \"San Mateo County Center\",\n", + " \"value\": 2729.98\n", + " },\n", + " {\n", + " \"category\": \"Broadway at Main\",\n", + " \"value\": 2487.86\n", + " },\n", + " {\n", + " \"category\": \"Cowper at University\",\n", + " \"value\": 2486.56\n", + " },\n", + " {\n", + " \"category\": \"Caltrain Station\",\n", + " \"value\": 2433.86\n", + " },\n", + " {\n", + " \"category\": \"South Van Ness at Market\",\n", + " \"value\": 2412.63\n", + " },\n", + " {\n", + " \"category\": \"South Van Ness at Market\",\n", + " \"value\": 2396.49\n", + " },\n", + " {\n", + " \"category\": \"South Van Ness at Market\",\n", + " \"value\": 2301.94\n", + " }\n", + " ]\n", + "}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "from PIL import Image\n", + "from ultralytics import YOLO\n", + "import easyocr\n", + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "import os\n", + "import re\n", + "import torch.nn.functional as F\n", + "import json # <--- ADDED JSON IMPORT\n", + "\n", + "# Suppress annoying Mac/MPS warnings to keep the terminal clean\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# ==========================================\n", + "# 1. LOAD ALL AI MODELS\n", + "# ==========================================\n", + "print(\"🧠 Booting up STEM Sight AI Models...\")\n", + "\n", + "# A. Chart Classifier\n", + "classifier = models.resnet18() \n", + "classifier.fc = torch.nn.Linear(classifier.fc.in_features, 5) \n", + "classifier.load_state_dict(torch.load('graph_classifier_real.pth', map_location='cpu'))\n", + "classifier.eval()\n", + "\n", + "# 🚨 FIXED CLASS NAMES: Must perfectly match PyTorch's alphabetical sorting\n", + "CLASS_NAMES = ['dot_line', 'hbar_categorical', 'line', 'pie', 'vbar_categorical'] \n", + "\n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# B. YOLO Bar Detector\n", + "yolo_model = YOLO(\"./Bar_Model_Final/weights/best.pt\") # Update path if needed\n", + "\n", + "# C. OCR Text Reader\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "# Helper function to safely extract numbers (handles floats, negatives, and ignores text)\n", + "def extract_number(text_str):\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "# ==========================================\n", + "# 2. THE EXTRACTION ENGINE\n", + "# ==========================================\n", + "def extract_full_chart_data(image_path):\n", + " print(f\"\\n🚀 Analyzing: {image_path}\")\n", + " print(\"-\" * 40)\n", + " \n", + " # --- STEP 1: Classify Chart Type ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " img_tensor = transform(img_pil).unsqueeze(0)\n", + " with torch.no_grad():\n", + " outputs = classifier(img_tensor)\n", + " probabilities = F.softmax(outputs, dim=1)[0]\n", + " _, predicted = torch.max(outputs, 1)\n", + " chart_type = CLASS_NAMES[predicted.item()]\n", + " \n", + " print(f\"📊 Top Prediction: {chart_type.upper()}\")\n", + " print(\" Confidence Scores:\")\n", + " for i, prob in enumerate(probabilities):\n", + " print(f\" - {CLASS_NAMES[i]}: {prob.item() * 100:.2f}%\")\n", + "\n", + " # --- STEP 2: Detect Bars (YOLO) ---\n", + " results = yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + " \n", + " if len(boxes) == 0:\n", + " print(\"❌ No bars detected.\")\n", + " return None # Changed to return None instead of empty\n", + " \n", + " # --- STEP 3: Read Text & Numbers (OCR) with Upscaling ---\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " \n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " numbers = []\n", + " text_labels = []\n", + " \n", + " # +++ SMART LABEL MERGER +++\n", + " def add_or_update_label(new_text, new_cx, new_cy):\n", + " if len(new_text.strip()) == 1 and not new_text.isalnum():\n", + " return\n", + " \n", + " existing = next((l for l in text_labels if abs(l['x'] - new_cx) < 30 and abs(l['y'] - new_cy) < 30), None)\n", + " if existing:\n", + " if len(new_text) > len(existing['text']):\n", + " existing['text'] = new_text\n", + " else:\n", + " text_labels.append({'text': new_text, 'x': new_cx, 'y': new_cy})\n", + " # ++++++++++++++++++++++++++\n", + " \n", + " # Horizontal Pass\n", + " for (bbox, text, prob) in ocr_results:\n", + " cx = ((bbox[0][0] + bbox[1][0]) / 2) / 2.0\n", + " cy = ((bbox[0][1] + bbox[2][1]) / 2) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " add_or_update_label(text, cx, cy)\n", + "\n", + " # Rotated Passes for VBAR\n", + " if 'vbar' in chart_type.lower():\n", + " h_up, w_up = img_upscaled.shape[:2]\n", + " \n", + " # 1. Rotate 90 degrees counter-clockwise\n", + " img_rot_ccw = cv2.rotate(img_upscaled, cv2.ROTATE_90_COUNTERCLOCKWISE)\n", + " for (bbox, text, prob) in ocr_reader.readtext(img_rot_ccw):\n", + " cx_rot = ((bbox[0][0] + bbox[1][0]) / 2)\n", + " cy_rot = ((bbox[0][1] + bbox[2][1]) / 2)\n", + " cx = (w_up - cy_rot) / 2.0\n", + " cy = cx_rot / 2.0\n", + " \n", + " if extract_number(text) is None:\n", + " add_or_update_label(text, cx, cy)\n", + " \n", + " # 2. Rotate 90 degrees clockwise\n", + " img_rot_cw = cv2.rotate(img_upscaled, cv2.ROTATE_90_CLOCKWISE)\n", + " for (bbox, text, prob) in ocr_reader.readtext(img_rot_cw):\n", + " cx_rot = ((bbox[0][0] + bbox[1][0]) / 2)\n", + " cy_rot = ((bbox[0][1] + bbox[2][1]) / 2)\n", + " cx = cy_rot / 2.0\n", + " cy = (h_up - cx_rot) / 2.0\n", + " \n", + " if extract_number(text) is None:\n", + " add_or_update_label(text, cx, cy)\n", + "\n", + " # --- STEP 4: Process based on Chart Type ---\n", + " final_data = []\n", + " ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'y_axis', 'x_axis']\n", + " \n", + " if 'hbar' in chart_type.lower():\n", + " lowest_bar_bottom = boxes[:, 3].max()\n", + " axis_nums = sorted([n for n in numbers if n['y'] > lowest_bar_bottom - 20], key=lambda d: d['x'])\n", + " \n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x'])\n", + " zero_x_pixel = axis_nums[0]['x'] - (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " units_per_pixel = 1.0\n", + " zero_x_pixel = boxes[:, 0].min() \n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[1]) \n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cy = (y1 + y2) / 2\n", + " if (x2 - x1) < 10 or (y2 - y1) < 5: continue \n", + " \n", + " possible_labels = [\n", + " l for l in text_labels \n", + " if l['x'] < x1 \n", + " and (x1 - l['x']) < 150 \n", + " and l['text'].lower().replace('_', ' ') not in ignore_words\n", + " ]\n", + " \n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = (x2 - zero_x_pixel) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " elif 'vbar' in chart_type.lower():\n", + " leftmost_bar_edge = boxes[:, 0].min()\n", + " axis_nums = sorted([n for n in numbers if n['x'] < leftmost_bar_edge + 20], key=lambda d: d['y'], reverse=True)\n", + " \n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y']))\n", + " zero_y_pixel = axis_nums[0]['y'] + (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " units_per_pixel = 1.0\n", + " zero_y_pixel = boxes[:, 3].max() \n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[0]) \n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cx = (x1 + x2) / 2\n", + " if (x2 - x1) < 5 or (y2 - y1) < 10: continue \n", + " \n", + " possible_labels = [\n", + " l for l in text_labels \n", + " if l['y'] > y2 \n", + " and (l['y'] - y2) < 150 \n", + " and l['text'].lower().replace('_', ' ') not in ignore_words\n", + " ]\n", + " \n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = (zero_y_pixel - y1) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " else:\n", + " print(\"⚠️ Not a bar chart.\")\n", + " return None\n", + "\n", + " # +++ STEP 5: AXIS LABELS & JSON FORMATTING (NEW) +++\n", + " x_axis_label = None\n", + " y_axis_label = None\n", + "\n", + " if text_labels:\n", + " # Extract just the text values of our detected categories so we don't accidentally use them as axis labels\n", + " category_texts = [item[0] for item in final_data]\n", + " \n", + " # Heuristic: X-axis label is usually the furthest down (max Y)\n", + " bottom_most = max(text_labels, key=lambda l: l['y'])\n", + " if bottom_most['text'] not in category_texts and bottom_most['text'].lower() != 'title':\n", + " x_axis_label = bottom_most['text']\n", + " \n", + " # Heuristic: Y-axis label is usually the furthest left (min X)\n", + " left_most = min(text_labels, key=lambda l: l['x'])\n", + " if left_most['text'] not in category_texts and left_most['text'].lower() != 'title':\n", + " y_axis_label = left_most['text']\n", + "\n", + " # Build the final dictionary\n", + " output_dict = {\n", + " \"chart_type\": chart_type,\n", + " \"x_axis_label\": x_axis_label,\n", + " \"y_axis_label\": y_axis_label,\n", + " \"data\": [{\"category\": label, \"value\": value} for label, value in final_data]\n", + " }\n", + "\n", + " # Convert to JSON string\n", + " final_json = json.dumps(output_dict, indent=4)\n", + " \n", + " # --- FINAL OUTPUT TEXT ---\n", + " print(\"\\n📈 FINAL EXTRACTED DATA (JSON):\")\n", + " print(final_json)\n", + " # +++++++++++++++++++++++++++++++++++++++++++++++++++\n", + " \n", + " # --- DISPLAY THE GRAPH WITH YOLO BOXES ---\n", + " annotated_img = results[0].plot() \n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " plt.figure(figsize=(12, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " file_name = os.path.basename(image_path)\n", + " plt.title(f\"STEM Sight Extraction: {file_name} ({chart_type.upper()})\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " return final_json # <--- Now returns the JSON string\n", + "\n", + "# ==========================================\n", + "# 3. RUN THE ENGINE\n", + "# ==========================================\n", + "if __name__ == \"__main__\":\n", + " my_image = \"./Real_Test_Graph/hbar2.png\" \n", + " extracted_json = extract_full_chart_data(my_image)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0ac76a8-8a36-4d35-a12b-0111d9bac606", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tfenv", + "language": "python", + "name": "tfenv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/Dot_line.ipynb b/notebooks/Dot_line.ipynb new file mode 100644 index 0000000..240fc79 --- /dev/null +++ b/notebooks/Dot_line.ipynb @@ -0,0 +1,3656 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "id": "cfa6c145-042c-41de-a125-7c55dcff2f7b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧹 Cleaning up old directories...\n", + "\n", + "Processing FigureQA (train)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████| 100000/100000 [00:09<00:00, 10198.10it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Processing FigureQA (val)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████| 20000/20000 [00:01<00:00, 11264.34it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ Pure FigureQA Dot-Line Dataset Generated!\n" + ] + } + ], + "source": [ + "import json\n", + "import os\n", + "import shutil\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "\n", + "# --- PLOTQA REMOVED ---\n", + "dataset_configs = [\n", + " {\"name\": \"FigureQA\", \"base\": \"./../FigureQA_Dataset/train1\", \"split\": \"train\"},\n", + " {\"name\": \"FigureQA\", \"base\": \"./../FigureQA_Dataset/validation1\", \"split\": \"val\"}\n", + "]\n", + "\n", + "CLASS_DOT = 0 \n", + "\n", + "def process_dot_lines():\n", + " print(\"🧹 Cleaning up old directories...\")\n", + " # Nuke the folder completely to clear out old mistakes\n", + " if os.path.exists(\"./datasets/yolo_dataset_dots\"):\n", + " shutil.rmtree(\"./datasets/yolo_dataset_dots\")\n", + " \n", + " for split in ['train', 'val']:\n", + " os.makedirs(f\"./datasets/yolo_dataset_dots/images/{split}\", exist_ok=True)\n", + " os.makedirs(f\"./datasets/yolo_dataset_dots/labels/{split}\", exist_ok=True)\n", + "\n", + " for config in dataset_configs:\n", + " print(f\"\\nProcessing {config['name']} ({config['split']})...\")\n", + " anno_path = os.path.join(config['base'], \"annotations.json\")\n", + " \n", + " if not os.path.exists(anno_path): continue\n", + " \n", + " with open(anno_path, 'r') as f:\n", + " data = json.load(f)\n", + " \n", + " for item in tqdm(data):\n", + " # Strict check for dot-line type\n", + " if item.get('type', '').lower() != 'dot_line':\n", + " continue\n", + " \n", + " img_path = os.path.join(config['base'], \"png\", f\"{item['image_index']}.png\")\n", + " if not os.path.exists(img_path): continue\n", + " \n", + " try:\n", + " with Image.open(img_path) as img:\n", + " w_img, h_img = img.size\n", + " \n", + " yolo_lines = []\n", + " \n", + " for model in item.get('models', []):\n", + " # Filter out axis labels, titles, and legends\n", + " model_name = model.get('name', '')\n", + " if model_name is None: model_name = ''\n", + " model_name = model_name.lower()\n", + " \n", + " forbidden_words = ['axis', 'title', 'legend', 'label', 'background']\n", + " if any(word in model_name for word in forbidden_words):\n", + " continue\n", + " \n", + " if 'bboxes' in model:\n", + " for box in model['bboxes']:\n", + " if isinstance(box, dict):\n", + " x, y, w, h = box['x'], box['y'], box['w'], box['h']\n", + " else:\n", + " x, y, w, h = box\n", + " \n", + " # ==========================================\n", + " # 🛡️ THE GEOMETRIC SANITY FILTER 🛡️\n", + " # ==========================================\n", + " # A dot is a tiny square. If it's bigger than 50px, it's a bar/line. Toss it!\n", + " if w <= 0 or h <= 0 or w > 50 or h > 50: \n", + " continue\n", + " \n", + " cx = (x + w / 2) / w_img\n", + " cy = (y + h / 2) / h_img\n", + " nw = w / w_img\n", + " nh = h / h_img\n", + " \n", + " yolo_lines.append(f\"{CLASS_DOT} {cx:.6f} {cy:.6f} {nw:.6f} {nh:.6f}\")\n", + "\n", + " # Only copy the image if we successfully extracted valid dots\n", + " if yolo_lines:\n", + " base_name = f\"{config['name']}_{item['image_index']}.png\"\n", + " target_img_path = f\"./datasets/yolo_dataset_dots/images/{config['split']}/{base_name}\"\n", + " \n", + " shutil.copy(img_path, target_img_path)\n", + " \n", + " txt_filename = base_name.rsplit('.', 1)[0] + \".txt\"\n", + " with open(f\"./datasets/yolo_dataset_dots/labels/{config['split']}/{txt_filename}\", 'w') as f:\n", + " f.write(\"\\n\".join(yolo_lines))\n", + " \n", + " except Exception as e:\n", + " pass\n", + "\n", + "process_dot_lines()\n", + "print(\"\\n✅ Pure FigureQA Dot-Line Dataset Generated!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5a262e40-02e4-4213-8ec9-f6e2d5d1faa5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cv2\n", + "import os\n", + "import random\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def test_dot_labels(img_dir, label_dir, num_samples=3):\n", + " if not os.path.exists(img_dir) or not os.path.exists(label_dir):\n", + " print(\"❌ Error: Dataset directories not found.\")\n", + " return\n", + " \n", + " images = [f for f in os.listdir(img_dir) if f.endswith(('.png', '.jpg'))]\n", + " \n", + " if not images:\n", + " print(\"❌ No images found in the directory. The extraction might have failed.\")\n", + " return\n", + " \n", + " samples = random.sample(images, min(num_samples, len(images)))\n", + " \n", + " for sample_img in samples:\n", + " sample_label = sample_img.rsplit('.', 1)[0] + '.txt'\n", + " img_path = os.path.join(img_dir, sample_img)\n", + " label_path = os.path.join(label_dir, sample_label)\n", + " \n", + " if not os.path.exists(label_path):\n", + " continue\n", + "\n", + " img = cv2.imread(img_path)\n", + " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + " h, w, _ = img.shape\n", + "\n", + " with open(label_path, 'r') as f:\n", + " for line in f.readlines():\n", + " parts = line.split()\n", + " if len(parts) < 5: continue\n", + " \n", + " cx, cy, nw, nh = map(float, parts[1:5])\n", + " \n", + " x1 = int((cx - nw/2) * w)\n", + " y1 = int((cy - nh/2) * h)\n", + " x2 = int((cx + nw/2) * w)\n", + " y2 = int((cy + nh/2) * h)\n", + " \n", + " cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)\n", + "\n", + " plt.figure(figsize=(10, 8))\n", + " plt.imshow(img)\n", + " plt.title(f\"Dot Constellation Test: {sample_img}\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + "# Pointing exactly to the newly created folders\n", + "images_path = './datasets/yolo_dataset_dots/images/train'\n", + "labels_path = './datasets/yolo_dataset_dots/labels/train'\n", + "\n", + "test_dot_labels(images_path, labels_path, num_samples=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8fc51ae3-26d1-483b-9ee5-89c10a34f20b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🚀 Loading YOLO model from: dot_detector_run/weights/best.pt\n", + "📸 Analyzing image: ./../FigureQA_Dataset/train1/png/85005.png\n", + "🎨 Detected 7 Legend Classes: ['Light Coral', 'Burlywood', 'Magenta', 'Violet', 'Dark Cyan', 'Deep Pink', 'Dark Seafoam']\n", + "\n", + "📈 Final Extracted JSON Output:\n", + "{\n", + " \"title\": \"title\",\n", + " \"x_axis_label\": \"xaxis label\",\n", + " \"y_axis_label\": \"xaxis label\",\n", + " \"total_points\": 78,\n", + " \"data\": [\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 6.66,\n", + " \"y\": 20.96\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 6.66,\n", + " \"y\": 60.81\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 6.66,\n", + " \"y\": 62.67\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 6.66,\n", + " \"y\": 13.5\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 14.78,\n", + " \"y\": 29.61\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 14.78,\n", + " \"y\": 16.39\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 14.78,\n", + " \"y\": 58.1\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 14.78,\n", + " \"y\": 13.67\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 14.78,\n", + " \"y\": 61.49\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 14.78,\n", + " \"y\": 60.47\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 23.16,\n", + " \"y\": 35.04\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 23.16,\n", + " \"y\": 19.1\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 23.16,\n", + " \"y\": 55.21\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 23.16,\n", + " \"y\": 59.96\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 23.16,\n", + " \"y\": 15.03\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 23.16,\n", + " \"y\": 58.27\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 31.01,\n", + " \"y\": 55.21\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 31.28,\n", + " \"y\": 37.07\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 31.28,\n", + " \"y\": 15.37\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 31.28,\n", + " \"y\": 21.98\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 31.28,\n", + " \"y\": 58.6\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 31.28,\n", + " \"y\": 55.89\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 39.66,\n", + " \"y\": 57.25\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 39.66,\n", + " \"y\": 19.61\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 39.66,\n", + " \"y\": 49.45\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 39.66,\n", + " \"y\": 35.71\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 39.66,\n", + " \"y\": 24.69\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 39.66,\n", + " \"y\": 53.69\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 39.66,\n", + " \"y\": 53.01\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 47.77,\n", + " \"y\": 16.89\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 47.77,\n", + " \"y\": 30.97\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 47.77,\n", + " \"y\": 51.31\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 47.77,\n", + " \"y\": 27.58\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 47.77,\n", + " \"y\": 55.89\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 47.77,\n", + " \"y\": 48.94\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 47.77,\n", + " \"y\": 50.47\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 55.89,\n", + " \"y\": 22.83\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 55.89,\n", + " \"y\": 43.18\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 55.89,\n", + " \"y\": 54.54\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 55.89,\n", + " \"y\": 30.29\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 55.89,\n", + " \"y\": 19.44\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 55.89,\n", + " \"y\": 49.11\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 55.89,\n", + " \"y\": 48.09\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 64.01,\n", + " \"y\": 13.5\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 64.27,\n", + " \"y\": 33.17\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 64.27,\n", + " \"y\": 41.31\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 64.27,\n", + " \"y\": 53.18\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 64.27,\n", + " \"y\": 23.0\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 64.27,\n", + " \"y\": 46.74\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 64.27,\n", + " \"y\": 45.55\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 72.39,\n", + " \"y\": 13.5\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 72.39,\n", + " \"y\": 51.82\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 72.39,\n", + " \"y\": 20.12\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 72.39,\n", + " \"y\": 43.01\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 72.39,\n", + " \"y\": 35.04\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 72.39,\n", + " \"y\": 44.53\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 72.39,\n", + " \"y\": 36.05\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 80.76,\n", + " \"y\": 24.18\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 80.76,\n", + " \"y\": 13.5\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 80.76,\n", + " \"y\": 35.55\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 80.76,\n", + " \"y\": 50.47\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 80.76,\n", + " \"y\": 38.94\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 80.76,\n", + " \"y\": 42.16\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 80.76,\n", + " \"y\": 40.63\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 88.88,\n", + " \"y\": 13.5\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 88.88,\n", + " \"y\": 49.11\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 88.88,\n", + " \"y\": 29.95\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 88.88,\n", + " \"y\": 38.26\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 88.88,\n", + " \"y\": 26.39\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 88.88,\n", + " \"y\": 41.65\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 88.88,\n", + " \"y\": 39.95\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 97.26,\n", + " \"y\": 47.75\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 97.26,\n", + " \"y\": 35.71\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 97.26,\n", + " \"y\": 13.5\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 97.26,\n", + " \"y\": 28.76\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 97.26,\n", + " \"y\": 44.53\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 97.26,\n", + " \"y\": 26.73\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 97.26,\n", + " \"y\": 37.58\n", + " }\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "import cv2\n", + "import numpy as np\n", + "import easyocr\n", + "from ultralytics import YOLO\n", + "import matplotlib.pyplot as plt\n", + "import json\n", + "import re\n", + "import os\n", + "import warnings\n", + "\n", + "# Suppress warnings for clean output\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "def extract_number(text_str):\n", + " \"\"\"Safely parse numbers from OCR text.\"\"\"\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "def color_distance(c1, c2):\n", + " \"\"\"Calculate Euclidean distance between two BGR colors.\"\"\"\n", + " return np.linalg.norm(np.array(c1, dtype=np.float32) - np.array(c2, dtype=np.float32))\n", + "\n", + "def test_dot_extraction(image_path, yolo_model_path):\n", + " print(f\"🚀 Loading YOLO model from: {yolo_model_path}\")\n", + " \n", + " if not os.path.exists(yolo_model_path):\n", + " print(f\"❌ ERROR: Model not found at {yolo_model_path}\")\n", + " return\n", + " \n", + " yolo_model = YOLO(yolo_model_path)\n", + " ocr_reader = easyocr.Reader(['en'], gpu=True, verbose=False)\n", + "\n", + " print(f\"📸 Analyzing image: {image_path}\")\n", + " \n", + " # 1. Run YOLO to find dots\n", + " results = yolo_model(image_path, conf=0.5, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + "\n", + " if len(boxes) == 0:\n", + " print(\"❌ No dots detected by YOLO.\")\n", + " return\n", + "\n", + " # 2. Upscaled OCR Scanning\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " \n", + " numbers = []\n", + " text_labels = []\n", + " raw_legend_candidates = []\n", + "\n", + " for (bbox, text, prob) in ocr_results:\n", + " # Scale bounding box back down to original image coordinates\n", + " orig_tl_x, orig_tl_y = bbox[0][0] / 2.0, bbox[0][1] / 2.0\n", + " orig_br_x, orig_br_y = bbox[2][0] / 2.0, bbox[2][1] / 2.0\n", + " \n", + " cx = (orig_tl_x + orig_br_x) / 2.0\n", + " cy = (orig_tl_y + orig_br_y) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + " # Save raw coordinates for color sampling later\n", + " raw_legend_candidates.append({\n", + " 'text': text, \n", + " 'x': cx, # Fixed missing key here\n", + " 'tl_x': orig_tl_x, \n", + " 'cy': cy, \n", + " 'height': orig_br_y - orig_tl_y\n", + " })\n", + "\n", + " # 3. Robust Axis Scaling (Using Linear Regression to ignore OCR typos)\n", + " leftmost_dot = boxes[:, 0].min()\n", + " bottommost_dot = boxes[:, 3].max()\n", + "\n", + " # Y-AXIS\n", + " y_axis_nums = [n for n in numbers if n['x'] < leftmost_dot + 30]\n", + " if len(y_axis_nums) >= 2:\n", + " y_coords = [n['y'] for n in y_axis_nums]\n", + " y_vals = [n['val'] for n in y_axis_nums]\n", + " y_m, y_c = np.polyfit(y_coords, y_vals, 1)\n", + " else:\n", + " y_m, y_c = 1.0, 0.0\n", + "\n", + " # X-AXIS\n", + " x_axis_nums = [n for n in numbers if n['y'] > bottommost_dot - 30]\n", + " if len(x_axis_nums) >= 2:\n", + " x_coords = [n['x'] for n in x_axis_nums]\n", + " x_vals = [n['val'] for n in x_axis_nums]\n", + " x_m, x_c = np.polyfit(x_coords, x_vals, 1)\n", + " else:\n", + " x_m, x_c = 1.0, 0.0\n", + "\n", + " # 4. Extract Colors from Legend\n", + " legend_colors = {}\n", + " ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'x_axis', 'y_axis']\n", + " \n", + " # Filter to likely legend items (Right side of graph, not a title/axis label)\n", + " for item in raw_legend_candidates:\n", + " clean_text = item['text'].strip()\n", + " if clean_text.lower() in ignore_words or item['x'] < leftmost_dot:\n", + " continue\n", + " \n", + " # Sample the color slightly to the left of the legend text\n", + " sample_x = int(item['tl_x'] - item['height']) \n", + " sample_y = int(item['cy'])\n", + " \n", + " # Ensure we don't go out of bounds\n", + " if sample_x > 0 and sample_y > 0 and sample_x < img_cv.shape[1] and sample_y < img_cv.shape[0]:\n", + " # OpenCV loads in BGR format\n", + " bgr_color = img_cv[sample_y, sample_x]\n", + " # Ignore white/gray backgrounds (sum of colors > 700 usually means white)\n", + " if int(bgr_color[0]) + int(bgr_color[1]) + int(bgr_color[2]) < 700:\n", + " legend_colors[clean_text] = bgr_color\n", + "\n", + " print(f\"🎨 Detected {len(legend_colors)} Legend Classes: {list(legend_colors.keys())}\")\n", + "\n", + " # 5. Map Dots to Real (X, Y) Coordinates & Colors\n", + " extracted_points = []\n", + " for box in boxes:\n", + " cx = int((box[0] + box[2]) / 2)\n", + " cy = int((box[1] + box[3]) / 2)\n", + " \n", + " # Apply the linear regression math\n", + " real_x = (x_m * cx) + x_c\n", + " real_y = (y_m * cy) + y_c\n", + " \n", + " # Sample dot color\n", + " dot_color = img_cv[cy, cx]\n", + " \n", + " # Match to closest legend class\n", + " best_class = \"Unknown\"\n", + " if legend_colors:\n", + " best_class = min(legend_colors.keys(), key=lambda k: color_distance(dot_color, legend_colors[k]))\n", + "\n", + " extracted_points.append({\n", + " \"class\": best_class,\n", + " \"x\": float(round(real_x, 2)), \n", + " \"y\": float(round(real_y, 2))\n", + " })\n", + "\n", + " # Sort sequentially left to right\n", + " extracted_points.sort(key=lambda p: p['x'])\n", + "\n", + " # 6. Extract Axis Labels\n", + " title, x_axis_label, y_axis_label = None, None, None\n", + "\n", + " if text_labels:\n", + " top_most = min(text_labels, key=lambda l: l['y'])\n", + " if top_most['y'] < boxes[:, 1].min(): \n", + " title = top_most['text']\n", + " \n", + " remaining = [l for l in text_labels if l != top_most]\n", + " if remaining:\n", + " bottom_most = max(remaining, key=lambda l: l['y'])\n", + " x_axis_label = bottom_most['text']\n", + " left_most = min(remaining, key=lambda l: l['x'])\n", + " y_axis_label = left_most['text']\n", + "\n", + " # --- FINAL JSON BUILD ---\n", + " output = {\n", + " \"title\": title,\n", + " \"x_axis_label\": x_axis_label,\n", + " \"y_axis_label\": y_axis_label,\n", + " \"total_points\": len(extracted_points),\n", + " \"data\": extracted_points\n", + " }\n", + "\n", + " print(\"\\n📈 Final Extracted JSON Output:\")\n", + " print(json.dumps(output, indent=4))\n", + " \n", + " return output\n", + "\n", + "\n", + "\n", + "# ==========================================\n", + "# RUN THE TEST\n", + "# ==========================================\n", + "# 🚨 UPDATE THESE TWO PATHS 🚨\n", + "my_model_path = \"dot_detector_run/weights/best.pt\"\n", + "my_image_path = \"./../FigureQA_Dataset/train1/png/85005.png\"\n", + "\n", + "results = test_dot_extraction(my_image_path, my_model_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "47b77a9e-212e-4cd1-8a8f-8d8e23a2b964", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🚀 Loading YOLO model from: dot_detector_run/weights/best.pt\n", + "📸 Analyzing image: ./../FigureQA_Dataset/train1/png/85005.png\n", + "🎨 Detected 7 Legend Classes: ['Light Coral', 'Burlywood', 'Magenta', 'Violet', 'Dark Cyan', 'Deep Pink', 'Dark Seafoam']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "📈 Final Extracted JSON Output:\n", + "{\n", + " \"title\": \"title\",\n", + " \"x_axis_label\": \"xaxis label\",\n", + " \"y_axis_label\": \"xaxis label\",\n", + " \"total_points\": 78,\n", + " \"data\": [\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": -0.08,\n", + " \"y\": 63.28\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": -0.08,\n", + " \"y\": 64.92\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": -0.08,\n", + " \"y\": 65.0\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": -0.08,\n", + " \"y\": 62.97\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 8.89,\n", + " \"y\": 63.63\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 8.89,\n", + " \"y\": 63.09\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 8.89,\n", + " \"y\": 64.81\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 8.89,\n", + " \"y\": 62.98\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 8.89,\n", + " \"y\": 64.95\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 8.89,\n", + " \"y\": 64.91\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 18.14,\n", + " \"y\": 63.86\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 18.14,\n", + " \"y\": 63.2\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 18.14,\n", + " \"y\": 64.69\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 18.14,\n", + " \"y\": 64.88\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 18.14,\n", + " \"y\": 63.03\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 18.14,\n", + " \"y\": 64.81\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 26.82,\n", + " \"y\": 64.69\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 27.11,\n", + " \"y\": 63.94\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 27.11,\n", + " \"y\": 63.05\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 27.11,\n", + " \"y\": 63.32\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 27.11,\n", + " \"y\": 64.83\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 27.11,\n", + " \"y\": 64.72\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 36.37,\n", + " \"y\": 64.77\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 36.37,\n", + " \"y\": 63.22\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 36.37,\n", + " \"y\": 64.45\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 36.37,\n", + " \"y\": 63.88\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 36.37,\n", + " \"y\": 63.43\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 36.37,\n", + " \"y\": 64.63\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 36.37,\n", + " \"y\": 64.6\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 45.33,\n", + " \"y\": 63.11\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 45.33,\n", + " \"y\": 63.69\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 45.33,\n", + " \"y\": 64.53\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 45.33,\n", + " \"y\": 63.55\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 45.33,\n", + " \"y\": 64.72\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 45.33,\n", + " \"y\": 64.43\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 45.33,\n", + " \"y\": 64.49\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 54.3,\n", + " \"y\": 63.35\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 54.3,\n", + " \"y\": 64.19\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 54.3,\n", + " \"y\": 64.66\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 54.3,\n", + " \"y\": 63.66\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 54.3,\n", + " \"y\": 63.21\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 54.3,\n", + " \"y\": 64.44\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 54.3,\n", + " \"y\": 64.4\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 63.27,\n", + " \"y\": 62.97\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 63.56,\n", + " \"y\": 63.78\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 63.56,\n", + " \"y\": 64.12\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 63.56,\n", + " \"y\": 64.6\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 63.56,\n", + " \"y\": 63.36\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 63.56,\n", + " \"y\": 64.34\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 63.56,\n", + " \"y\": 64.29\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 72.52,\n", + " \"y\": 62.97\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 72.52,\n", + " \"y\": 64.55\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 72.52,\n", + " \"y\": 63.24\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 72.52,\n", + " \"y\": 64.19\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 72.52,\n", + " \"y\": 63.86\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 72.52,\n", + " \"y\": 64.25\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 72.52,\n", + " \"y\": 63.9\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 81.78,\n", + " \"y\": 63.41\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 81.78,\n", + " \"y\": 62.97\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 81.78,\n", + " \"y\": 63.88\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 81.78,\n", + " \"y\": 64.49\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 81.78,\n", + " \"y\": 64.02\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 81.78,\n", + " \"y\": 64.15\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 81.78,\n", + " \"y\": 64.09\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 90.74,\n", + " \"y\": 62.97\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 90.74,\n", + " \"y\": 64.44\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 90.74,\n", + " \"y\": 63.65\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 90.74,\n", + " \"y\": 63.99\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 90.74,\n", + " \"y\": 63.5\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 90.74,\n", + " \"y\": 64.13\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 90.74,\n", + " \"y\": 64.06\n", + " },\n", + " {\n", + " \"class\": \"Deep Pink\",\n", + " \"x\": 100.0,\n", + " \"y\": 64.38\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 100.0,\n", + " \"y\": 63.88\n", + " },\n", + " {\n", + " \"class\": \"Dark Cyan\",\n", + " \"x\": 100.0,\n", + " \"y\": 62.97\n", + " },\n", + " {\n", + " \"class\": \"Magenta\",\n", + " \"x\": 100.0,\n", + " \"y\": 63.6\n", + " },\n", + " {\n", + " \"class\": \"Violet\",\n", + " \"x\": 100.0,\n", + " \"y\": 64.25\n", + " },\n", + " {\n", + " \"class\": \"Burlywood\",\n", + " \"x\": 100.0,\n", + " \"y\": 63.51\n", + " },\n", + " {\n", + " \"class\": \"Dark Seafoam\",\n", + " \"x\": 100.0,\n", + " \"y\": 63.96\n", + " }\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "import cv2\n", + "import numpy as np\n", + "import easyocr\n", + "from ultralytics import YOLO\n", + "import matplotlib.pyplot as plt\n", + "import json\n", + "import re\n", + "import os\n", + "import warnings\n", + "\n", + "# Suppress warnings for clean output\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "def extract_number(text_str):\n", + " \"\"\"Safely parse numbers from OCR text.\"\"\"\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "def color_distance(c1, c2):\n", + " \"\"\"Calculate Euclidean distance between two BGR colors.\"\"\"\n", + " return np.linalg.norm(np.array(c1, dtype=np.float32) - np.array(c2, dtype=np.float32))\n", + "\n", + "def get_robust_scale(axis_nums, axis_key='y'):\n", + " \"\"\"\n", + " Robust scaling that ignores OCR typos (like reading 64.5 as 645).\n", + " Calculates slopes between all pairs and takes the median to reject outliers.\n", + " \"\"\"\n", + " if len(axis_nums) < 2:\n", + " return 1.0, 0.0\n", + "\n", + " coords = np.array([n[axis_key] for n in axis_nums])\n", + " vals = np.array([n['val'] for n in axis_nums])\n", + "\n", + " # Try to fix obvious missing decimals (if a value is >10x the median)\n", + " median_val = np.median(vals)\n", + " if median_val > 0:\n", + " for i in range(len(vals)):\n", + " if vals[i] > median_val * 5: \n", + " vals[i] /= 10.0\n", + "\n", + " slopes = []\n", + " for i in range(len(coords)):\n", + " for j in range(i+1, len(coords)):\n", + " # Avoid division by zero if pixels are too close\n", + " if abs(coords[i] - coords[j]) > 10: \n", + " slope = (vals[i] - vals[j]) / (coords[i] - coords[j])\n", + " slopes.append(slope)\n", + " \n", + " if not slopes:\n", + " return 1.0, 0.0\n", + " \n", + " best_m = np.median(slopes)\n", + " intercepts = vals - best_m * coords\n", + " best_c = np.median(intercepts)\n", + " \n", + " return best_m, best_c\n", + "\n", + "\n", + "def test_dot_extraction(image_path, yolo_model_path):\n", + " print(f\"🚀 Loading YOLO model from: {yolo_model_path}\")\n", + " \n", + " if not os.path.exists(yolo_model_path):\n", + " print(f\"❌ ERROR: Model not found at {yolo_model_path}\")\n", + " return\n", + " \n", + " yolo_model = YOLO(yolo_model_path)\n", + " ocr_reader = easyocr.Reader(['en'], gpu=True, verbose=False)\n", + "\n", + " print(f\"📸 Analyzing image: {image_path}\")\n", + " \n", + " # 1. Run YOLO to find dots\n", + " results = yolo_model(image_path, conf=0.5, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + "\n", + " if len(boxes) == 0:\n", + " print(\"❌ No dots detected by YOLO.\")\n", + " return\n", + "\n", + " # 2. Upscaled OCR Scanning\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " \n", + " numbers = []\n", + " text_labels = []\n", + " raw_legend_candidates = []\n", + "\n", + " for (bbox, text, prob) in ocr_results:\n", + " orig_tl_x, orig_tl_y = bbox[0][0] / 2.0, bbox[0][1] / 2.0\n", + " orig_br_x, orig_br_y = bbox[2][0] / 2.0, bbox[2][1] / 2.0\n", + " \n", + " cx = (orig_tl_x + orig_br_x) / 2.0\n", + " cy = (orig_tl_y + orig_br_y) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + " raw_legend_candidates.append({\n", + " 'text': text, \n", + " 'x': cx,\n", + " 'tl_x': orig_tl_x, \n", + " 'cy': cy, \n", + " 'height': orig_br_y - orig_tl_y\n", + " })\n", + "\n", + " # 3. Robust Axis Scaling\n", + " leftmost_dot = boxes[:, 0].min()\n", + " bottommost_dot = boxes[:, 3].max()\n", + "\n", + " # Isolate numbers strictly on the left axis (X < leftmost dot)\n", + " y_axis_nums = [n for n in numbers if n['x'] < leftmost_dot]\n", + " y_m, y_c = get_robust_scale(y_axis_nums, axis_key='y')\n", + "\n", + " # Isolate numbers strictly on the bottom axis (Y > bottommost dot)\n", + " x_axis_nums = [n for n in numbers if n['y'] > bottommost_dot]\n", + " x_m, x_c = get_robust_scale(x_axis_nums, axis_key='x')\n", + "\n", + " # 4. Extract Colors from Legend\n", + " legend_colors = {}\n", + " ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'x_axis', 'y_axis']\n", + " \n", + " for item in raw_legend_candidates:\n", + " clean_text = item['text'].strip()\n", + " # Only look at text far to the right (past the middle of the image)\n", + " if clean_text.lower() in ignore_words or item['x'] < (img_cv.shape[1] * 0.7):\n", + " continue\n", + " \n", + " sample_x = int(item['tl_x'] - item['height']) \n", + " sample_y = int(item['cy'])\n", + " \n", + " if sample_x > 0 and sample_y > 0 and sample_x < img_cv.shape[1] and sample_y < img_cv.shape[0]:\n", + " bgr_color = img_cv[sample_y, sample_x]\n", + " # Ignore backgrounds (white/gray)\n", + " if int(bgr_color[0]) + int(bgr_color[1]) + int(bgr_color[2]) < 700:\n", + " legend_colors[clean_text] = bgr_color\n", + "\n", + " print(f\"🎨 Detected {len(legend_colors)} Legend Classes: {list(legend_colors.keys())}\")\n", + "\n", + " # 5. Map Dots to Real (X, Y) Coordinates & Colors\n", + " extracted_points = []\n", + " \n", + " # Image for visualization\n", + " vis_img = cv2.cvtColor(img_cv.copy(), cv2.COLOR_BGR2RGB)\n", + "\n", + " for box in boxes:\n", + " cx = int((box[0] + box[2]) / 2)\n", + " cy = int((box[1] + box[3]) / 2)\n", + " \n", + " # Apply the robust math\n", + " real_x = (x_m * cx) + x_c\n", + " real_y = (y_m * cy) + y_c\n", + " \n", + " # Sample dot color and find best class\n", + " dot_color = img_cv[cy, cx]\n", + " best_class = \"Unknown\"\n", + " best_color_rgb = (0, 0, 0)\n", + " \n", + " if legend_colors:\n", + " best_class = min(legend_colors.keys(), key=lambda k: color_distance(dot_color, legend_colors[k]))\n", + " # Convert BGR back to RGB for matplotlib drawing\n", + " b, g, r = legend_colors[best_class]\n", + " best_color_rgb = (int(r), int(g), int(b))\n", + "\n", + " # Save to list\n", + " extracted_points.append({\n", + " \"class\": best_class,\n", + " \"x\": float(round(real_x, 2)), \n", + " \"y\": float(round(real_y, 2))\n", + " })\n", + " \n", + " # Draw on visualization image\n", + " cv2.circle(vis_img, (cx, cy), radius=8, color=best_color_rgb, thickness=-1)\n", + " cv2.putText(vis_img, f\"{real_y:.1f}\", (cx + 10, cy - 10), \n", + " cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 0), 1)\n", + "\n", + " # Sort sequentially left to right\n", + " extracted_points.sort(key=lambda p: p['x'])\n", + "\n", + " # 6. Extract Axis Labels\n", + " title, x_axis_label, y_axis_label = None, None, None\n", + "\n", + " if text_labels:\n", + " top_most = min(text_labels, key=lambda l: l['y'])\n", + " if top_most['y'] < boxes[:, 1].min(): \n", + " title = top_most['text']\n", + " \n", + " remaining = [l for l in text_labels if l != top_most]\n", + " if remaining:\n", + " bottom_most = max(remaining, key=lambda l: l['y'])\n", + " x_axis_label = bottom_most['text']\n", + " left_most = min(remaining, key=lambda l: l['x'])\n", + " y_axis_label = left_most['text']\n", + "\n", + " # --- FINAL DISPLAY & OUTPUT ---\n", + " plt.figure(figsize=(14, 10))\n", + " plt.imshow(vis_img)\n", + " plt.title(\"Extracted Data Validation (Colors matched & Y-vals overlaid)\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " output = {\n", + " \"title\": title,\n", + " \"x_axis_label\": x_axis_label,\n", + " \"y_axis_label\": y_axis_label,\n", + " \"total_points\": len(extracted_points),\n", + " \"data\": extracted_points\n", + " }\n", + "\n", + " print(\"\\n📈 Final Extracted JSON Output:\")\n", + " print(json.dumps(output, indent=4))\n", + " \n", + " return output\n", + "\n", + "# ==========================================\n", + "# RUN THE TEST\n", + "# ==========================================\n", + "# 🚨 UPDATE THESE TWO PATHS 🚨\n", + "my_model_path = \"dot_detector_run/weights/best.pt\"\n", + "my_image_path = \"./../FigureQA_Dataset/train1/png/85005.png\"\n", + "\n", + "results = test_dot_extraction(my_image_path, my_model_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6f79865b-37f7-4e23-9dff-04ba3fb4b450", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🚀 Loading YOLO model from: dot_detector_run/weights/best.pt\n", + "📸 Analyzing image: ./../FigureQA_Dataset/train1/png/85007.png\n", + "🎨 Detected 6 Legend Classes: ['Medium Periwinkle', 'Salmon', 'Medium Mint', 'Sienna', 'Black', 'Lawn Green']\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABFEAAALnCAYAAABBWtj1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd8E3UbB/DfpS2UWfbee8lG9hJBFJUh4kJBRXArKu69XsWNeyvuvUCGCArK3kv23nuXrtz7+f3rlSRN27RNShp/3/eTV5rLXS6X5HL33PN/Hsu2bRsiIiIiIiIiIpIpV+aTRUREREREREREQRQRERERERERkQApE0VEREREREREJAAKooiIiIiIiIiIBEBBFBERERERERGRACiIIiIiIiIiIiISAAVRREREREREREQCoCCKiIiIiIiIiEgAFEQREREREREREQmAgigiIhGuRo0aGDp06OlejXy5rf744w9YlmX+m5Vu3bqZWzA9+uij5vlPl61btyI2NhZ///13yJ+Lr5OvV7L/+di3b1/IN1soPt/hLjvf//woN/uXQD8P/rbhpZdeikGDBuXoeUVEwoGCKCKS73z00UfmoCyj2+zZs7O1vB07dpiDycWLF+N0+fXXX0/7CaTnNoyOjkapUqXQqlUr3HbbbVi5cmWOl3vixAnz2oJ5IvLiiy+a9ZwyZUqGj3n33XfNY37++WeEs1Bsn2B5/PHH0bZtW3Ts2DHdNK7vgAEDUKFCBRQoUADlypXDBRdcgO+///60rGt+FM7vfW4cPHgQ119/PSpXrowiRYqgWbNmeO655wKad+PGjShcuDAuu+wyv9O/+uor871+/fXXg7zWklfuuecefPfdd1iyZIk2uojkSwqiiEi+xRO8Tz75JN2tTp062Q6iPPbYY6c9iMJ1ON169uxptuGHH35otm/Lli3x8ccfm5MgBi5yeqLI1xbME0VeyXS5XPj8888zfAynlS5dGueee26On6dLly6Ij483/w2VzLbPgw8+aJ7/dNi7d69573ky7OuRRx5B9+7dsXz5cowYMQJvvfUWRo0ahWPHjuGiiy7K9H2R0H43wgGzud5//32TbcD9BoNwn332WUDz1qxZ03y+vvzyS0yePNlr2pEjRzBy5EgT2LvhhhtCtPYSCL43vu9PoFq0aIHWrVvjhRde0MYWkXwp+nSvgIhITvHkmAdip+PEh1dKI1G9evUwePBgr/ueeeYZk2Fw5513okGDBjjvvPNwulWqVMmcxDPr4c0330TBggW9pm/fvh3Tp0/H8OHDERMTk+PnYaCGw1lOF2YE8XY6fPrpp+a5+d57+vbbb02AbeDAgSZY4rl9GUiZNGkSkpKScDodP37cZEDI6dn248aNM8G3l156Ke3+hISEgJfBfQ2DLjfeeCOWLVuGQoUKmfsfeOABE9ybOHGi+W7K6ft+MPssNxhgY7DsjTfeQNGiRXO1LBGRvKZfIBGJWDxA44H277//7nU/T6x5AMhUYl4BbtOmjbn/6quvThvOwiFDxDHfTZo0wYIFC0w2AoMn999/v5n2008/oU+fPuaEnifxtWvXxhNPPIGUlJR06zJnzhwTfChZsqQ5eG3atCleeeWVtKu2Tmq655Aah9vtxssvv4zGjRubE/ry5cubq/9Mmfdk2zaefPJJVKlSxawngwwrVqzI9XZkNgevCvOE+qmnnkq7PzExEQ8//LAZ8hMXF2deV+fOnTFt2rS0x2zatAlly5Y1/+YVd+e1OUOXli5dal5/rVq1zGvj0JBrrrkG+/fvz3K9GOw5fPgwxo8fn24a15fb7YorrjB/P//88+jQoYN5LTwh4zozGJDTmgjvvPOOeb+5rDPPPBMzZsxIN28wto+/mgXJycnmc8bn5+eOdVz4mfQ9SeX9559/Pv766y+zjty+3M5jx45FIH788Udzxd/3BOehhx4yQ70++OADvwGqc845xzyvY8+ePbj22mvN55brwKwmZrgEYtGiRSZYWrx4cbMePXr0SDdczxne9+eff5qTbg4r4neAjh49ittvv91sC24rTmO21cKFCzN9Xme7r1mzxnzO+P7xfeJr5/eMtWL69u1r1oufWd8r6sF472nVqlXmZJOP42etfv36JpDg69ChQ+Z7VKJECfN83Jcx2OsvMMZ14rL4HjKji6/FVyCf74w4r4PbyZNvoDMz3NdwHTi0h/s04j6YJ9wMsHD/6Wv+/Pnmef19thjY4zQGd2jz5s3ms8LtydfI/cLFF19s3pOsrF271mRb8X3n55mfNW5H7ouy8s0336Rt/zJlypjPFgO+Du6nuJ5cP1/33Xef+d3y3O/zd6V3797mPec+v2vXrunqFzmfZQ7JvPzyy81vUKdOnTJcR2YhnnXWWea7wvesUaNGJlAdSE2Ubdu2oV+/fubzzvmZNZRR8IzfQwZzfvvttyy2mohIGLJFRPKZDz/8kEfn9pQpU+y9e/d63fbt25f2uMTERLtFixZ29erV7SNHjpj7Jk6caOZ94oknzN+7du2yH3/8cXPf8OHD7U8++cTc1q9fb6Z37drVrlChgl22bFn7lltusd9++237xx9/NNP69etnDxo0yH7uuefsN99807744ovNcu666y6v9Z08ebJdoEABsx6PPPKIeeytt95qn3322Wb6zJkz7Z49e5p5nefnzTFs2DA7Ojravu666+y33nrLvueee+wiRYrYbdq0Ma/R8eCDD5plnHfeefZrr71mX3PNNXalSpXsMmXK2EOGDMlyu3Lem266KcPpPXr0sF0ul3348GHzN7d3xYoV7TvuuMO8ptGjR9v169e3Y2Ji7EWLFpnHHDt2zEzjsvv375/22pYsWWKmP//883bnzp3Ne/DOO+/Yt912m12oUCH7zDPPtN1ud6bry/WIjY21L7roonTTWrZsaba3s4wqVarYN954o9kuL774olk+12ncuHFe83Eez201bdo08zj+1/Hee++Z+zp06GCPGTPGvv322+0SJUrYtWrVMp8XRzC2Dz8vvj/VXD/eN3DgQPv111+3r7rqKvM3P4++r4XPV758efv+++83r53bxbIse/ny5ZluW36u+D5w3T2tWbPGPBc/W4E4ceKE3bBhQ/OaR44cabYX328u4+WXX/Z6LO/j63VwHfk55zbk9/WZZ56xa9asaRcsWNCePXt2uv1Bo0aNzPZ/9dVXzWPp8ssvN989vg6+b88++6x9wQUX2J9++mmm6+1s9+bNm9uXXXaZ/cYbb9h9+vQx9/Hzw+16ww03mPs7duxo7v/zzz+D+t7zv8WLF7dLly5t33fffWbfc/fdd9tnnHFGuvXkfm7AgAFmfbi/4H18rKcnn3zSvPeXXHKJedxjjz1m9g01atSwDx48mO3Pd2a4zfj5WbhwoZ0b3B9xmy1dutRu1aqVWQd+pjLC6dz/+br66qvtkiVLpu0vv/nmG7tZs2b2ww8/bPY7/H5wOr8zx48fz/D7n5CQYD6D3K9ye3JbcTtyX7xp06ZMX4vzOeVjX3rpJfvee+8128hz+2/evNm8R/y8+Htt/Aw6fv/9d/PZbt++vf3CCy+YZTZt2tTcN2fOnHSfEX4/+vbta9577jc8p3ni+g0dOtQsj9+lXr16mcdw/+GJnwXPzwPfl3r16pl9Mj97/H7zPeM6+e5DKSkpybz+O++8M9PtJiISjhREEZF8xzkY9XfjCZanZcuWmYNKnljwQLVy5cp269atzQGcY968eWZeLtcXDxI5jcELX/4O5keMGGEXLlzYPnnypPk7OTnZHHTz4NzzRIU8gwQ8WfAX154xY4a5/7PPPvO63wkGOffv2bPHvE4eZHsulycHfFwwgigMcPAxzkkeXxtPKjzxNfKk3fMkmyeUvifImW3DL774wjx++vTpWa4zA1c8aHcCO7Rq1SozP088M3oenkw1adLEPuuss7IVROF85cqVMyfXnq+dJ2J8nOdJRTC2j+9JzuLFi83f/Dx7YuCO90+dOtXrtfhuR35O+B3J6sRl3bp1Zl6eRHn66aefzP08wQoET6T4eM+gBbchT/yKFi2aFtwk323AoBA/005Ak3bs2GEXK1bM7tKlS7r9QadOncw29xQXF5fpZzojznZnYNXBZTMYx5NcJ0jjvKc8GfT83ATjvedr5GvlibUnz++3s56+QS0GZRh8cfAEPyoqyn7qqafS7R8ZoHXuz87nOyNHjx41AWK+d3y9DLzlFL/XDFiUKlXKPD/3e5nhd55BlwMHDqTdx9fBIJDnNvK335k1a5Z5jrFjx2b4/WcAjH8zCJMdznblPic+Pj7tfgZxuTwGcxz8bjD44Gnu3Lle68bPQN26de1zzjnH6/PA18XfGwblfT8jDGz58hdE8bdt+DwM4mQWRHG+619//XXafQxI1alTx28QhRh0Offcc/1uMxGRcKbhPCKSb3EIDFOBPW8TJkzwegyH4jBV/r333jPDDNgKlOne2akzwZRmpsf7csbpO8MGuGym7DONnmn4znAEpqRzSAFT7T0F0lqS6d9M1WbqM5fv3JgSzuENzvAAdqnhEIJbbrnFa7l83mBxhnXwtVJUVFTauHgOnTlw4IAZasI6NVkNl/C3DU+ePGleW7t27czfgSyD6fCcz7MjjFPU1BnK4/s8TIdn6j3fq0DX03PIAIensN6DZ00ADqXg++QpGNvHXwFiuuOOO7zu5xAH8h3axFR8vk4Hh4VwCMOGDRsyfR5nOBVT/30Le1KxYsUCXl8Oe/DstMIhQLfeeqspQsshOP5wSByLVnJoAIcgOSpWrGiGJHCIkrMujuuuu85sc0/8znHIA4tH58SwYcPS/s1l871jvIfDkzyfw3eb5va9Z90P1vTh0LZq1aplud/wLf7L95zvobON+P3genBokOd+hO9N3bp10/Yj2fl8Z+Sqq64yw2K4D+Tn7eyzz8aWLVvSps+aNcu8Bt9hlv5wuBSHMnL7XXLJJWYfnhk+hvV4PPcH/BxxuBOn+dsf8PHcVixIzvcys/fH2QYcHuRvuFRGnO3KIUSeNZY4HJR1pjy/t1xPDl1av369V0ci/g5xCBmxCDqHFfG7wHV33k8Oj+GQN352+H578lcg2h/PbcP9JJfLYUL8fGc2ZInfdX4/WSvJwSFGHD6bEe5f8qI9t4hIsCmIIiL5Fsfq8wDd88Y6IL5Y7JJ1GObOnWvqpPDEMjvYptNfET3WG+nfv785sObBPk8YnKKszsGmcyDMYE5O8ECZy+L4ci7f88aTUB6YkzOGnidEnvg43xPhnOLz+Z5AMyDF+gQ8MWBdAT4fTwgCqQ9APDliC2XWy+DBO+dndw4KZBmsl8HaDp7dYL744gvzfrOGjIO1EBic4Xry8XwejvMPdD0dGW1nBgY8T/aDtX38PT/r/Ph2oOLJME8AfWsp+J6AEz8PvvV0MuJb14Kfc89AWiDry23lWwS0YcOGadMzCiLwJJXBCV+clyeIvrU8nM+Np9GjR5sOQlWrVjX7C9aHyCqAlNn243ed7yXrWfje77tNc/PeO+sY6H7Ddz2d77yzTtyP8L3ke+G7H/nnn3+y3I9k9Pn2xXo1P/zwA55++mnzfrAALHHfvHv3bvNvvh8MYjMQHAinZpVnEXHui3bt2pV24+eF+L1nUIJBBwf/zfeLdT4c7HjFmjX8XDA4wencFgy2ZPb+8DUxgMmgPOdhUIfB/KzeU2e7+vs8c309vweszcLvi/Ma+L4xmO7UBnLeTxoyZEi695Prxjokvuvk7/vhD2uq8P1iXRPuU7hMpw5YZq+Tr4H7Jd8gn7/X7OBrC+RigohIuFF3HhGJeDwhcQ462ekhuzyvzDl4sM2rczyoZacSFmHkyRKvYt5zzz3prgLmFJfDAEpG7UGdwpR5gSc/vMLuHIyzSCWvUDNbgIEqrien/+9///O6ipoZXhmfOXOmmb958+Ym24WvmcUSA9mGPLnjMt59911zksYr3nyvefLsYFHMCy+80BQGZmFKXi3lfCygGMpWvMHYPhkJ9MTDNzMjo+CIL570k29ggCd8Of0ehZq/7yk/G8zK4Ik9MxKee+45PPvssyZTIZDW1/62XyDbNJTvfaDr6blO/C7xM8NMPX+PDVZ3FH6XyckmYwCaWRssZMpsOhZoZsFYFtn2zczLDhZg9WwJX7169bSisMzkYAFsZjgw4Pvzzz+bTCjP7ENm7PH7z0y99u3bmyAYtw8LxGa132ERYb63LCzOzxSzqvi+MoDkFDTODRYq52f266+/NsELLpf7NX5uHc468vPM/aY/vu+pv++HL342mcnC7zlbUzPIxAsIzDJhp6Vg/a45uH/xDdiJiOQHCqKISETjQR8PeBns4AEzr5Ay3XjAgAFpj8nJlTCeDDCNmidjPDl3cOiOJwZXnAAEr+5lJKN14PwcqtOxY8dMD4J5EkEMIHheMeYV2kCzDjLDg3gOveAJh5OJwu42fC5uA8/1Z7ZPIK+N68WUfp4M8aqwwwl4BYrDdt566y1z5Zbbn8/nOXzku+++MwEunsx5dgjhSVR2eW5nzyvbHBLA5+aVcEdut09Gz8/PNJ/fyeYgBpAY2HPWL7eY2cDPm+/nmS2weWWZJ5DsLpXVyTfXhx2YuM6e2SjOcLeM1pfBQQ4FWL16dbppnJfL4gleIBg04zAK3phx0bJlS3OSHUgQJady+94732HuN4KB+xEGVBgA5XsYjM+3P87rYZaQ8/44w1V4cs7sE+5L3n777Vy9Hg4Z8uww47lvZBCF+xR+75nhxiFNDI74vj/M4vDsqsRhgfwOBeKMM84wtwcffNAEjrh/5j7I6SSU0Xbl59lzuzr3+X4P+Br4eeU07tf4XfBsNe78rvB3LbPflez65ZdfTBYLA0+e2U2eXaUywtfAz6tvdom/7zBxeBs/Jwxwi4jkNxrOIyIRjVfTeJDLq59sC8s2tzfccIPXOGymLVOgB9DkXM31vPrMmiTMdPDEEzaeuHBcv+/yPefNaB14JZ31Ibju/g5CncfzQJrZFa+++qrXcvm8ucUhNwxKcD0826v62wasP8GaB554AuDvtfmbPyfrzBMYtrDl1X+ecDBDyPOKMJ+HB/Werad51ZotfLOLQwp4gs8TJr7fnm12A3l92dk+/vAKvr9txM+5U2MhGPhZ4mtlLQdfPEFlAJH1QvgZ9MWr804rWa4vh1t4Dq/gPPycMgDD98ofbrtevXqZYI1n21kGi5g9xBNoZ2hDRvh++w4/YEYIr/Rn1HY1WHL73vMzxuAs20h71hPxXWagGDTmOvG9852ffzs1cLLz+faHgRJidp7nZ4Otshlw4HvJzIOcDm/0DDJ5DuPkPsDB4CIDHPzM8cYgmmegm7gtfLcDP5P+2tN7YkDG9zPP52JQL7PPFLcrP3vcrp6PY2YQh1P5fm/ZQpnryKGJHMrDluHObwQxGMVACjNynGGWnpzhTcH43PI7FEjAmd911h7ybB3PIXn87fWHLZcZuOJvsohIfqNMFBHJt3gA6lzR9sSDMh5k8+D0oYceMpkozlU8ngww/ZlX+ZguTTwYZWo5D3CZZcGDVR70ZzaGnM/BugO8msl0bp6kf/LJJ+kOzHlwzdobfH4+LwvU8qCe682aKsyOIKc+AJfFcfY8mOXVU55kjhgxwqSLs5ggTyx5gssrxTy4ZjYAM2t44nPXXXeZx/GAmwe0LGrLbeRbvyEza9asMcEIvg6eMCxZssQ8Dw/UeaLOYTYOPg+vtLMuDE8CeKWa25A1ZzwP7HmVmPfxhIZXwVmThCdRvPHkhkNveKWbqf88AffNfsgKtz0LLDLLyDmB88R1c9adj2M2AusYcPw+sySyg9ueV5v5nvCKMq8Yc315kuFbMyIY28cXMwH4meOJiTOkjLV+WH+DQ0f81QTKKRaxZNCMnwPPgAVfM4fzMJuDnzEG2HgVmifirIHB7CJnmBSLSjLrgN9BFstksIsnWay7wEBQZgVquZ1ZLJoBE35fORyDy+JJqOdwrYywbguDafx+cLsxaMOsrnnz5nllIIRCMN77MWPGmNfOQCy3I/dHDEIwq4P7guzgPo7b87777jPL4GeF257rxaFOXD73H9n5fPvDGjDch3HdWcuEnw3uWzmk7ssvvzTDVFgUmEWA+ZkNFa43s9uYgcYiwL41efj+cH/NYTzc/gxu8bPhDGPLyNSpU3HzzTebuiV8vxhQ4XK4v2bgIyPcrhyOw/0/v7PcLgwIcv/N78TIkSO9Hs+AC7/L3G/xc+xZFJf4elj7hNlUrP3E5XL/uX37dpM1wu8rs0qyi78vHL7D3yt+BvhZ5VBJrs/OnTsznZfv6WuvvWayhPhd5+8ct40TKPTF7zancZiXiEi+c7rbA4mIBLPFsdOqmC1G27RpY1qSHjp0yGv+V155xTzuq6++8mrd2qhRI9Pu07PdMVs4Nm7c2O96/P3333a7du1Me1O24bz77rvtSZMm+W3n+Ndff5m2k2xZWqRIEbtp06Ze7WO5vrfccotdtmxZ00LVd/fMFqNse8nn4jLOOOMM83xs+epISUmxH3vsMbtixYrmcd26dbOXL1+erm1vRjy3ocvlMm1BW7RoYVobr1ixIt3j2Vrz6aefNstn21w+li07+Vy8z9PMmTPN+rPtqWdL123btpl2rHwutqNly2K+pozavmaE6+e0uPZtJU3vv/++aQnK6Q0aNDDvr7/2nlm1OHa88cYbppUol8eW2Wwj7NvyMxjbx986sj0332c+P9u5Vq1a1bR2ddpqe74Wtrz25bueGdm9e7f5PnzyySd+p//+++923759TetWPo6f3QsuuMB8l3yXc/XVV9tlypQxr4+fXX/txP295wsXLjTtVdkOma3Du3fvbraVv/0BW5V7YmvbUaNG2c2aNUv73vHffO+y4mx3tiD2xPeOy/Hlu58IxntP/P463w+28q5fv7790EMPZbmezjbZuHGj1/3fffedaQXN18AbvwtsAb169epsf74zw+8bXxPXme9d586d7S+//NKr7To/w4Hga+Djn3vuOTtQa9euTduXcd/ri/sI5zPJ9eNnjK3Rs/r+b9iwwbRKrl27tnltbL3Mz+SUKVMCWi/+5vCzwO3Kea+44gqzD/Tn3XffNc/Nz65nW2RPbLk8YMAA086ay+T6Dxo0yHw3s/qMeE7z9PPPP5vfJ76+GjVq2M8++6z9wQcfpPs8+fs8sB33hRdeaL6r3Lb87WBban/70LZt29qDBw8OaLuJiIQbi/93ugM5IiIiEn54FZ/ZScwkEBEJBmZSMcOKhdgzKowrIhLOFEQRERERv1iPg8MWOETHs+6EiEhOOV2QnCG1IiL5jYIoIiIiIiIiIiIBUHceEREREREREZEAKIgiIiIiIiIiIhIABVFERERERERERAKgIIqIiIiIiIiISAAURBERERERERERCYCCKCIiIiIiIiIiAVAQRUREREREREQkAAqiiIiIiIiIiIgEQEEUEREREREREZEAKIgiIiIiIiIiIhIABVFERERERERERAKgIIqIiIiIiIiISAAURBERERERERERCYCCKCIiIiIiIiIiAVAQRUREREREREQkAAqiiIiIiIiIiIgEQEEUEREREREREZEAKIgiIiIiIiIiIhIABVFERERERERERAKgIIqIiIiIiIiISAAURBERERERERERCYCCKCIiIiIiIiIiAVAQRUREREREREQkAAqiiIiIiIiIiIgEIDqQB0l4sG3b3NxuN+Lj4819lmWhQIECiImJSfs7kOVQYmIikpKSkJKSknYflxMbG2uW43IpxiYiIiIiIiLiUBAln2HwZNeuXfjoo49M8IMBj3POOQetW7cOOOjBIAznnTp1KubMmYOdO3fi5MmTZlqTJk1w2WWXIS4uDsWKFQvxqxERERERERHJPxRECQPJyckmK2Tv3r04cuSIua9gwYKoWbMmoqKiTFaIk2GSkJCA48ePY9u2bWY+Po7zMCjCxzCjhI85evQodu/ebebh/TVq1EDhwoW9lsUMFt534MABHDp0yNxXsWJFk53CQIuIiIiIiIiInKIgShg4ceKECXh89dVXmDlzprmvWrVqeOqpp0w2iDNUhwESBkwY9Ni/f7/JHmGQhQEQBk74bwZTduzYgXnz5mHs2LFmPs7/6KOPomHDhibowiAK72vXrh0aN26MrVu3pgVRRERERERERMQ/BVHCqNYJM0uYBUL8r1OnxMHgR/HixVGhQgWceeaZ5vHR0dGoWrWqySpxMlF4YzDFWZbzHJ7LIQ7/4fwiIiIiIiIikjWdQZ9GnoEN34CJ7/3Of0uWLGmySXr06GGCIayJUrlyZRNECeT5nOVkpwBtoAJZpoiIiIiIiEh+pSDKacRskWPHjmH16tWYMWMGNm/enDaNw2s4vIc1Sxg0admyJapXr45JkyZh+/btWL9+vQlycAjP2WefbaYzq+Tw4cOYMGECNm3a5PU8nG/hwoUoVKiQWU7Hjh0DXkcWs12yZAkOHjxonpvPwxszYRi8adasGUqVKoUqVaookCIiIiIiIiIRS0GU04hBEBaUZeCDARQGVBy8n4ESZprwVqtWLROk2LhxI9atW2duTvHXRo0aoUGDBiagwfoqW7Zswb59+7yex6l74gRlAsW6K6zDwudj3RY+PwMxXCcWr+VzspMPAyocZsSgjloji4iIiIiISCRSEOV0bvzoaJPB0bRpU1NA9ueff8b8+fPNtNKlS2P48OEoWrSoCXoUKVLE/HfgwIEmy+S5554zGSKeQ2lKlChhljNo0CAsWrQI33zzjZnGwMZFF12EunXrpgVlAsEgzR9//IENGzZg1qxZJljCFshcXy6Ly2dQ5euvv0adOnXM+pUvXx5ly5YN0RYTEREREREROX0URDmNGPhgIIWZHQyaeGaIMPBRpkwZU0iWnXScorGsicLMFX/1RzgPb3wMgy6ez8P7ypUrl9adJytOcdqdO3eazBYni4WBGq4Xl8WADTNROMxnz549pisQn1dBFBEREREREYlErtO9AhKeODyHQ3n++ecfLFu2zPzNDJaKFSumBWgY+GEwhcN32HJ5+vTpJuAiIiIiIiIiEomUiSJ+sT0yM1EYPHFqr7AGCoMqBw4cMDVSOMyHtVeYTcNACocX8fEiIiIiIiIikUhBlAiV23bDCQkJaUEUB4Mns2fPNkN4OMSIxW/5GA4RYiCFmSsKooiIiIiIiEikUhAlggIfzjKCsRwO3WF2CYMjDtZC6dChgxnSw2E8zFDhjcEU1lAhdhESERERERERiUQKooSBzAIfDFJwaI0z3QlW5GR5nNdZllOoNiMMnjDDhBknLFbLjBMWlq1evTrq1auHmjVrpq0f2ypzucxEYbFZERERERERkUikIEoYYJCCHXo8sz6IgYmtW7dizZo1pksP2x1XqlQp02UxOMIsEg658cRhNuzqs2TJEvM87NbDwrCeXXw88TFcToMGDcwyV6xYYWqirFq1ysznBFEYQJk8ebJZVz5no0aNUL9+/VxvExEREREREZFwoyBKmARRGLBgkITBEhZoZebH9u3bcezYMdNmmI9hJghbCfPmFHulI0eOmMfExcWZYAwzSPhY/s3aJnws5+HwHD6Oz8NpbFvMG4fjOJhNwscwA4XLYtCGy9i1a5cJkrAuCv+9efPmtGKyXAb/zeVyPUVEREREREQikWUHMj5EQopvAW9TpkzBokWLTEthBi4qVKhgAhe89ejRA40bN8bYsWOxceNGc3MCKaxPUrZsWVxzzTVmuA2DGatXr8avv/5qOugwKFK+fHkTFGGwhpkiffr0Mc83a9YsExBhRgk52S69e/dGx44dTVCEgZyJEyea5axdu9YEaLgsPpYBG2am8Hm7d+9uMlh8M2pEREREREREIoHOdsOAU6OkWrVq5r8MinD4DYfaMCDBrJAqVaqYv5s2bWqCHBw248S/GMzgtFKlSpmAC7NC+O8WLVqY+ZgpwulcDqezMCwDIbVr1zbL4JAdDschBkVY14Tr4nTd4fL4fHzeypUrm+V41kxh9gyLzvLffKyIiIiIiIhIJFImioiIiIiIiIhIAJQ2ICIiIiIiIiISAAVRREREREREREQCoCCKiIiIiIiIiEgAFEQREREREREREQmAgigiIiIiIiIiIgFQEEVEREREREREJAAKooiIiIiIiIiIBEBBFBERERERERGRAEQH8iCRrCQnJyM+Pt7/hyw6GrGxsbAsK6AN6Xa7zbJcLle25gtkXRwFChRAwYIFs7VcERERERER+W9TEEWC4q+//sKdd94J27bTTevSpQtefPHFgIMhe/fuxZAhQ1C7dm2MGTMGUVFR2VqXBQsW4Oabb0ZKSkqGjxk6dChuvfXWbC1XRERERERE/ts0nEeC4vDhw1i0aBF27NhhMkE8b4cOHcKyZcuwZ8+eTJfBAMzGjRuxdOlSs6z169f7Dcpk5ejRo1i8eDG2bdvmd12c9RQRERERERHJDmWiSFCNGDECd9xxh9d9U6ZMQbdu3fDAAw/grrvuynBeZo4wm+W3337D8ePHc70uV155JR5++GGv+2bMmIEBAwbketkiIiIiIiLy36MgiuQKsz5+/fVXbN26FVdddRVat26NuLg4r8fExMTgyJEjSEhIyHA5zA5ZsmQJatSogd69e5tlZteJEyfS1mXw4MFo3759unUpUqRItpcrIiIiIiIiQgqiSK6wfsltt92Gtm3b4ocffsh2EVgH53366acxbtw4NG7cGLNmzcr2MjhUh5kuderUwYQJE0xBWxEREREREZFg0VlmHtQKYUDAqfXh2yGmUqVKaNCgAbp27Yr8monCbjpJSUkmiMGOOv4yROjkyZPmMf44WSocxsNlshYKa5hw+wVaWNZZF2c+f0GU8uXL48knn8TBgwdx4403moyVRo0aZfNVi4iIiIQfdh5kBjCPnXJ6YUtERDKnIEqIMXCwfPlyzJ07F+PHj/eaxva9tWrVQs+ePdGmTZs8+7HzLNaa2+dk8KNQoUJmOfv3709bntOamK+fQ3n4nAy0+LYeZh0UPobTChcunNaemI/nNAZgAs0o4XwMojjz8SDCV8mSJU2tlNdeew1vvfWWGX5Us2ZNRJpgvscSXvTeRj69x5FP73HkOl3vrefz8oIWb/r9FxEJDQVRQqxUqVK44oor0LdvX4waNcprGrvPsM3uvn37zOP4Y5cXP3gMfDBrg/VBGADJjWLFiuHHH3/E/PnzMWjQIPMjzqAHWxNXrlwZw4cPN1k4vJ9BktKlS3vN//fff5tisueffz5+//13E1Ri0IU//szUKVOmTMCZKAzE8LEMnnC+zIIvXBcqXrx4unWKBAxMHTt2DEWLFjUBLYkc/Jwz04rvK99fidz3mPtn1XGKTImJiea3jr9Fzu+RRAZeyGHWLY9heIyUl8/L4zseP3EfoiHNIiKhoyBKiPGEvmLFin6n8QeWJ7s8mOLj8uqqAX9oiQEHrkNucP4WLVqY4TH80XYyQVjcla+Lr4/ZJb7Px8cyuLJq1SpTULZDhw7mZGH37t3YtWuXmYdDe9atW5cWRKlWrVqmJ43OAQO3I7env0wULnPLli3m3xzGw8yU3G6DcORvm0tk0XsbubgfJb3HkSuYv8MSXnh843ksklfZIHxe57efF648M1NERCS4FESRoOjUqZNpH0z8ER86dKgJVnz33XdYsGCBqT3iicESZucw2MIThvfffx+fffaZmca/mSnD4UFdunRJO9D84osvzNCn3Fi4cCEuuugiXHvttWZ9dZVXREREREREAqUgigQFr6Q5V9N4ha1jx46oW7cuypUr5zdQwaEIPXr0MBksvljPZNKkSShRogS6detmruLwik7ZsmUzXQemvvfr18/8+6uvvkKTJk3QvHlzr8cwwMM0W16hYRaKiIiIiIiISKAURJGgY9bIfffdl+ljWIfk1Vdf9Ttt27ZtaN++vQmCjB07NuCaKAy6vPzyy6a2yrnnnmtq0PgGUURERERERERyKn0/WpEcYPtmFsmdPHmy+ZvZIwcOHMCDDz5oWjy/9NJL6NWrV9rjnSK6Gd08+bv/n3/+wW233ebV8SivCvOKiIiIiIjIf5MyUSQoWCSWbYPZFadz587mvr1795paJ2eeeSaefPLJgDNKAsF6K6+//rrprtOnTx+/j3HaJXti5XoRERERERGRnFAQRYLqvffew4QJE9ICFsxGOV1YqNYpdutgS0mner2IiIiIiIhIdiiIIkHB1sMNGjQwnXU8i8XWqlULlStXztYwG7YqrlOnDqpWrZrhfCxWW79+fZP5ktE0Bkv8Fa6tV69elkVqRURERERERHwpiCJBwSE8vlkfjpiYmGwFURjg+OGHH8zwH3bl8YdDhKZPn2468vhq1aoV/vzzz0yfg92BRERERERERLJDQZT/oGOuHVhXcApqRbVHUTQNyjLZ3pgdd4KBwZOs2g97Ph/bFf/111/YsWNHuscxeMN2y8yG8cX5Zs6caboBZaRgwYKmFXOxYsUCWncuc/bs2aZmi791adu2LapXrx7QskRERERERCS8KIjyH7QrZgF+i7sBvV3Po0qQgiinE4cQjR49GuPGjUs3jZks33//fYZBlOeffx4//vhjplkxf//9d8BBFBozZgy+/PJLv0GUTz75REEUERERERGRfEpBlAi30v4Bm23vYTb77DWAZWOV/ROOuL2zMCqgGZpbV+W7VsEMiDDQwbbHvlksc+fOxcKFC00LZs9sGb7Gq6++Oq2bkGPatGkmIDNkyBCTOeKv7kpW61K4cGHccsstKFeunNc0tmZ+4IEHzLQKFSrk6LWKiIiIiIjI6aEgSoSxbTdSkJT29wb7d8yxX/f72E2Yjk32dK/7GmEAmliXwLJTgyhRYD0T/3VJwgGLxyYmJpohQKVKlcKwYcO8Mj2YpdK/f3/MmTPHBEV8gygXXnhhumWmpKRg/PjxOP/88zFw4MBsrQtvzH5h62UGaFjg1jO4MnjwYPz666+44oorFEQRERGRLPFYJinp1LGdJx7LsPacPzzu4DFSZnjMwoL+gV48C2SZzjrltwtyIiKBUhAlwhzGFvzsvhGJOGr+PoAN2ZqfgZWP3T3Nv12IwbmuF1ERzRGu2Mb4/fffx5VXXon7778f5cuXP23rwmFDr776Ki699FKTacLuQiIiIiK5sX37dtxwww04fPhwumlVqlTBm2++aToT+tq5cyeuv/56v50KHawb9/TTTwcc8NizZ49Zl71792b4GBb/5zBrXuASEYlECqJEUAbKEWzHXqzCFvyNBBzJ0XJOYB8246+0IMpeeyViUQJxqAKXFX4fFxZwZc2Su+++2wy9yY34+HhzoLJv3z5zpWXXrl3YsGGDOUBhIdussLAtC9zedNNNaN++fa7WRURERMQ5PmHR+oSEhHRZrMwkWbdunbmIFBcX5xUMYXYsgx779+9Pu4/HNzxeYWYLj28yC7D4wywUZvceOnQIFStWTPd8LNbPIc18HhGRSBV+Z8WSI8lIwE/u4diGuUj4Nwslt9xIwi/2TSht18WVrl9RBNmrDZLfLFq0CBdffHHalR7WLnn99dfN0J5atWqd7tUTERGR/7Du3bvj3Xff9Qpc8GIShwjzQhKzYT2nsag+a7xxOJCDwRNmzG7evBm//PKLyZrNybCbdu3a4dNPP/XKNmHmy3nnnZer1ygikh9EZBCF0W/WteDJMKPvjNLzB4L389/MKihatChKlCjhd37+2HD+TZs2mUg7i4Myqs56Gpw/PNmIx0HE40BQl3oSh8wybZz6AQ4nDRo0QL9+/bBx40YznMbpqMP01LVr12L58uXmRz0QrGPC+XglhXilhVkp/CwEonbt2qb+Cq/wOOvCOi0sXMvP0pIlS7B169Ycv1YRERH57+DxBzNceYzTs2dPtGrVyhyTegY9eKx74MABv0N9GODwLY7PTBIeB/N4lse1zF7JCS6Dx1usp+IZoAnf42QRkeCJyCAKgyBMeVy9erUZ6lGwYEHzQ8IfIxa64o9G3bp10aJFC7/z8yT65MmTJnrPri5nnXUWatSoYU6G9eMQXlj4lYEL3pgxQj169DDFWxnIYDYJg2eB1Epp3LhxWmtizjNo0CBMn+5deDczLETbp08fXH755bjrrrvSrtT8/vvvZn3YOYjLzSh4JyIiIuIZlHjwwQfNkBwGUxgQUbFWEZHTLyKDKMeOHTNX/fmjU6hQIdSrV8/88DC4cvToUSxbtsxkljCCzkwB/tvT7t27TQCGy+E0Bk7CeWznP/aPpssOi8qGwgnsxx/2E6hit0Ez68qw+gHnuvD9GTp0KDp16uR10MH3nsXSPvnkE6/xwJkty3ltfL9ZrLZNmzb44IMPUK1aNVx33XVeV1z8zU8MojgBOgbkHn30UcTGxuJ///ufCdIwK0VEREQkKzwe4c3zGCWnJkyYYC7ssIYKM62ffPJJc5xz1VVXBXyRkJkrvEDF7Bf+1xOXceONN5rMXF10FJFIFpFBlOPHj5tACX9sePLKnTlvztjRP/74w1Qx5zAPnmg7QRTnh4pDOBiEOXHihHlcuP8QrLenZNjGOFhDeubYr+EI+qOZNZjhAoQTvj8XXXRR2t9Tp07FBRdcgDvuuMMUnJ01a1a6IAqzknhjUMTf+8vPDocJsfp8hw4dTCG3a665JtMgimfbZKd1MgvB9erVy8zLYMrSpUsVRBEREZGA8LiDN14gcloLM7uaxy68UOMMQQ4Es1nGjBlj/s3j3TfeeMMcL/GiUaCKFStmLipNnDjRZAFzOU5dlEqVKpljMF54CqcLbiIiwRaRQRT+0DCbhJkmHDvKQIqDw3l4P4f78IS2ZMmSZniPU/18/fr1Zlwpfwj4A8WAjFq05S/Nmzc3Q3v4I56Rr776Cu+99x4ef/zxtAyWUGjYsKEp3MYK9iIiIiLZqTvy4osvmk6Bw4YNMxf3iC2GGcC48847MXfuXL/1UPzhBZ2zzz7b/JsdCG+++eZsvxm8uMQuhGvWrDEXo4YMGWJuxGzvkSNHon79+ib7VsfPIhKpIjKIwqg4h+446Y/OfQ4GRxhE4XAdRvWdDBTex+AL52VghT8GDMgomh7e+N7xfeN7yWAFh2h169bNpKqyGBuvmjCgwgCagwccrEzP6axMz6CZ53Quk8PBWCSW9VQ8gyCcxoMIBt38zedM4zxMe+3atat5Pj4Xs56qV6/uNY+IiIiILx6vtmzZ0lzwY1DCaUfM4wneODx4+/bt2SqA72RmsxVxnTp1zDESl8Pj3sxqtjnHWjx24o3HyDVr1jTDl9k1yAnMPPvss6YWIdePy+S6i4hEmvAep5JDzhAeRsBZ24Q7euKPDKP43LHzR4cn2U5qJO/nMJ7Fixeb1EgWkWUWi4Q/Br1GjRplUlL5A+74+OOPTZYJC76ySLBnIITjf5nWyoKvLAbLYInvwcL9999v6pu89NJLeOutt8wVIQdrrvTu3dsMD/P10EMP4ZxzzvGa9u2335phQe3bt8fkyZPNgYeIiIhIVnixh/VMZs6caW4coswi+sxI+frrr3NUsJ7HRMyU5fBjHit99NFHmT6ex9C33347hg8fbjJ5nXW59tpr0x7DTO8ff/wRl112mbmAxHbMIiKRKDpSgyi82s+MAJ5UMzjCqDjx36yDwkCJk2HCk3AGVVgki1kHzGTgMnKahsjn5NUCtrNll5+MMPLP9eDjeJLPHx9G7Jnd4KxvZo65dmJfzDIctDciLxzDTqzCLyiVVA9xKeETBOAPOw8ouB0ZoOB2pAULFpirJnwf2b7Yc+ww72OWCIdr8WrMpEmTTN0TzyDKP//8Yz5DTt0cZio50/hZYaYK5/d8j51p/Dz99ttvWLlyZVq7ZK4Lryr5rksoMIPK+W9mn0HJf5zPjdNFTCKP8/3Vexy59B5HLicrhP91jhuCgccODnaMPOOMM8zFPh4veh7P8t88FmGAg58zBkj8HVPyOIjz8xjHOZ7JCo9teYzDDBPPYybPZfIYjMdMPOZhxreISCSKyCAKf2iYSbJ27Vrzg7Jq1SpT/8SpjVKlShWTeXLkyBGzw+ePDFsh84eHY0U9f6iyiz9cHJ/Kk+YPP/zQ/Ihk9ljeWISLxW753K1atcLFF18cUEveNbHjMTXuNthwIy9sxWx84R6AtsfvR4sTNyBc8D3me8gfdxY78x3CxR9x/uhnNB+H2lx//fXphm1xOgNqnO45P5frDAPLaBqfk2OGA12XUOHn3BlDLZGFB+fBPECX8MMgmQJlkY1DP3mTyMNjgVD93vft29dkkPAYgxfknGHsTnCO/2bGLLNseXwbyDGliIgEzrLDuXdvDjnBCf54ObUynE4sjLSzGJZzAsJxnEyT/Oyzz8zBapMmTUzEnrd58+aZ7AZG1ZkqyWlMf6xVq1amz8/lMxOBHX4yi+wzY4Wpjo0aNcKAAQPMEA8un3+zK1BWDkSvwsaCk7Ha/gXbMAehVhaN0NS6DFUSO6F8UiuEC77XTEn11zqYBxgcruPvPeN8LEDLgm0Z4RUaBrV8U2WZVsvPBqf5jvdlxXp+BvzhMB8WXAs1JwOFgUPVX4kszrBEvq+eRbMlcjADhSfWHEIYSFai5N/3mO+v51BRyf8YwOCxH485eQwRDMy2ffvtt82xzCWXXGKObfhb8MEHH5hsWh6HsL4Jhxkz45XHNxxWw+MUHuuyyD2HJ3teLOKFJy6Tvyf8HHL4jVNo35lWuXJlXHHFFWaZfF1ffvmlOWbi8UXdunVNVx/PDoe8OMnhz7xgxGVyeVyuiEikidggSkY4PIMnufzx4Y8JC3aVKVMGn3/+udn5M0XR+ZHhSTl/SFh0i6mJzGBh+mSwfhAYZGHGDAMo77//vvkhykkR23Hum0Pa4tjREP1xmetbWJYrdwEupKa6WoiKiKK9fE0ZDc3h62O2k7/Xmdl8Dn4mAhlWxmXxM+189nlQxCwZDllyWnj7clokSv7CoDCHJTLQyvdXIg9PUHgRoGjRornKjJTwxQCKc3zBm0QOXsTgPppBbl6ACcZxDi/MsK4ai+bzeJXL5G8BL8zwYiGH7vC5PDPXGMBhAVjO165dO3zzzTde68JpDHKceeaZ+OGHH7yONTiNNdx4jPzTTz95TWNghsvj8TADNZ7TmPnCZfJiIC9SMZAkIhKJoiP14IQ7eeIPBrM7eDDKE1YWmeXwHkbs27Zta8Z08mRk4MCBZjqv7jrjSTnEhhF3PoaBljZt2uiANpcYQJliP4jD2Io+1isojDLI71j35O67704rUuyJBxKjR4/2ezWZRY/vuuuuTIdksCjubbfdFtBn/o477jAtuslJ6+UBTEZBGBaIY5aOiIiIhL8ZM2ak/W7zOHXFihXm+DQrs2bNSvd7z4CL0+0nJ+bPn2+OUTwDMzye4cVKEZFIF5FBFF6RZ1YJTyJ549UAp1aF07aY93GMKAMoPMFlkS4Hp/OHgNOYZstoPoMwzFJRanXg3HYyjmEX3B41W9xIxhb7bxzABhywNiLR9q7XUQRlEWMFJ/01rzDj4/fffzefFd9hPwzKsUsPPzusr+J7AMO6PZ7j4Z0WgjwoYcE3Bu4CwaAJrxwxMOMsh/d5Zjfxc81lMzOF68LuVCIiIhLeeCzBbGhmqDm/88QsJl4ozCirlBdSOCSHmTGe8zl4HMwh677ZMrz4wvmcQv3+pnFIur+hyzx28TefiEgkicggijOEgieobFnMnT1/aDhGlcGTc8891/wY8YTX3w8PWyCzHgq7s7BiOSP1rHFC7PrD7ALJ2lHsxKfuC3AcnlclbJzAARNM+cx9gRnSk/a+IQoXuT5GLXTPl5uX45QfffRRr/uWLVuGXr16mTHFTz75pNc0fo6mTZvmNfyMQb5+/fqZYN13330X0BUmYmCELZ2donIMzDCQyKEAzphsfp779++P8847Dy+++GKOWiKKiIjI6WlxzIsj/gIl/D33N43Hv7/++mtaxyB/eFzsG0RhBjZrzTF443uczMDLzz//nOUyc9rhUkQkP4jIIIrT0pY7ehZrZRaAk03C/7KFMH9wMtrBc+fPeVjAiyex/Jvzsv5AsIqEBVM5NEYdnGOKy55E8LMLYlAY1dABlSwWk818bO9eexUOIHVIyXF7Nw5hC07Cf7roMXh3LrLgwmZ7BpJwIi0rpTJa56oGSygxs4njkDmEhoESZo3wgMUTs1B4tYbZKr6YucLPoidmh/CghTdeXQqkwDDxIIdXfxysicLACj+zzjJ4JYoHSryfzxsJ9WhERETCyXErGX8W2Icq0cXREcG5WMFACY8JMpNRgMVfK+JAni+j+XjsnJNliohEkogMojDoUbt2bRMEYfcdX1mdPDLiz0yV7M53urSxRqCZNRgfuc/GNswN+vKLogIuco1FEZw6Sc/IEvsTTLef/fcvO1vtl/nYafZjgJ26neugFwa7fjbBlXDErJEbb7zRDI2ZNGlSWAbYREREJO9sjzqJm4ovQh+rGjqimja9iEgEisggihPsyGnQg/OFa8DEH2ZquGxm1YRmnS3zvyi4rKhMM1CW2V9hkz09rftOTngGXfZjDabZj6MmuqOWFZ5DfJjOyqs/ue1047QjnDNnjhlCxuU9/fTTpjo+C7flNmPmww8/xM6dO03x2ebNm+dqeSIiIgIstvfjR/cmr02xB/E4jmQz7TH3Qq9pZRGLa1z1UciKyMNvEZH/DO3FIwgzNnjLTvZHoMvMKjyzD6tTs0gQvI7ZHBb0h/2E+Xe4BlGc4AmDKU67YqeYK4MrmY0Z9sU2gp9++mlaUIVBlOuvvz4oQZR33nnHrB8r+6tlqoiISPaZou3/5tnSIntfukCJYxkOYJn7gNd9DVECl7hqI8ZOvehijrDy0UU7ERFJpSBKhIhCQfR2PY/d9jJMtO9CIo7lepkuRONs6ylUsdqiIOKCsp6RhMWK33rrLaxbtw6XXnqpCVIweHLPPfegZcuWuPPOO01hWX+tj/0ZOXKkKU5LLIrMtskiIiISHk4iBXe752KdnVrnbLtPh8GsbMExXJYyFdH/Xpq6wdUIF1rVQ7KuIiISOgqiRAgOtWHxVxZjjbOrpRWYPYnDSMLxgJcTjVgUQmor3igUQA2rC6pa7TJtY8zuOyfs/QiVBBzFEXs7CqM0oq1YhAsWhu3SpYsp1MrOO2yLzSAKuzuxvd+KFStMgMVfsTdfnK9Zs2bmRiz8yto8LDDLzlAshBxokVnfQrUsMut0ospPw9RERETCxUE7AXtxEn+4d2B5BgXzs8JhPlPs1G6P1MEuj1Z2GTPMp0AmQ6ZFRCS8KIgSYUqgBoa6JqcN6ZlqP4KF9ocBz18LZ+EC15umCgoxKJOZI9iBz939cBhbgjqUx9NC+wP8Y/+A/q4Pw7L98RlnnIE///wzLdX3kUcewXPPPYe3337bdMRhlkp2NWzY0LQ//v77701dlBdeeAEXX3xxtpfzzDPPmKK3b7zxBpo0aZKjQIyIiMh/3TPuxfjMvQ57cDJoy3zRvQxj3WvxZXQPtEKZoC1XRERCS0GUCBNlxaA4TrXZrWy3wRGcuupBR7ELu7EUZVDPBF08VbXaIw5VA85YsJFsAiknEMpMlCNINNdvgnfgEkwFCxY0WSNOEKVu3bqmc0/16tVNzRTfbZmUlIS5c+eaaWyL7K/VNrNc2CGKmShbt27F8eOBZxN5OnDgAHbs2IGSJUuqJaGIiEgOHbQTsR3ZG76TlUNINEOEEu2UbPcGYJbr/PnzcfBgalYMa7A5w4eZedqhQweUKaPAjIhIKCiIEuFaW8PRyhrmdd8K+1t8Y1+OVtZ1aG/d5jUtXNsJ5yesicJgCoMj27ZtSzf92LFjuOGGG1C0aFFMmTLFDAcSERERCRQvyLB22t9//51uGi/ATJgwAV27dtUGFREJAQVRIlxqW2LvTIdSyQ3Q8sStqBDbClEFY07bukUKBkrYVadVq1bo2bOnCZ7Ex8fjvffew969e02B2XbtTtWViY2NxbXXXmuG+rz44oto3bo1evfu7bVMtiP+5JNPzHLuv/9+NG3aNN20xo0bo0+fPn7XifVYvv32W5MNM2rUKGWhiIiI5ABbFY93b8Ei7AvJ9kuGGx/Za7AkZT+GuOoF1P6YF2Bmz55t6rJ17NgxLTOFBe45vHjx4sXmYo6IiISGgij/QaWTG6Dt8XtQPKo4UDBny0j9cWaTv7z7kWadF9tmrRcrrAqkbtmyBY8++ihGjBiBs846Ky3b5OWXXzbDaKZOnYpChQqlPZ7/vu222zBnzhx0794dQ4YMMcEXTxzC89hjj+Gqq67Cm2++6TWNw3Mef/xxXH755RkGUZYuXYrRo0ebuizDhw8PyesWERGJdAvsfXjQPT9ky0+GjXfcq1AfcbjYVQuFAjg0nzhxIl599VUTTOncuXNaZsrJkyfx0EMPmWOAcDpOEhGJNAqiSI7YSMHv9iPYZs9J6wQU6uf7w/0EVljf4hxrdJYFb0+HX375xXTmIY5LZoYKgyiBHAz1798/XVcddvsRERERCdQVV1xhslNYoF5EREJDQRTJEWag7LNXYReWwo2kPNmK+7AGyXYCUqzUwmnhgmOPy5cvb4bezJs3L+3+YsWKoXTp0hleDWLxWM7HK0ee8znYJrl48eIZPp+/aZ7ZLpzfMwNGREREIgMzgvfv32+G+BKH8vDiCy/e8MZjEBERCQ0FUSRHXIjG+a7XsR9r8YV7AE6EaKywZ8Hbc60XUdvqgaIoj3Btceyvcw+DJf40atQIf/zxR6bjlv0dBNWvX98MEcqsXfHZZ59tMmNq1qwZ0GsQERGR/IPDd1iknscZDud4ghdbWKvNsx6biIgEj4IokiPMriiGCki2T8DyKVwbGhaKWuURZ6W2Es6pePsgdmIxSqAqSll1grJmLBRbo4Z3q+hA8MCHhV9zO98///xj6qR44tUo1mVhNkq5cuX8LmfVqlXYvt27/bUnFsht0aIF4uLisrV+bLO4aNEiHD58ON00tl3kMkuUKJGtZYqIiOSlo3YSFtr7sMoO/ZBlOoFkzLB3oQ6KozFKZlnThNMrVaqU9nvKwrK8bdiwwdRqY5ariIiEhoIo8p+yC0vwqft8tLduR0/rKeR3vOr00ksv4aOPPkp3P7Eoba1atfzOO2bMGNNBKCMcCvTbb7/hzDPPzPbVsTvuuMN0DvDFrBzWgOnUqVO2likiIpKXNuII+qf8hiPImyHEW3EcF6dMwSCrFj6N6p7l45lt8vzzz6d15+FwHgZOHnnkEVNUXkREQkdBFIlYW+1Z2GRP97rvADYgGSex1Z6JGe5nvabFoRqaWIP+bQudfzDzg9ith7VSnEAGs1E2b95sgiyXXXZZujbHHPLjO1xo+fLl+PXXX023IAZPfOfJCjsFLFiwwHQLaN++vdc0DkFixwC1XRQRkXBXBoVws6sR5tl7MdHeFvLnK4WCuMJVB+0s/9mj/kRHR6cNGWZmCo8Hunbtau6fMWMGVq9ejcGDB2c6/FdERLJPQZQQ8zxh9D15jIyTScv8Ly+eJdC2y44N9jRMsR/w+9iN+AMb7T+87quBLmhk9YdlO88VXq2U/b1e5zPErJHbb78dzZs3N3+fOHHCdPgZNWqUCaJ06dIlXUBkwIAB5uZp7NixJojSr18/3HjjjdleJ9Zh4RUwBkw6dOjgNe3OO+80QRoREZFwV8kqjMejWuN992pMTAl9EKUsYvGIqyVKW7G5Ws4555yD7t27m99xDvXlfxVEEREJLgVRQownstOmTTNXA3w7sLBmBDu65GdFUA79XO9hsz0DM+zRXkGMYGlsXYym1mWoiBaZPu4kDmKyfR+O23vN3/uwOlvPswcr8ZX7UlPElkGbjq67UA3e2RThhFkfHK7DjI9PPvkkR3VZ8tKQIUNMhoraLoqIiIiISH6lIEqIcVjF1q1bsXLlSvz1119e0zh+1RmKkV8VsIqgPvrAjeRQxE+MsmhgMkQywmyMBBzGEWzHGvtXHEHOrhixw9Aq/PTvXxbq2X1QGnVRCCXgssLvq7Jx40b88MMP6NOnDy688MJcLYufxYMHD+LIkSPm76NHj2Lv3r2mYB3HXWcXl7Vnzx6v+5gJU7FixUxbM4uIiEjq7zBrnGT3d5hF5flbzuyTUqVKmYLuIiISXOF3Zhhh+AN21VVXYdCgQabYl293lEsvvfS0rVuksOHGRHsU1tu/4Rh2BW2pU+z7Mc9+E5e4vkFJhHeWR26tX7/efBadLj8sVsfsls8++wzNmjXL1rISExMxYsQI07XIF8duf/zxx2jTpk3Q1l1ERCTSvPLKK/j888/NMNvWrVsHPN8777xjfrufeeYZtGrVCiVLlgzpeoqI/BcpiBLqDRwdneEP2PHjxyPmCkFhlDY1RQ5iAw5ja1CWGYuSKI8mKBFAAOOovROHsBnBdAy74UYK3EhCOGJWB4fH8IrT9OmpBXR55YlBD2aBLFy4MF02SEZ4lYvLY6HZ+vXrY926daZNYk5bJJYpUyZdxgmXx6wstV0UEZH8ogIKobNVAWvtw9iF4A/B5lFgU5RGY6skYsxfqfbt25fh7zC77rErDzNSndpozCjlRYxly5Zh06ZN5iJe9erVg76+IiKiIIoESVV0wBDXJPxuP4y/TG2U3KuM1rjc9SOikVp5Xrydd9556NWrF2666Sbce++95j4GUH7//Xf88ccfGD58uBkuxqKzWWE9FQ4Nctx2223m6ldOMNuEV9DatWvndf/dd9+Nt956S2+jiIjkG72tqjg7qjJuTPkbH9jZq7UWiAKIwitR7U1XHs8gSmb4+37llVfiggsuwKxZs7ymMZgSFZW/ugyKiOQ3ykSRoHBZLrhQEDXRFTZS67ycxGEstT9HEk4EuBQLjdAfJa2a5q8yqI8YxMKyXJm2Md5s/2UyYEIhCfFYYH+ACnYzNLEGhlVtFB4kMZOJ7Yg5ZtrJfGKggmOpr7nmGvz5558m+yMrXE7BggXT/mZwpmjRoqbLDuv5sEWyv+E5mWW2eC6PevToYe5nbaA1a9aYZRYuXDhbr1lERCQvRVkWosz/Qtetj8GTApZ34IMddvi7W7ly5XSP5289L5BcfPHFaUN93G63CaCYdY6K8jufiIgER/icEUpEqGedZ2500N6E1fa4gIMoLkShtes61LV6B/x86+0pJvslVJJwHDPsZ1AdnUxxW1eYfWXYgvmSSy4xN1q8eLFpZ8xis6xrwmCKbxDFs7V2Ri2c2fq4d+/e5iCOy2CLxOwEUfxh8Vu2Xjz77LOxa9cu87eCKCIiEmyB/M6Fi4zWrm/fvuaWEQZSmInq2cjAc+hPIFmoIiKSM+F1RigRpQjK4kLX20i2472KwE63/4ej2IEe1pMohFP1YphxUgHZK2Iq3jj++aOPPkLp0qUzPHBkdgpbIw8bNsxksYiIiERSAOV190rMt/fh8ahWqIaiQVnucFcDdEJ5PJqyEBtxNCjLHGrVQx9XNdS14oKyPBERyRsKokhI2x83xIVel1lS7GSssL81114aWn1RzKqodyCX2M6QxeRYyJVFjJlFwhbD27dvN8NnWFyOV6wc7MAzZcoUk7HSsmVLxMXFeU13lnno0CFTqJZpwZ4BGRZE5tUuPl922i5yPhbBZfYJhx+F+9VBEREJb27bxhEkIgWnMk/4rxn2Lkywt2KYXR9FfA51i3CgsM/QmUC0dpVFQ7sEPrLW4LCdaO5LQAqOI3UITSA4JKg4CqQdFnVwlcdAV+oQZhERyT8URJE8xSE757leRgqSUBhltfWDcMXt6aefxsSJE01Lw4YNG5r7GSRhsdlbb70VDzzwAKpWrZo2D4f6sO3hG2+8YeqUfPrpp2jSpInXcl944QV89913eOqpp8w0du1xvPjii/jmm29M4dnmzZsHvK5jxowx6/jEE0+Y+Zw6LiIiIjlxDEkYnDINa+0jXvfvwgkc/3daQXgHTP4X1QYD/q29ll2FEI0Po7ri5L+1335wb8J97nkBz18DxfBF1FkobqVegCgHDbkREcmPFESRPMXsgzicOqHPqXj7EPZiJQ5hC/JCAo5gK2ahhF09rfBtuNi9ezdWrVqFuXPnmgwUWrRokWmNyDHRdevW9Xo8M094YzbJ6tWrzXzMEPG0ZMkS0+a4XLlyqFnT+/WybfLatWv9tl3kY9u2bWvaK/riMjkf2x/7LlNERCQQO+0T2GinDqc5iiSstA9lOLxmM46lu2+BvQ8V3KlFzYtY0WiCkojKpIC9J5dloTpOXVRoapVCB6ucRx4Mj09SsAwHUBIFUdcq7jV/TRRDAysOxSx1HRQRyc8URJF8aQfm43N3PyQjIU+ebxeW4WN3b7S3bsU5VnBaOAdTfHy8aXnoDJFha+NAMBByww03pBtawwr/bFWcXSxyN3ToUFMMb86cOemWqbaLIiKSGz+5N+F29+x//7KRCHe25h/tXoIXsMz8u7lVClOi+qBogK2FfZ1jVcFZUZW87uPlnbOSx6OnVRnvR3XxKhxrwUKBHD6XiIiEDwVRJF8qjipoZV2HbfZsbIVzMBU6xVDRdOeparVHuOGQHLYj9g1YJCQkoEGDBhnOd9ZZZ2XacYf1TipUqJDu/m7dupn2xf6mcR7WUenfv7/foT6svVKpkvcBp4iISFZ22SfwnXsjptk7TS2SnEqGjeR/599mn8Ab7pVoaZXB2a7stwRmBkuUT1CkfEosroyvhmbRZRFbyLummIiIRAbL9uwDJ3mKwxs6d+5sCoG+//77cLlcefJjy6wFDvtgYVDfk+/85g/3EyFtcexgi+OhrimItgrmi7aLJ06cMIVhOWyHQY1QCWT34e91BrrbCcY2yk+tLgPBIsL79u0z7yvfX4k8zBA7cOCA2T9zPy2Rx/kdZr0pz5pTkrHZ7j04K2Uc4nMRQMnItVZ9vBvVOSi/EWw1zH00L1LkZRF1fy2OfYvGi4hIcGjvKpJHeDI/134DO7EEZ1kPm2ya/I6dfh577DHTecdXxYoV8cgjj/g9QWAdl0cffRRHj2bcJrJNmza47bbbcnUAymFNo0ePxs6dO816snuRiIiIiIhITimIIhICtu1GAo7B9rlittH+A+vwG1pZ1yDG9s4QiUHhXGe65DUWpP32229NS2TfjJdatWrhxhtvNBlWbGvsGQxhpgw7CO3fv99rHi7H7XabwAvnY+App0EUXunl8iZPnoz169fjnnvuURBFRCQftjFmF56jKSdhHzoB2H5aCkdHAUULMt0w/bTkFOBYAn+YM3yOxNh4HCqWiMJ2NArmoP0x8feKFwaYEaIkbxGRyKYgikiIuvl8474CB7HR6/4j2I5EHMM37sGIhmfhVgs9XU+jIfrmy/ejZ8+eJuPDM+DBLJXLLrsMHTt2NC2TPVWpUgXjx4/3KoDLYSrDhg0z3X8+//xzVK9ePVdZKO+88w7efvttbNmyBaVKlcrxckRE5PRhB54rUqZhxbJlSLj2VSAhKf2DGlcC3r8aKOSnIPrqXcC1HwLxfub71y/922P+o0fweFRrDMxhBz4OpbnuuutMIOXll182w2lERCQyKYgi+VoxVEZltMF+rMVJHAr68l2IRlk0Qlmroamqn5mj9i4cxmbz75M4gj1YgUP//u3rINanu2+nvQjFkFqsNQZFUBYN4crhFbFQY7bIP//8YzI8mjVrhpYtW6JRo0ZeQQ924mGb5Bo1aqSbn51/6tev73UfC+EyY4XT6tWrZ9or5wTrDLCVMseks6aEOgKJiORfKbCx3j6CTSf2A6t2AsVjgeqlvR/EBj0LNwOVSwI1ynhPi3IBRQqm/jdtoW7gn52pmSsNKuJQQTcO2QdxKIcd/zZt2oTNmzdj2bJl5uJAoB3yREQkf1IQRfK15taVaGJdjK/cg7AWE4O+/FjE4WLXpyiNunAhJtPHrrC/xST77rS/k3GqwFsgptv/www7tX1yJbTEENdkFEBhhCMGPDhU5/Dhw/j1119RurTPAe1pNHv2bAwaNMgM3+GQIXYKYlBFREQiQN8WwHODvO9bvAUY8DpwRTvghUu8p9UrD/xym/d9R08CvV9iex3g51uBEoX8DwUK0Isvvoj33nvP/DbWqVMnx8sREZH8QUEUydeirBhYtgsWQpWxYSEasYi2Mm4FfNTeiVX2z9hk/4FkxOf4mVKQmPbvw9iK+fY7qIgWqGl1RTjiwSJv7EDAlse5MXPmTMyfP98UgGVg5sMPPzQZLuecc062h/TwCiBrrnA+plOztoqIiORTHL7z7Vxgxybg6o5Ap7pAYZ9hOwWigZNJQKKfein8DfB9POukuKzUW6GY1PlzYNWqVZg6darpojV48GD8+OOPOVqOiIjkLzq7kIhwOhvXsu7JePs2rMB3QVvmYWzBBHskltlfIj9gET3n5vydHT/88IPpxMPhPxyGc++995qaJtlZjufzi4hI/mf26ScSgafGAd8tAJ4ZCFzcJrcLzfS+7PyWMPPxpptuQuXKlfHSSy+ZWl4iIhL5lIki+Z4FF9q7RqK23RPT7CcQD++OLznV1roJ1dEJRVE+KMuLJDExMXjooYfMGPC7774bycmpV/8uv/xydOvWzRSZXbBggd/Wx/5ccsklaNy4sfk3C8s++eST2V4ndvp54oknEB0djffff9/UaRERkfyJgYy33P9gesp67MQJ5p4GY6HAh38Bf6wGth1IvQRz06fAWQ2BIR3wgXs15ll7cb+rOaqjWDBehoiIRCAFUSTf47CN2uiBcmiM+fa7cCO1An8yEpCSjSJxHBKUWoOEeS0Wals90dDqm2kb40QcN912QoVDfE7ahxGDQoiy/HQdOE0YqOjTpw9Wr16NZ599FocOpRb15RCc5s2bm/TmefPmmY47gWjdurW50YYNG0xXHQZq2EKZQ3IyGy7EA20O39m1axe++uor8/wPPvigGcbD+Rng4WPY7phDhYjL4zAkEREJX/PtvRiPrThexAXExqTWMkn8t2grh+HERAHHE1JvgWYiLtoC/Lr0VIHZL+emdvUZ0gGL7P3YZB/Dja5GqJ7FsFFeJOB/OZSHBdFFROS/Q0EUiRiFURqXur5Nqy2ywH4Ps+1XA56f9Uf6ut5KKyBbItNDqNQOPN+5r8JerPSqZxJM/9g/Yrs9Dz1cT4Rl+2OmLrOwrNOJ4JNPPsG5556L+++/3wRBrrrqqmwvk2nRv/zyi0mT7tq1qxnmc80112T4eD737bffjhkzZphsFNZX6dKliwmuMXjCrgms3dKvXz+zTsSiuNdff30uXrmIiITaI1GtcHWJurhqbBI2rlgNXDjmVBDlif5Al3rANR8Ay7cDJ/3UQ/HFGlv3nAsM/7fW2KpdwLCP0ibf42qGga6aqI3imS6GnemGDh2KFi1amN8e/m6JiMh/h4IoElFFZsuiQdrfFe3mqAjvIR2JOIr9WIeiKGfaI3uqaLVAeTQ1ywmEjRTsw2oc8NOuOFjiccDcTtoHT2/hlwwwm8MZhkNsS8wrcuxOwGm+7YXZGpmdcpKSkkyLYyeo4YlZImyXzIJ9bBe5d+/egDJjihQpgqZNm3rdzyCKU5iWz+U8n4rNioiEN+67q6EoikbHoGDdSkDCwdQCsE7Cydb9wNKtQJIbiM7GUJ8qpVJvxOW1qAYUKWAyVKrUbIkm5f6dlkHQfs2aNVi6dKm5sTMdf88YrD958qTJimTQfuXKldi9ezeKFSuGqlWrmt9GERGJHAqiSMRqZg1GE8u7DeImTMdn7n5oal2BHtZj6YbzuPSVyJVbb70VN9xwgxmCwyKxvniwecstt5iDy99//x1lypTJffAsKsq0l3SyYTxxKM+AAQNM4Oa7775DxYoVzf1KvRYRyWcaVgQmjPw3iGIDt30B/O9X4IebU4fznP9K9pdZpxww/jbg8zlAj+eB12oDQ1OHlvoTHx+P6667DgsXLjT/njhxIqZNm+Y1ncH7K6+80gSBeHvhhRcwYsSIHL5oEREJRwqihBivSvCqBU8aWYTT07Zt28xJpYQGa4iwyomnknYttLKuRXWrIwpYRbXpc+ngwYP4+eefzZW27t27mywSBjXGjRtnPu8sGMsaJQ5mgJx99tnYunUrvv76a9StW9f87dnGmHVMfvrpJ9PueNiwYabOiuc0Ph+v6vXs2TPtIJVBG3/4/eL68DGFCxdG0aJ6z0VE8qUoF1Dk3/pYrH/CVsdxhYAKccCOQ6lDdTyx3fG4Jaktjvs0Ta2fktEyo6zUQAxbH2eC2Yy9e/c22ZL+fm/428f/9urVK62eV7169XL3ukVEJOwoiBJiPOmbMGGCqe/Akz85vcpaDXCh9Waul3M6Wul6Dk0JFyzmOnLkSJxzzjkmiMJ1ZPYHi8069UmY7ux5AMpuPswM6dChg6l50qNHD69lsjvPnXfeiU6dOuHbb7/1GnrD9sd33XUX2rZtmy74IiIiEc757eW+/+pOp+5jEMVXfCLwxC9AwRigZyMg2pU+0OK5TL9PlzrN+a1hUISFy/1hodnly5eb477HHnsMFSpUQIkSJfQ7JSISgRRECTFWbT/vvPNM55ELL7wwXSbKM888E+pVkCDjQdU8+y1sxl84hl15sn0X2B9gG+ahC+5DnFUF4Wbu3Lm49tprzcEigygsuseDx6zMnz/fZJv4ZqIcPXo0xGssIiL5QRFE48mo1li4fhWee240kjrWBi5vmzrxRCIwegJwJB544RKgUaVTM7LjziN9U1sZ3/lVaubK4PbeC9+yH3huIjqXqIUh771ngvcOZkz+73//Q5s2bUwRWQXtRUTEoSBKiHEIgedwBE9LliwxY2Ul/9mK2fjH/glJOJEnz7cNc3HAXoczrRsQh/AJojBLhAVdmT3yzTffeE2rVKlSlvMxW8V3PqdQrL8WxM58GQ3f8YeP5TwqJisikv8UtKJwkVUTlffvxkufzkGSnQJc8O9xFYMn3y9IHZLDbj3OcB+naGy/FsCCTcCDPwApNtC3hffCtx0EPp2NepfWwTX/u8YrUHLgwAHTcY6FYhlEERERcSiIIpIDZ1mPooU1FN+7r8ZheNe6CYWu1v1oaPVFKdRGuLU4Hj9+vMk+8cUgSFxcnN/5qlSpYoa3+ZvP4S8NmoVhf/zxRxMUCeSqIIMxLDrLrgmew4pERCSf+nERMH9T6r9T3MCm/UDjjIP2acYtBpZs8b6PmSwc9iMiIpINCqKIZBNP3kuiJgraxRENj6teIVQC1VDB8p/RFKgkm82S1yEWJRBnVQ3KejFQ4ttWOBAcV57T+c4444x0w6s2bNiAY8eO+X2vatasadpM+uJ8GzduzHToEGu4sF1zoN18uEy2uuSQpMwCO1wmX4uIiASe2cv9//aTh7A9xckCtYC65VNvrgwC6xzW06QyEJ+Umo3iIbZgLOo0aWIC+/5+3/h8/qb5w2xHFkvnbxELmouISORSEEXkP4IBlI/dvdHAuhAX4I2IGd/NbBYWt/3jjz/8BixYnPass85KN40tkVmkdsqUKRkum5kvnM7uQ4EGUe6//36TnZMRtnXmMmvVqhXQMkVEBGjcuDF+++03vONehVEps9N32YmN8b+Z6lf4tzVy+gKy9azSmBDdGyVjCqf7TWSwe9KkSeZ3JJDfSwZd3n33XdOdh50ZRUQkcimIIhKBDkVtwKrY31A4qjAKuFOzKA5jK5iLsttehkX4CPA4nixklUQ9nGfaQudHPGB1u904//zzveql8MB38eLFpqsPp/FKpuc0FhH0HXLEx7NeEbsGNWnSxGueQLRv3z5dPZdly5ZhwYIFpoMRl6lWyyISyXbZJzDJ3oZGKIk2rrJBWSazO1isv4W7Moa6UzMzE5GCX+2tOIRMhuQwwFLs1D65o1UedZG6369uFUUpVxxirWi/z+cvizEj/E3hUFMGUeLj47P34kREJF9REEUkAu2MmYNpxe9I/cPn4tsW/I0t9t9e95Wzm6CmqxuikD+DKMSaJ6x/wuwRzywVdsdavXo1Onbs6BUQ4QEyM1h8PfHEE1i6dCluv/12M292MnaYzn3LLbeku3/06NFYuHAhbr75ZvTv3z9isoBERPxZYx/G8JQZuMXVGG0QnCCK4yyrEs6KSq2BchiJ6JT8S+ZBFB/XuupjqFUv7W/tj0VEJLsURBHJoQIogh7WY9iBhZhpvwQ3Mi6SmlPV0QXNrMtR1fJpy+gj2T6Jv+znTbYJ7bNXm6HigTqK7fjVHokoOzWI0tS6DDWtbgh3LDI7ceJE9O7dG1dffbXJKsnOAXFWj83JwXUolikiEq4mubfhe3uj13077RNIho3f3NsxAjO8ptVBcdzuOgMxlitHz+e5Dy1kR+PhqJY4aCd4PeZDew2W2PsxytUUlVHEa1oHq7z2wyIikisKoojk9MtjxeIM61LE2dUwyx7DUEbQt2U5qxHauEZk+phkOwEncRjL7a+xG8ty9DzxOIhF9kdpf5dFQ1TGmaZwrssK3wJ5c+fOxfvvv48JEybg7LPPztWyWCOFXXwSE1OvaLKtJYcJcWhOTtsjO8tkenewlikicjqx9tNJpMD9b5rjPHuvqVPiz1IcwFL3Aa/72lnlcC0aoKCdug8siChE5zCgwvbHg6xa6dZvfspebMZRXOKqjcZWyRwtW0REJCM6ihfJx3iw+Jc9GmPd55nCscHCzJqx7nOwF/4PjCMRAzKsg/Lhhx+a+ir33nsvBg4ciD179uR4mYsWLULPnj3x9ttvm/fqoYceQr9+/bBjx46grruISF45gARcljIV3VLGmdvb7n+yNf9y+wB6pfxq5u2eMh7T7ODvD++Lao7x0b1RE4HXNBEREQmUMlFEcikGhVAOjXAUO3EMu4KyPaMRa9ooF8Op+h4ZOYhN2ImFCKbD2ILj2IskpG8bHE7KlSuHRo0amcKxy5cvN/exEGC1atVM8GPXrl04fvx4wFkjzBIpWbIkSpQogS1btph5ncyUnGAwhsvkMCMWRNy6datpf8zsFBGR/ISB4K04jo32Ucy392I7ctaB5hiSscDel/b3UvsAqtpFzS8eM0tyi8N9aqF4rpcjIiKSEWWiiORSeZyBa1xT0c66NWjbsgwaYKhrCjpZdwVtmZFoxIgR+P333/HJJ5+YTju83X333SZ48c4776Br166YN29eQMtq27Ytpk+fjr/++sv8l112cqtly5am9TKXOWPGDLM+IiL5EQfv3JsyFxemTMLOHAZQ/HnYvQDnJU/EljAP2ouIiDiUiSKSSy6LeSMlUAkt0AxXmPuSkYh19iQk4EjAy6mKDihl1TT/ZhZKYZRGtFUww8fvt9diqz0HB+zgDePxZCMFa+yJOIY9qINzEB2G7Y/ZzrhAgQLo3LmzySBxslM+//xz05mnT58+mDp1akDLiomJMRkoxCBMr169TEbLpEmTULNmTZx11lnZrmMSHR2dtkxexWXdlrJly5p12rBhgxk+xC5BIiL5wXEk4whSazwFC0vQssuOU2NFREQk3CmIIhIkDDTUsc4x/47HAbxrd8xWEKWNNQLNrSsDfvxG+w/8ZA9HqKQgEdPsR1HWboTqrk6IDtP2xwxC3HPPPWl/jx8/Hn379sXjjz+Ojz76KK3FcXYwWHLnnXea2iUdOnRAvXr10K1bt1wVg2WK+a233oq9e/eaZVapUsUsU0EUEREREZH8Q0EUkSDxbLtYwC6CbtZDpuuNp0X2x9iDFeho3YGiqOA1rYp1ZjbbLubVVbvwvzroud2aNGmCMWPGmOE5GWGghRkm119/vampktkymUESCC5v3LhxuO6669C0adMs11NEJL+Y7N6Gn+zNWGZ7d9oJZobLEymL0MIqjVtdTbJsf8z98tixYzMdrskuaHfccQcqVaoUgjUWEZH/MgVRRELxxbJi0cxKHdrjedC3AwtwxN5uppW1GmrbBwG3K4u/cggOD5pr1KiBm266ybQVjo+PN0NqeL9nAGPhwoWmCw+H7HCoju90Z5lsSVywYEFz8/d8vN/JTlm6dCk++OADk11St25dr2me87GoLIcgeS5TRCScLbT34Q33ypAtPwEp+Mxehw04gpvQCDEBlOz77bff8Nlnn6Xb1xL3tUWLFsWQIUMURBERkaBTEEUkD3W17seZ1o0ogera7kHCrjqjRo0ynW/effddlClTxtzPgAYLzjIzhNkpzv00dOhQU+PkvffeM/PwxloqDgZI7r//fqxYsQKvvPKKCcw4w24YDHnggQfMECEWr61YMbWD0uWXX46OHTua4Ayfm8v0vALK+R599FHMnz8fzz77LGrVqmUCPCIikjMMlLz11ltmf+qJwzlnzZqlzSoiIiGhI3iRPMJMh9Kom+vlJNknTQvio9iNvMDaKPuxFsXtKqblcrgNSWFwYuXKlfjnn3/MjYVbadGiRZgzZw4eeeQRtGrVymueqlWrmuDHE088gcWLF5v5Dxw44BVEYbBj3bp1JgDDArOez7dq1SqTzeLZ/rhy5cpmmQyQ8Hm5TLYz9pyPy1yyZAkaNmyIOnXqhHjLiIhENga3mzVrZvbTnvta53dAREQkFBREEcln9mE1PnWfb4rX5oWD2IiP3eegiTUIF1pvIVzt2rULF154YVpa94kTgbXg3LNnD/r3759u6M2xY8dyfCDOgMzAgQPTFY09evRoWrceERERERHJfxREEclnYlEMtawe2GuvwHbMD/nzFUBR1EJ3lMepK33hhJkxrEPiOVzHwSBG+fLlM5yva9eumQY12Da5cOHC6ebr0qWL6a7jO43YbpmtlzNSvHhxk4IuIhLudtvx+NPeiSUhKijra7+dgG/sjWiMkmhppd+ne2rXrp2pLxUXF5cn6yYiIuJQEEUknymBmhhgfYj5eBfb7dAHUYqjMvq53kMsSobdUB4nUMIaJdnFzJN77703R/OxBktmrZFFRCLBCvsABqdMQxLcefJ8a3AYV6X8gVtdjdEyKuMgCn+LWEBcRETkdFAQRSSfcQIZVp52HraCEkBx28mYY7+BBBxFB+s2FLByn5GR0/XKzevxnHfNmjV4++23TYFbX+zSM2LECL8FZFlvhQURk5OTM3weZtj069cv4PXatGkTXn/9ddOZKCOdOnUyQ41ERLJS14rD8662mGxvx3h7S8g3WA0UxY2uRmhjlc3RPvyvv/7Ct99+i3r16uHpp59OK/wtIiISTAqihBhrK/DkioUqefPkWZRSJNLYthsp4Mn8qWhPMhKw3P4Kx7AbLawhcNneu6AoFIBlZd3aMpxs2bIFY8aMMd9132AJh/ZcddVVZniP77QdO3aY7j6e+wEuwwmAME2dt+wEUXbu3InXXnvNLMP3+bj/4f18PgVRRCQQVa2iuDWqCU6kJOdJEKWiVRi3uBoj1sre4Sn3b9y3sXA3g9Pvv/8+rrjiipCtp4iI/LcpiBJiLDA5YcIE0yqVV0g8HT9+PODilyL5zWFswy/uG5GAw2n32XBjN5abjj9fugciCjFp01yIwbmuF1ERzZEfXXbZZRg+fLjXfRs2bMAFF1yASy65BDfccIPXtKZNm+LXX381gRPHoUOHzONKly6Nl156ybRWzom+ffvi9ttv97qPnYtuvfXWHC1PRCScseU892/NmzfHb7/9ZjJRREREQkVBlBDj1RF2+Th48KDpHuIpISEhXXaKSKAKIg6lUAfHsdsMjwk+y9RDKYHqsBBYdshxey9O4lBaV58t+Dvtb1/bMMfrbwZR9torUQBF0graFkWFsKzDQhyGs23bNvPdrl27tjl4Z+aJ72NmzpyJtm3bppufBW05tMbT3r17TdYKi8927NgRBQsWzNG6VapUKd26MKvFswORiEh+x0xf7ocZsGYmXocOHdLt+0RERIJNQZQQ4xVlpvPzKrXv8B1mp/AqtUhONLAuRC3rLPxq346l9udB34jRKGgKylZBGxREsYDmmWm/jPn2O+bfHMxz0iMLJStuJOEX+0a47NTslPpWH/S3PjDBnHC0b98+DBgwwHTpmTZtmgl8iIhI3uFFqsGDB5vhi8zsY0c1ERGRUFMQJcR45ddfG1Tij324XmWX8BdjFUK0HYtoxIboGSwUQgkUskpl+cjD9lZsw1zsshfjBPbl+Bk9gy577VVYYX2HCnZTlLHqI9wwi2z//v0oVaqUaa8cE3NqaFJ2cUjP7NmzsWrVKnNSwADNDz/8gIYNG6JZs2YBL4frwhoqzIoREQmW+lYJDLBqYJa9BzsR/GHIBeBCN6siWltl4fo3cM794ty5c7F7925TZNszUM1p8+bNw/r1683QHe6D2c4+p9l7IiIi2aEgiojk2mb7L3xjs4hf8FoGcbjPV+5L0Mt6Bp2tuxHJeELwwgsv4Pvvvzf/5tC/yy+/HCNHjjT3B4onE5999pmCsyISVP2s6rggqhouSpmCn+3NQd+6RRGDV6I6oD7ivO5/5ZVXMGnSJFNTzjfb79VXX8W4ceMwY8YMNG7cOOjrJCIikhEFUUTyMWYyNcHFKImamGu/gaPYGZTlNkR/1LA6Iw7VsjFXKHouc5l52ss5YDygv//++03WCP/rvB9DhgxBtWrVTJccdorw1/rYF+e78sor02qnbNy40XTu8Sw6Gwguxze7LT4+3rQ9ZpHrRx99FC1atMjWMkVEuF9xhXhXzD2X7/6L+0Df/eDff/+NH3/8EQsXLjT7NwaamYmSEQ65ZMFu1oUSEREJBgVRRPK5ulZvVENHrLJ/ShtK44YbNrI+eT+FpWOj06qP1LF64UzX9VnOxYNb1jJxIxmhwtoqKXZi6vqFUfvjokWLYsSIEZg6daqpbcT2wRy+1759exNg+fDDD00wJJDi0TxxYEcdB6+6fvLJJ+Z+1lKKiooyt5y0Vz969CjGjh2LYsWKma4VGQ0vFBHJCn8lYuAye/1giYJlhvNYfupfsdYJh0p6BleWLl1qMlQczL7LTKtWrTBs2DAFUUREJGgURBGJADEohAtcbyIRx8zfa+wJ+MseHfD8JVEDfVyvpnXGKY26Ac13GFswzn0zDmA9QmWB/R422FPR2/UcKiL8siiY2eG0Kubtyy+/xPvvv4/Ro0dj06ZNGDVqVLaX2aRJE4wfP95cce3VqxceeeQRdO/ePdvLeeaZZ0xA5qGHHjIdhFQvQERyimGMx6JaYbBdFzem/IVdiA/KxnzQ1QI9rcqo8u/vj6f77rsP119/PapWrZp234UXXmjqRQWKAeTY2FDVDhMRkf8iBVFEIoDLikZltE77+6h7N4qlVDWZEU72RopphLzTBEoKo6zX/KVRDzXQGQWt7HWYScIJbDZtjA8iVNgq+TC2IT6DVsmnGwtEd+3a1fybWSdffPEF9uzZY65+xsXFpUtPZ3bIjh07zBXWChX8t3Bm++MuXbpg/vz5+PPPP83ysuPw4cOm6O3mzZtNfRUWmq1bN7DAmIjkfwzo7kY8EuFGJRRGdBCy+FKHj5ZCeRRCXSsOhezUQ8hDSMRBJAS8nIKIQkUUSss8aWOVRUdXBb/P16hRo3T3V65c2dxEREROFwVRRCJQjYSzMeDIL2ZYSeFChcx9e7ASn7n7mtbB51kvez2eQ2UKoOhpWtvIwYP+Z5991gztYaecdevWpXvMwYMHcfHFF6NixYr46quvQpJi/u233+KBBx7A008/jaeeesqsi4j8d3BA58iUWVhlH8b46HNQyU+WR06VQiy+izobKf/Wq3rdvRJPuhcFPH9TqxS+iTobBZEa2CkB1SoREZH8RUEUkQgUjUIo7C6LInYcilipB89JdjzqW+ejKtqjCMqrg0uQ7N27F7NmzUKdOnXMVVNmppw8eRLTpk0z7Tf79OnjdTWV4/uZGcIrxRyyw446vp0lmEUyc+ZMUzSRtVI8r7oeOnQIU6ZMQf369dMK0TpYPJZDgJi5wmkcwlOuXLlgvVQRCUPxdjKm27tw0qM2FYMoq+3D2IpjmGBvQxn7VOtfZoC0tcqivJWz+khRloWySA3OUwurNC60qns9Zj9OYqa9G7VQHI2tkl7TGlolTCZKASt7dZ5ERETChYIoIv8RJVADF1upBfj8DSGRnGGRQ2aW3HXXXSbrwwl0cBx/9erVTb0Uz2wTZge98cYbZpjOueeei1tvvdXUT/G0cuVKDBo0yHSUYNtjz/eL2S1c9vDhw9MFUVavXo1LL70U1157LX744Qe9zyL/AftwEsNSpmM7jnvd7/S0uS5lerpCrj9F9cJ5Vna6r2Wsv1UD/aJqeN033d6Jc1ImoK+rOp5zee+nSL9AIiKSnymIIvIfkXoiHpxD1xQ7yRR83YlFSA5SccHMsNMQn2+HPR9trOtR0CqGcGE6FLndJvPEaXV8/Phxk03CVsesS8Obbxti3jjf9OnT0+ZzbN261QwJIs95HZzPs+3niRMn8Pbbb2Px4sWmmw+zWB588MFM13vgwIFo2bJlrl+/iOS939zbMM1ObWl/BImmLklGHYh97+cwnI/ca/GXvdv8XccqjiFWPZNhkhNmf+ZzHzNQHne1RmurDFwK2ouISIRREEVEso0tjZfYn2ErZmezlXLOsJHyMvsrbMc8NLeuQkGETxCFJxAcojNv3jxz88TisVnNt2DBAnPzNz2jtsaczzO4wuFD7AjETBRasmSJuWWGQ4wURBHJX9xsXQ4bf9g78T/34hwtg0GVb+wNadGVHlYlXBZVGwXsqBwHUnxVs4rinqhmQVmWiIhIuFEQRUSyLQoFcK7rJey2l+FX+7a01sqhwsK3Pa1nUNVqh1iUQLi1OP7ll1+8MkMcrI+SUSCladOmZj5mlWSEmSy+WEPlww8/RK1atbxaeL777rsmAyZQvnVYRCT8zbX34GH3Aqy1jwRtmYvs/Tg/ZRKucNXBNVb9oC1XREQkUimIIiLZ5rKiUAVtUBBF4bJj8mALWqhktUR1q2OulpJkn8Bx7EUs4hBrBScYw843PXr0yPZ8DLCcddZZ2Z6PNVU6dOiAIkWKmMDNvn37zHCeSpUqpXtsmTJlzON8cT6nBXJGmAnDFszZ6R7EZR47dizTZZYvXx4FC54qcikigdsXfxS/71xmCsemUygGKFuMX7T00+ITgb1H04/tYUFqAFOxA+1KFgVKBx5EYQbc7t2pQ4Iy219xXyciIhJJFEQRkf+MLZiF791D0cEaiY7WHYgEjzzyCH766Se/01599VUMGDDA77THH38c3333XYbLLVq0KH788Uc0bNgw4HV55pln8Pnnn2c4vVChQuY5mzVTmr9IjsxcB1w9GnD7GUbZrQHwwdVsn5N+2pyNwDUfACkZZ77htjuBe7oGvCochnj55ZcjOflUVyBfI0aMwMMPPxzwMkVERPIDBVFEJCLts1djP9Z53bfdnoej2I4dWIjV9nivaUVQFpXRGpaVvpBrODt48KBps9y+fXsT+PDETJPJkyebaRzy44mdg9hq2dOWLVuwfPlyM9SIw4ZiY2OztS6HDx82V6bbtWuHuLg4r2nLli3Dzp070wrmikjgTtjJpmXwvJM7Ye88BNQum3rzVCwWmLgcqFceqFvee1rxWKBZVe8gSkIyMGs9UKQg0LoG1pW38Kt7C1qZ9senWhhnhEWs+Z2uWrUqGjRokK7d+pw5c3DkSPCGHYmIiIQLBVFEJCIttj/FdPtpn3tt87+l9udYZn/hNaUOzsFg18+wkL+CKMTgyZtvvon69et7DdkZOnSoabvMDkAsJOs5rGbkyJG4/fbbvZbzzjvv4MYbbzRtlzmvv85AWWHg5aWXXkpXtJbtmj/7LLXFtohkz17EY2jKH9iRstDsw3BZW+C+87wfNHkFMPCN1PsfvMB7WotqwLc3et/HYEzXZ4G6FYBvb8A3MdH4PmUyvo/qiQus6gGvG7PdmIXmifuc3r17620WEZGIpCCKiORYYZRBF+tek+GxAt+GZEvWRk/UsLqgJGpm+rh4+xAW2O8iAUfN35vsP0xXH/9Sgyme9mMNptqPwbLZrtOFptblKGPVQ7iaPXs2/v77bxM4YXHbcuXKeXXzYRCFt5QU/92T/AVInPv434w6A/mzcOFCM/SHdVkeeOABVKlSJd38qS22RSRHDsfD/fYk2McOAg+eD3StB0T5fIf5FWOhan+9jvn98x3mY77vVup8Lhdsl2VqrWTUKtnBukcsZH3o0CHzfe/YsWO673t29h8iIiL5jYIoIpJjRayy6GzdjaXuL7DCDlEQxeqBzq57MpxuggVwIx4H8Lf9Io5hV46e5wDW40/7SfNvBlEqWa1Qyq4FC1FhGQBgqvwTTzxhapBcdtlluVqWE2xxOgXxv6xzwBOhQF77okWLzLq8/fbbGD58uN/HMDDDTkVcNp+Lf4fjdhUJS4fjgVemAC3KAN/dlD6Akh3sJOa2U4f28N/2v/9mkCWA7DMGUVhviUMCJ02alGHxaSeQwn0Jv+85yWwTEREJR/pFE5F8zUYKptgP4gf31YjHwSAt041p7kfxnT3EdPOJdGvXrsXAgQPx2muvmb9ffvllDBo0CJs2bQrac9x888349NNP8frrr+Omm24yHYVE5DRg0OSJX1ILze47BizeClz0OvDp7KA9RZMmTUx2GjvzXHDBBSZrTkREJFIoiCIiuRZjFUJxVEEBeBc2zY1oxKI4KqMAvAui+mIeCocTbcJ0pCAhaM/P4rMb7T+QjJMI1zooHDYTHx+Pbdu2mduePXtMVgmvFPPvQAMVbFW6cuVKUxi2cuXK2LBhA37//XccPZo6NCoYGjdubFo6r1ixwpxQqcCsSNb4fd5rx2On6yRSKhRPLQK7/SCw7WDqf08mAcnu1PomDIjYgSyUVaT3A+v2AKWLsGc98NtK8zcn7cdJ7LCPI9nOpJNPAK3fe/XqZdqZT5w4Ebt25SxDUEREJBwpiCIiQalbMtw1E02si4O2NWuiG65z/Y3m1uCgLTOSMFOEwYi//vrLdN/hjUNpEhIS8M0336BDhw6mM08g2Flj6tSpmDVrlrn16dMn5OsvIllLho1bU2ZhQNk52PfDMKBvC+Cs54AuzwDdRgPzNgJ7jgADXgfu/iZ1mE5WGDR59mJg+r2ptxcuSRsexLnvTpmDC5InYSeULSYiIuKPaqKISK4VsIqgAIqgst0GR7Dd3JeI49iGuXAj0Ja2lmkxXAglzV9VrfaIQ9VMWw7vt9diP9YiHvtD8i4yC2WTPR1l0QCV0DKs2h+zZXHx4sVRt25dbN+eus1LlChhMkjYZpjdeJYuXWqyTLLCmgbManGufLdt29ZkuLAt8fHjx9GmTRtTzyQ3mOnCDBeuV6FChRATE5Or5Yn8F7BqUHWrKOpEl8T+SklIrFEaaFAxNVjCYMjqXcDeo0DVUqn3MRsly4VaQFmPDL8GFYCzG6VlpFRp0Rx1y8YhJhfX2djieMGCBaYNMjNSypf3abksIiKSjymIIiJB09oajtbWdebf+7AG77k7m4KvgYhCDHq5nkUNdPY4fci88Ogi+2NMt5/JpAtP7nDdv7eHorZ9Nq50jQu79scszHr33Xdj1KhRacVm2Vb06quvxrhx4zBkyBBMmDAh28tk62Mug8NvGGBhlgqHD+UGC1GyCO5vv/1m2h+re4dI1qJg4SlXa2zCMXRK/hm7WtcEfrw5dSKH8bClMQMpv98FLNueWtsku5pVA364CXhuIlz9XsMj332H88/vbp47p5YvX45+/fqZ1ubjx49XUVkREYkoCqKEGGsTLFmyxNQnWLNmjdc0jhFm6r1IpHBZp9paFrHLoaN1F5I8UsJtJGOJ/RkScQwtrKsRg8Kn5kWUaWPssgLfLTF4wsKyocTlh/o5csMzGFG1alXcddddaN26tckc8df9Zv78+Saw0rdvXzRt2jTDZfLmdNLJSvPmzfHggw9i586dePbZZ3HVVVehYsWKXo9xOv44XXpEJGv8DjOYEW1ar/87FMf173ee/76kDbD3GFCicGp3Hd+v/JF44OOZQNmiwKA2/rvveC4zxQ2XDURnknXHgCoLRbPFMb/vHDrYo0ePdI/j9530fRcRkUijI9k8CKLMmDEDs2fPxi+//JK+NSur5ItEoCJWGXS17vO6L9lOwBZ7Jo5iF7pY95oWyZI7DE5wP8LgRLVq1fDII4+Y+3jjCZhvW9F58+bh0UcfNY9lsVd/rYYzm9/z+Zz5WrVqZW6sycJsk7PPPjtdEEVEgsBpT8zvHr+bV3Y4dR8PJ3if59f5yEng5d+ARhWBAa0YHUkNmvhbJnGax/6A33XffQGDKHfccQemTZuGc845ByNHjvQbRBEREYlU4ZWbHoFYo4CtQx944AH89NNPXrdXXnnF1AYQ+a9wIRo9Xf/Dha43URDFT/fq5Hs8wXnhhRcwePDgtLooxPR5ZpowsMGgBjNUHOeee67Z/zBD7vLLL8fmzZvTLXPMmDG49tprzYnSiy++iNjY2LRpHJZz6aWXYuPGjXn4SkXEmL8JuPgN4Nv5pzbI/mPAdR8Dvy4FvroeGHTmqWnsvvPOEOD8ZsAlbwFfzU2/IZdsBQa9CSQmA9/eCLSukTaJdZUuuugijB07Vm+AiIjIv5SJEmI8+ahTp47faTyJUZqr/NeG+1RDh1wvJ9k+iXgcNMOC8kIyEnEUOxFrl0BBK/OWy3lt4cKFZnjOjTfemHalmPsWBlIuu+wyc6XYU40aNVC9enV8/fXXZr7rr7/e1D3xxMw5FqhlxorvkB+eVLFlKQPD/jDQsm/fPuzYscPr/kDbLYtIehzSUw6FcHJvIg7+ugyoXxHoXDd14o7DwG8rgObVgN5nANEe18cKFQB6NASSU4CJy4E65YBu9b0XvmY38OsyFG1cHXHntUVsVGpxb+J3+ddffzUdvDLLuPX9vu/fv1+ZtiIiErEURBGRfGcTpuMn94iAi9bm1nbMxbvuTmhv3YqO1p0IN0ePHjXZIU5Qln8Hgic/V1xxRbpOOTwBymnhV3b1GTp0aLrADLt1iEjOVEBhjIs+B5NdblwHC+73pgPfzDtVYHZfYN95fPg38MNC7/tOJplaKENc9TAq+kKURfYyZD/99FNTyNoT670lJQXamU1ERCR/URBFRPIdtlMuhdo4ABsJOBLy54tBIfN8/P9ww7om3bp18zsts7aibDXcvXt3v9OYPVe4cGG/HXl4Rbpr165+p9WvXz/DZTqZeWzNLCLZw0KvVVAU5cqUTc0kcft0JKtXHmhaJeOGZqWKpM6XkkEns0ZAXK3KqO6TaVeqVCmzf6ldu3a6WUqWLGm+704BWX/7powycUVERPIzy1Zl09OGKfedO3fGgAED8P777/st8BgKvFJ88OBBFC9ePNdtSyU8cegEOyfExcWhSJEiiDS27YYbyfjdfggz7NEhf75a6IHBrl8QhQJeHYhOh8TERJNiz/eV32F2z2HhR3+YmeJbGNbBE5+M5iPui/x1+OF8/NnIaFpWy2SGS0brJKlOnjxpMne4f+Z7LJHH+R1mUDE7gcVxKZvRN2GC6UuWDr+PUSws6+c4goVjs+i0dX90KzxV4Mx0haS5j+F31jc7zZmW2WGk0+nrv4QZONxHM2jMunh5cVznPC/3HQ7W3NOQcRGR0FAmiojkO5bFhsgFYNl5c3DO5qJRiMlVAIUnGv/gBxy2t6G5dSUKWSVzv17/BjpyIhjz7d69G5999pkJ7PgqW7asKXhbsGDBdNP27t1rhgBk1uKdmTIXXHBBwCcgHILEZfLk1N8V8yuvvNJk14jkldX2Ifzg3oTuViW0dZULyjJru+Jwd8GWmG7vwkx7d+AzmjbG/r/zNVAUF7tqoYtVKf1sLleGQc/MpomIiEQyBVFERIIs9cqs99VZGzYWuz/FZvyFeta5iLXjfOay8uyKZbDs3LnTtFRmbRXfdT/jjDNMVw/WW/E90dq1axcee+wxHD582O9r5vZj5yAGUQLFK7+PP/64yeDwXSaHFPTv399cGdZJn4QCP7O++RhL7QO43z0Pz7jORBvbu517xrkbmWtolcD/os7EwynzMcsjiJLd5Xl+Q+pacXjK1QYxlgIiIiIigVAQRUQkyE7iMCbb9+C4vSftPp5isUBtAg7jF/dNpq6Lp06uu1EN7fPle9GjRw/cdNNNXvdxqMLw4cPRqVMn3HLLLX6DJay1cOutt3rdt23bNtx33305XpcOHTrgrrvu8rqPhXb5PC1btsSoUaPyXbBKwt+H9hr84vZuF74DJ0xwY6x7rVfAg5q6i2M4TrUez65LXbXRwipj/r0fJ3FPylwcQMaZXZ746b/f1QKt/p2/HGJN9x8REREJjIIoIpJvMRBRBGVxEoeQguB3grDgQiGURGwAQ28S7eNpLZePYy/W2hNxGFv8PnY9fkv3TPXt81EKtcxfHDoUi5Jhe7LPWggMkhw5csQM22nSpAn69evntb5shTxy5MhMh9BUrVo13XwrV65M1y0oqwwArgtrAJUuXdoMA/Jd5tq1a3HnnXem1XMJ1+0q+Uey7cZBJMCpADTX3oMfbe8gimMFDmKFfdDrvsN2WfS3yiHBSkC8HY0SKIAC2Rgu2MgqaW603T6OV7EC0T6BkENIRDLcKImCXkESFyx0syribFflbLxiERERcSiIIiL5VhvrBjS2BuJ79zXYiplBX35hlMFlrm9RCnVMVZTMLLY/xl/2C+bfLHp7FDuy8Uw2frPvx5/20+avylZrXGSNRTTS1xMJl8LFQ4YMMbVQfv75Z9MF6HQFJrgOI0aMwJ49e/D111+jYsWKp2U95L9lK45jYPIUHPo3+2N/gFkgjtkFDqBvyZlmeFmB5Gh8GNUVHayMu2llpjwK4efoXkj2GNTDwrPDUqZjjX0Y30adjQrWqWCm9W/LZBEREckZBVFEJN8qbJVCQbuYaUEcCi5EIw7VUczK+MQ83j6I3ViKHViEg9iQ4+c6jj3mRgXsIthkTUdJuyZKW+HXIpTZHBx2Q9WrV89222J2FurYsaNplxyMddm+fbspLMvMFmajiISK27axBPtNZsk6HMaRHGbAxVsp2BKVWgSZWSJz7D1wuS20tEpnKyPFaX9cHd7fwRTbRlurHMqhkKl5Us4KzT5SRETkv0hBFBGRXNiJRfjUfQGSs3klOjO7sRyfus9He+s2nGOFvoVzXqtRowa+//77PGvrLhIsiXDjjpTZ+NvejaS0wTy5kwIbd7vnoBaKY3r0BSazJLdYIpbFYlmLKcb8JSIiIsGiIIqI5GusW9LEGoiSqIWl9udIwvGgLLUh+qGi1RwFfa7w+rLhRgoSYSMlCM97aqlcJocFhSPWLLnqqqvMEJq33norLRDSq1cvk13y1VdfYcmSJRm2MGbwxLf1cVJSkhmOs3XrVgwbNgzNmzcPaF2ioqJw2WWXmcyYDz74IG1dWLSWy/j222/NuvhrfSySEwyeBCuA4uBQHC4zfY+fnOH3IEbFYkVEREJCQRQRyddcVhTaWNejrr0Za+xxQQmiMDDTynUt6lt9smhjbP6FUHKeJ5wyNtgq+I477sDixYvRpUsX0/2Gihcvjpo1a+Lll1/GwoULs/UaWdtkzJgxpl3yX3/9hZIlsy7m6wR02P1n9erVZogQh/XQCy+8YArevvHGG5gxY0YOX6mI9+c0WEEOf5zG6IEUPz61/8lcOO03REREIoWCKCISEVgE9kLX20jGSfP3MveXWInvA56/Apqhi3UfLIu9KyxUQstMH8+OQFPsB7DbXmFyUUJhtT0Oh7ENHazbUQ0dEI7Dcj7++GPT9Ybmz59v2hqz0CsDKw899FBAy3n//fcxZcoUXHPNNWaZrJmSXZUqVTLLYTCGGOBh8VtmqVx88cV44IEHsr1MEU8f22tNG+NV9qGQbJg9iMfwlBnobFXAXa6mcGUSAGG213fffZfhdGZ7sVV4oBldIiIi8h8PojhXaHhgzxRx3ysxPLhgCnh0dHTa49mykzc+3nmMuer07xUhU0G/QAEzTVd2RMJPAasIGuCCtL/3W2uxyf7T6zFsg5yAI4hB4XTFaMtY9dDYugguK7DdYjLisdoen2Eb42DYj7XYb69FY1yU2lIjzJQoUQL9+/dP+3vWrFmYOXMm7r33XrOffPzxxzOd/+TJkybzhO2Q//77b9x9991o2TLz4FVGWNy2b9++aX9zmcxoYZtlFpvNal1EsrLY3o/v7U0h21AnkIxx9hbTgviuLB67YsUKM1SN2V++LcHZPYvBxKuvvjpk6yoiIvJfFpFBFAZDOBZ/1apVJqWcBxgMmqSkpJh/88CfVzsbNWqU9niOw+f4/jlz5pix+jww4YEIgyoMnpQtWxY9e/Y08yuIIhL+2ljDTftjTwyq/Gxfj1bWMLS1bvKaVgBFsmxjLJm75557cOONN6JKlSpYs2ZNlptr4sSJJnByww03YNq0aWa+YLn11ltN3RYu0+kkJBJJeFzz0ksvoVOnTl73v/rqq3jzzTdP23qJiIhEuogMojDwsXv3bjM2ninlZcqUQaFChUywhIEUTuNVS14BZcCEQRFeEWXgxRRji4kxjyfet3fvXjMvl1W4cGFzE5HwVtgqY4b4eDqBfahmd0RFNDeZJ5I73IcuW7bM7GPr1q2L8uXLm3/zvnXr1qF169bmfl/Hjx83j9myZQvKlStn2iTXqZN1K2cGtplhwnop9erV8wpos3Asp8XFxaF+/fom8M0MlOXLl2Pjxo0mw4VFbxUEl+ziMQBr7uyovpvj/sJK5cqVzXfBk9p8i4iIhFZEBlEOHjyIyZMnm6E4RYsWRbt27UyxQ2LGyUcffWSmcdw9M1KYdcIDcA7v4RUdHoBUrFjRPJ7380rPkSNHzEEUx907yxKR/KUK2mKIazJckbnry3Pr16/HhRdeiAEDBqR16eE+k5klHE4wYcIEk/nnG7jYtGmTGXpz7rnn4rfffks3HCEj3H/zuXr06IGxY8f6nda9e3d88sknaQF1DufZuXOn+U1gwEYku/744w+T1ZT0v/7ATd21AUVERP7jIvJMgrVQGEhhAIVXLJlt4tQ/4dAc3s+Dax5086CaVy551ZLzcTqDK87wH2ag8H7+mxkoTl0UEcmfnXxcuRyyY9turMY47LKXIBGpXWlCbS0m4KT7EJpYgxCF7BddDRUGo5nFxxbC7KxDDJ5w+Iyz7/XcZ3K/67QcZmB65cqVeOeddzJ9jq5du6YVx+TzMTvQqV3lb11YK8JZF+67GbBxWipr/y05kVKrDE4O6wg0qZQnG3CDfQRj3MvR0aqANq6yfh/Di0M33XQTFi1aZIYu+2LHKmZ4iYiISPBFdBCFQQ8eyPMqp1NslsEU3serpUw3Zxosx8x7jsX3LEzLA3aeFPAgnBkrzjAfEflvYovT+e53TSAlryyyP8YqjENNqxuKI7wy4ZhlwlpSvHny16KY+1K2Hl6wYIH5e968eeaWGQZEAu0wwnVhV57bb7/d6/5AhgqJZKhFNVhNLwlxM/NTluMgRrpn4ylXG7SB/yDKeeedh169euH88883WVaeHnnkEbz44ot5tLYiIiL/PREZROEVx6pVq5p/cyx8rVq1zL+ZVcLgCa+SMrOEgRF/VzR37NiBtWvXYvv27Th8+LAZvsMhPsxWiY2NzfPXIyLhw4ILHV13oa59Lqbaj5g6K6HWzroVNawuKIbUYYbhgle62VbYaXHsiRl+vvWjuG9+8sknTZA7UK1atUr7N4dTMnOlQoX0hSk4BPPtt99Oa3HsidmHrIMlkhPtrXL4LKo7xrrXYqId+iLFrawyGOk6A82t0hk+5ptvvsH3339v6gCVKlXKdJ/if4lDj6+88kqMGjUKzZo1C/n6ioiI/NdEZBCFmScMeDAAcujQIVOMkBklDKI4LTWZbcLHMZjir+ghAygc78/5zzzzTDPsh6ngHOaTFR7E86SC/+VzZoTp7FwPPo4nFVw+M2X4XwZ4QsXJtHFaO0vkcd5XvcehUR2dUQp1MAPPIi9UtdujIVJbCSe6E3P03rqRjCTrOKJQANF2cDLqGCi56KKLMn9ej3Xkfo1Xz7PLWQaDIU5LZb5+Z9/uYD0UB7MGGbTxtxwG0z3n84fP5QwDDQR/W3jLDIeKBlL/Rfvo8FIVRXAJamEO9mAiQh9EqWwXxiWoCZdtwW17f8d54YfHKAyesLuVeXzlyujXr19aLbdnn33W1CMaOHCgCXTysxzKYwrJ+Pvr3PKC53OpgLaISGhZdl7t3fMQDzLYSWfDhg1mzD0PHnhjcILBjX379pmDaB6IsBBh06ZNvebnwTWn8wCdAZeff/7Z/DB17tzZHKRkNs6Yj2OrTo7551UiPldG+DybN282V0i53A4dOqBx48bo3bu36XARKjyR4M3ZLhJ59B6H3nHXbnxT/DwcjQrxSZUN9D72Duom9k3907ZN8JcHyYEEdR37o//B1OK3o2ZCb7Q+PhKRgK1cWWPFH9aLGDRokN9pbP/65ZdfZrhcBk+ef/55tGjRIuB1YUaOb7FbT3yvnnnmGROUz0pO32MJrYcKLcM7sRtCvpnPSayAj46fCRe8CzLTzJkz8cADD5hhPBzSQwzM8bjECdCxm9CePXvw+uuvm//y884LS5I3Ttf3l8/HYzo+J28MJGcnECwiIoGLyL0rfzRYv4SBCAYnGAxhYMXJ8OCQHOdHjj80vtF7pwAhr944VyO5DB6M8EpiIM/P5+A6+Bsu5OAyiQc+fCxT3zkf1ymUVxGcZfO/uloRmfQe5902zgv+vquZfX+PYTcO2Zu87juANdiLlSiMStiOuV7TYqwiKIdGZqhSfsJ29Ry60LBhw3TDdTiN9Vb8TXNa1rLlMfe9nth22Qm0Z+c95jws8MllMkPHE4eQ7tq1ywTus7NM7aPDTB595/k0luUvhJKaKcvPGbtiNWrUyO/8zJzlEOQDBw6Y2m+8eKTf+ryX199fvcciInknIoMoxEBEtWrVvArGOgfPbKnJ6QyIODVOmBXiBFA8l8HptWvXNvP9888/ZvoZZ5yR4fNyGR07dkT79u0xdOjQTNM4ly1bhp49e5rME14pYvDFuYIQyh9DnhxwmBKDNgwSSeRhgI7D2fj++talkOAoaCfBZedB0MGCCQKUsVKz0zj8b//+/Wbf5Huy7tjg/gYT7Du97rPhhhuJ2FhwEjYXnOo1rRJamNbPBazw6fwTCG4DBryZkcJuJZ4efPBBXH755Rg/frzZJ3tyrtCyfT0zDH3ne+2119IC8YHiMrnvHj16tGnB7Il1YHh/oMvk7xFPgPndVS2X8FEoJdZkhoUaP9NlCpX2m4niBP342cjss+R0G+SFI9ZKCWV2q3jjxTPuo3m8yBbveYXvOY/vREQk9KIj9QfMKVzIYAQPOvhj5rQr5hVKHlDUqFHDBFKYkbJmzRrzeBah5YGHE0xhEMQZP88D9kDGszuBkKwe6wRwnLRLHuzkxZUEZSlEPs/Pka5OhUYBFEFzXIld9tJ/O/UE/+yqApqhmtURpa06Xt9b57/Ov5Ptk1hpf494HDJ/b7T+QAr81+ewkWL+5+kItmMB3kWUnbrfq2V1R1mrIcIVC38zGM4g0ogRI8y+3F+wkDVKuA/P6DvA/bzvfM5+O7tXkZ3H8vfDd5lOSn1Orkzr+xtGZq0Hlk0Hzm8GVPQfwMyNYojBRVZNtLXKwUJq1yt2m+LQHeeCED/rN9xwgzmeeeutt9CnTx9zwcgTM7Dmzp1rhiqzMDOD6foc5R1/WYOn67lFRCQ0IjKI4tQacQIU7K7Dg2UGS5gKy449THVlRgmv8jGwwgMOpy0ngy48ECYegDNrg7VRGHhRi2MRoVgrDmdbT2K9PQVr3RNM4dZgq2WdhXNdmbcq5T4qCScwzX4c+7A6R89zGFswwb4j7e/++ABl0CBsD8rZIpk1T15++WU88cQTOVpGKF9XBJYaE/puAfDWl0CjSiEJopRBLP4X1QYVrNQgHOuxPffcc6ZFtxNE4XELM6Ueeugh3HLLLebCj9ON0MHsK2Y/jRs3zmS6ioiISHBFZBDFCZ5wHDqLyzJowiuWHOLAgAlTuzlEhwEUp0MPD1AYLJk6daq5asNgCjNaeGMmCudnQUAGX0REwgFP1ufab2ITpuModgZtufPt97AVs9HNehBx8D5BiwSXXnqpaf3K+iXBwi5FPNllx5TPPvvMaxpPdD/88MNMh4KKZBezURhk8f28sbC9iIiIhE5EBlF4hdEpBstWxTzRYGCE2ST8LzsulC9fPm04DQ9EmGXCAAvTxJmKzXoSTAVngIXDbJidwjRa35aZIvLf5kI0CiIOSTiGZGTeNjdQlmlEXATRSN1HZWYzZmC5/RWCaStmYo+9HG2tm8IyiMLgNwPb3Hcz+E1OnSvux31bH/viEAfePDFgzvn4+8FlZ7erBQMyzAhghx52aPNsKzty5EhTCFT1ifI3ZqLGFY8DomORghgcR1LQBvHx287hPJ51UJy6R/4+i07x+vnz5/tdHqepM4uIiEhoREfqgU69evXMOOGuXbuaA24ezDptfX3bvvHfbC3Medq0aZPWIs7p2uO0qeN84ZjaLiKnTyW0xrWuPzDffhez7TFBq4XSz/UuiqFiUJYXaVi4dcaMGSZg4RSGZZD7k08+wezZszFq1Cjs3Jm9zJzp06ebYAezVBgE4fKy47333jM1KjiUlN1RmB3A/xLbMPO3iMMwOnXqlK3lSvi49dZbcfngK4AaZbA5KhGDU6bhMBJzvdxoWHglqj06WRVQEqcu1AwfPhwDBgzw+1kcNmyYCcxlhMcqbHssIiIiwReRQRQn4MEbh+VkhQcbzhXCjLpdiIj4U9AqivJogop2c1RCanaDG0nYi1VIycYJVknUQiGk7q8qWs3NMqOs1NpM/hyzd+MY1iLeTi2iHWxupGCPvdJk2pRBfbisKIQLdrzgjRmFTnYgg+QcxsAghtMqPhDMWGHnNQ775LIqV66MJk2aBLwuzIRhG9k9e/aY561fv75ZLw7dcYIoM2fONHW21q9fbzIEmLXi1N2S0NhsH8V+JKA+4lDEyrogfCAqVqxobhRnH0Mrq0xaEGWrfRx7EHhnlOLuaFRPKYLoKBcKRMWgKUqjvuXdyaVChQrm5g8/Y7yJiIhI3ovIIIqISF5rZl2BJtYg8+9j2I0P3WfhEFILXGfNQg/rcTS0+v37lwsuZH7itwLfYbb7yaANIfKVhOP4wb4alexWGOKaiAIIv3boLKzJTiXEQAa7mDAzhZkk9913H955550sl7Fjxw70798frVu3NjWxsjtkc9asWbjkkktM9suff/6ZFph3hovS1VdfbTJcBg8ejKeeesqsH4M1Ejovupfhc/d6TIzujVYoG/TlV0ER/BzVK+3ve93z8Jp7RcDzn5lUCq8fbYG4YsVQtEBRxCJ8gpQiIiKSOQVRRESCgFkjrGRChe3SaGpdjuPY5/EI23TyOYZdaGD1RUEUT5vCQYJlrQYoYBUJ+PncdpLpyhNKyTiJpGxcXc9rDHg4QQ9elR84cCAaNmxoaqNk1WKe9a4mTJhgMlDOPfdck32Sk1awTtc34vP6w6wTDhN16q6oe0/wJNlu/GJvxj6flt6L7f04gkR8796EBZbn9xBm2EwjK+ss1cy4LAtFPAKdna0KSLC8W4dvxBFMsXfgTKssmsG7KH0DqwiK2FEobEcHLVNGRERE8oaCKCIiIWh/3NN62us+23bjC3sgtuAv0xq5tFVH2z2XnGAEAx8c9vDSSy953Z/ZfAx+PP/889i6dasZbhPI0AjP58tour9pCpoEn7NNE5CCp1IWYSH2+33c0+7F6e573dURDV2nhs4Eo9bZIFctc/P0rXsjfk/ZgYFWTYyKauY1LT4pHgcRmqF4IiIiEloKooiI5AkLbV03obE9EEWRWitDcueLL74wQ2g4lIbthWnevHmmwCuLcb799tuoW7duuvm++eYbTJ48GX379jXt7VmnJBDff/+9aWHMArSNGjUy9zVt2hTvvvuuqcXCQqC33XZbupoqP/30E3755Rf07NkTQ4cODahWl2RshnsXPnKvNv9mf5zNOJatzfWpvRYLUvaaf1e0iuA+V7OQZIO0tsrgvaguaGMFfziRiIiInD6p/RdFRCSkeLW7ttUDzVyXo6AV2El7RgVfk6zjSLFy3xUkEDZSkIBjSLK9h0uEgzlz5uDjjz/Gpk2bcPToUXNbuXIlPvjgAzO0hgELz8KcHE7Dx/z999+msw+LwPbu3du0RXbm97wdO3bMFKx1LFiwAB999JGpo+JgF7hrrrnGPO7DDz80tVl8l8OOQVxPdoFjbZSMhv1I5lJsG0ftJCyzD+ADe425fWKvNQVks2OWvSdt/m/dG3AACYi3k4OeMVTDKoZrXPVxhlUqqMsVERGR00uZKCIi+ciB6FX4peS1OObKXgvfnNqHNfjY3QuNrYHobj2McJOYmGiKyzqBCXbLyYiTtbJ9+3YTOGHLWtZByQiLvzLYUrq0dz2LjHCI0J133olixYp53b9r166AX49kbB0O45qU6dhqZy/zJDObcAznJU/EBa7qeMrVWptfREREsqQgioiI5EsMcnA4jb/2x2XLZjyEolKlSuaWXWxv26xZs3RBEmLGC6f5w2lcV3/zSeDikYKl9gHmRQVts7GmynIcRFNb2SIiIiISGAVRRETykVLJDXDBwa+wvNDHmF3sqZA/XxnUw1WuiYjFqUKc4YKZJE6LY1/+WhV37doV06dPz9YQrMKFC6f9zZonHCJUqFChdI8dNmwYrrrqqkyX528+EREREclfFEQREclHXIhCjF0EUXZqO+VQsxCFgiiKGCs2V8vZbP+NA/Z61LPOQxGrTFDWLTY21twCxbbHWbU+DrSlMuulsFgsWxb74hCh888/32/tE7ZD5nxOW2R/ypQpg1atWmV7/Xbu3IlJkyaZYUX+smFY/yUqKgr5sY3xeHuLaVucBDewdjfw11r/D65TDuhUlxGw9NPW7QFmrPE723prDT5wbUT79u3TigZntz7P8uXL/U4788wzccYZZ2R7mSIiIhKeFEQREZGQW2yPxRL7U1xr/YkiCE4Q5XTav3+/qX/CwIUvdvzp1KmT3yDKwYMHcdddd5m6LBnp3LkzPv3002yv06pVq0y2DAvo+lvm2WefnS+DKCeRjEdTFmAJDqTewQDKiLH+H3xl+9Qgij+z12c435x/b2PGjMlREOWrr75Ka7Hta/To0QqiiIiIRBAFUUREJGiS7QT8bT+PQ9jidf9mewZSkIjp7qdR2Kfla1PrMtS0uuXLd4EZBhxS5HK5vIrd/u9//0ODBg1w4403ek1z8ET95ptv9prGorjPPvtsttfhyJEjZr6EhAQTBOAwJAe7A/EkPiJd3hbo6BMwOXAMuOlT4NK2QJd6/ue7pA3Qpb73ffM2Ah/9ne1VmD9/Pt577z1T84attT0tXLgQ77zzTraXKSIiIuFNQRQRkXzIZcUgBoWRjATThjgUohGLGGRdxyPFTjIBEkrEMSy3v8UuLPb72JX4gX2TvZRFA1RGG/NvCxaiUcgrEBBO2Ab35MmTiI+PN0OJ6tWrZ7I/PDM8tm7dinbt2qF58+YZ1mypWrUqrrvuOkRHn/oZZnbK66+/nu114pCiL774AtWrV8fTTz+NAgVODfXau3evaa8cEfVYUtzAySTAbQOFCwDdGwBDOno/ZuxM4KEfgWbVMg6iMPByXRfv+4oWzFEQZf369Xj77bfxwgsvYMSIEV7TfvzxR3z++ee5GkImIiIi4UdBFBGRfKgxLkJjV09McT+IdZgU9OXHoAj6We+hgtXUBDUyswa/4g/3E+bfNtzYD/91JzIy034ZS+zPzL9Loib6u95HQRRHOHLaGK9btw7vvvsuqlWr5jfTJFywU5FzIp/vT+bX7wGu/wRoVhX4/S6gWmCtp08XFjKeNm2aGd4lIiIikUNBFBGRfKioVR7FUReFrJLpMjuCVcC2nNXI3DKSZMfjIDZil70EO7Agx891GFvMjbjE3ViOOLsqiqNK2GWkMBNlzZo1WLt2LRo2bJjtVsnMPOEwnxo1agT9tbFY7YoVK7yyWxye2Sn5yTb7OLbbx3GS2VbxScDiLanFY1tW9188NjMlCgONKwGl0teqceywT2CFfRA1UQyFrcAPkXbt2oVly5alu5+FiPNjHRoRERHJmIIoIiKSI/uxFmPd5yHeKfgZBIewCWPd56KJNQh9rcirJ1GuXDl8//335sQ62BksrMHRrVs3v8GZDh064IcffvDb+jlcMWD1jHsxPnGvxTEk536BvRoDnesCsRkHlF52L8OHyePxc1QvnGmVC3jRr776aob1Tx5//HHTjltEREQig4IoIiL5WHV0hm3ZWGtPQAKOBGWZVdEB5a0mKISSmT6OQ3cScBjJiA/K855a5hEkIX3r4HDAwEfPnj1Rq1YtjB8/Pi0owfonTZo0wdSpU02rW9ZMyWj+4sW9hyq53W4z7GPDhg2mDTHrpeQkS4WtkdmBxzM4w/otEyZMMC2Z86PmVmnstxIwyd6KgyULA5ecmZpJ8tns1AdERwE9G7FIEDB5BTBrfcYLKxCdevN06ETqfNsPAle0wxkNGuEMqxpKWdkLNjVu3DhdV58tW7bgzz//NAV/RUREJHIoiCIikk/xRPtM3ICmuBTv2B2CFkRpbQ1DC2toUJYVaZhBcvfdd2Pz5s0mu8NpccxsA55EP/fcc5g8eXK2My5efPFFLF68GDNnzkT58uVx4ED2s3s4vOiDDz7wqn3CwrJcz/z6+b4W9TEoqha6JP+Cg1VLAW8MTi0Ae82HqQ8qUjC1PkpMVGpXniMns/ckOw4BN38G9G4CfHwtrozqgJtdjbO9rpdffjlGjhzpdd93332H6dOnZ3tZIiIiEt4URAkxtp6cPXs2Nm7cmG689L59+8xVQhGR3JxoxtiF0c16yNQToU32n1iBbwNeRhyqor11O6KQOsyhqtUu00yIZPskZtovYSeWmO5AobDdno/xuAWNMTDs2h9z25QqVQpPPfWUqUPi7M9vv/12nHXWWejUqZPp1hIIZokwo6Vz584YOHCgWW4w1s9RtGhRPPLIIybYc9ddd6F79+4YMGAA8gu+Fsup+eO8rna1gZcvS/23bQNfzk3996N9gfmbgM/nZL3gxGTg1d+BXYeBhy8AGlT0es6crqunFi1amGE+u3fvxm233WZaWtet69OSWURERPIdBVFCjCndS5Yswdy5c82Bsm8Kd1JSUqhXQUQiXLQVi2bWFWl/u9xRWG2PTzdMJgUJsBCVFizxDKK0sUaggJVxwU1PKUjCMvsr7MIShAo7/Oy316AM6oddEIU4JOfqq69O+5uZKGwlzLoj9evXx1tvvZVll5/ExETz2/DRRx/h22+/NUN5KJjB9cKFC+PKK680GREPPfSQGX6Un4IofjWsmHqj4wnAuS8BSSnApDuA4oWyDqIwgHIsAfhlMXAiEZh8Z2rR2SCrXbs2brrpJowaNQpvvvkm+vfvryCKiIhIBFAQJcRKlixp0nwvvPBC0xbTE1tkjhgxItSrICL/MQ2t/qhotfC6b4+9Er/YN6I++qCTa5TXtAIogmjE5vFaRhYGVM455xwTQDl69GiWj2fwhJkhrGHy+++/o169enmynhEnNgZ448rUjJTCAdYxYQbKuCXATT2A+hWAovmn2K6IiIicfgqihBjbSlauXNnvtEKFCqn1oYgEXTGrAoqhgtd9MSiMcnZDVLCameE6kjvMIty0aRNiY2NRpUoVUwyW/926daupl1KzZk1zX0bzcYjn4cOHTTHYtm3bZvl8ycnJZj7+pmSn8KwzH2ujMMDD7kD5jQsWalrFccROwmYchZvFYDkMp0JcagZJk8rAySRgw57UzBIGRliE1tfhE8DOw6k3ZqI0qACcUcVMKo4YVEIRlPRTUJbDcrdv325q1WRnuJUzn9PWmllBIiIikv8piCIi8h9QDo1wtWtquqE8kjO7du0yGYbsyvPpp5+agDiH6LC46KpVq8zwHAZVfNsY79mzxwzrqFOnjunIw5olgdi/fz8uuugi0xXo66+/9ioem5mDBw/ikksuMcGa3377DcWKFUN+UxjR+CiqK5bY+9EnZSKO/boUGPkl8PwlwJXtUx+0YS9w4RigRyPgz3uAIn4+55NWALd8Bjx8IfBAH6DYqeyrXlYVvB3V2TyXrylTpmDYsGGmBs4NN9wQ8Hr/8ccfJkOJhYjZpSfQ91pERETCm4IoIiL/AS4rOsuWxYHYas/BHnsF4nEIeWE7FmCZ+yvUsnqgiFUG4YI1rZhJsnr1anz55ZcmWMIgytq1a00GAmumeAYs+HieSK9YscIUeWXQZdKkSX6zEZmtwpbErVq1SstS4fyHDh3yO1SI2TAXXHCBecw333zjFbjhumzbtg1FihRBiRIl0loy5yfMuolDARQ3AUALSEgGDp4A/l6b2pWHth4A9h4FklNSs1A8M3WYgfL7P8CMNanzLd4ClPYOaOywNmNi1B5YsMz269Gjhwk8EWvXMBjlr1Vx9erVcdlll+HEiRP44osvvKbNmTPHdFni8ji0V0RERCKDgigiIhJwK9759jtYaH+QZ1tssf0xluMrXG1NRRGETxDFsWjRIgwePNjrPmag+GKA49lnnzWBE+LJNQu+ZuaBBx4IaKhPXFwcXn75ZZP5wLos/gqWcyhPxPngr9RbVrYdAkaMBQ7Hp/798czUmwf+NdMjKDV16tS0IEpm+P589tlnpuYZC/eKiIhI5FMQRUREAs4IOAOXojTqYrb9Ko5iR8i3XCMMMN15SqIGwgkzCx577LG0FseeOGyDgQ1PzEZgIXGnA09WdUy4XLY9djCz5eGHHzbZJL5DhJz6KBwi9Pzzz5uAjS/W5mJtjvysMgrjGVcb/NUuCl8+n0EHI6drj6cKxYEn+6dmsPgoj0K41dUEha1T24bZQTVq1PBqVfzSSy+hS5cu6eZ3tn3fvn1RrVo1v6vEltciIiISOSyblxbltGDrYx4ks93k+++/bw6MAy0WmNu2y0xN5kG5xmhHJqaWM/WfJ3JM45fIwaEF+/btM++r74l6Xkmwj+I9d+eQtjh29LHGoJ3rllwtw7bZ3jkpdagGYvJkP5sbbHHMTBXun7mfzs+SbTeSYXOrI8ryDv7k1EfuNbg+ZUba34lwIzsHMtGm0XfqZ6AhSmJqdB+/BWXz4neYQ77yY50ayRgzwbiPZkYTg555tb/h83q2R2fzgvweOBURCVfau4qISEQ7gh342X09KlrN0cN64nSvzn/Kz/ZmvOhehgddLdDbSt+tKCfOtapgSlQf8+94JOPmlJlYg8MBz8/Mk/5WaqYJM1CKIbAivSIiIiKkIIqIiEQMZskcxU6v+w5hM7ZiJtx2EvZbawD71JXhKMQgDlVN4d38hJkqvNqd0VCjsmXL+p3G7Ae2O85MxYoVs5Udwaw3dh0yLYc9Ot7QUvsA/rZ3m//Wsr2zalgstrxVCNlV3ipsbnTCTkYjq4Sp1+NpD07iCBJRBUUQC+/ivS2tMujk8m4BLiIiIhKo/HXUKCIikokN+B0/uq/jIJ60+ziY5yQOYyP+wLvujl6PL4EauMo1AUXgP+gQrsaOHYsnn3zS77RbbrkFjzzyiN9pn3/+eYbTiEMP3n33XfTr1y/gdfnuu+9wzz33AK8PBga09Jp2Einmv0+4F2K023v41xBXPbwQ1Q65UQhR+DCqqxky5GlUyhx8Za/H+1Fd0MKnq1MRHfqIiIhILiiIIiIi2eJCNGpbPVHELmsCE6x6EWxxqIYqOBOlrDqZPs5tp2AT/sQJ7Dd/b7Vn4gT8Z2ikIDHtcQ5Wx/jH/gmxSK0vUx5noKzVAPmh7tH+/fvRoUMHVKpUKV1hWrY6bt++fbpOQazFwfnatWuXbtqaNWuwdOlSv618/dlvn8Sf9k7MrJiA/d1qAOXYgtj/vMeQbG6emJ3yjXuD+Xc0XOhuVUSJbNYmYdCnBNLP08FVHkluN2paxVHG8s6OEREREckNBVFERCSbPxyxOMcajV3WYrzn7oJEHAv6FqxudcJA6xMT5sgMC8b+7n4IW9Ia1GbPcezBT/Z1aYkrvaxn80UQxQkgjBo1ynSG8TR69GhceumlJpDir90yjRw5EhdffLHXfexAw1a9gVprH8GVKdNw4uxo4Ozh2V7/KfZ2TEnZbv5dHDGYHn2B34BITgyz6mNYVAS2dRYREZHTTkEUERHJlrRuEx61RULDyrSzxT/2j9ho/4GD2BS0Z1xtj8MJ9360tq5D6SyyYE6HtWvXmuE27Lzx3HPPoUmTJn63UVaN9zhPTruGsA7Ja+4VWGLvN51xEITuIxz280LKMjS3SuMmVyMUtLzrmGRXuHdgEhERkfwrOP0GRUTkP4ctg6NQwPx/MLENMYcMZWWDPQ2z7FdwFDuC9tybMQMz7ZdwGFsRjjZv3mwyRtjOlFkjdepkL9ATFRWFAgUKwOXK+c//SSTjw4R/8HnCaiQnJgGJyd63jAI4vD8pJf3jE5NN6+5PEv7Bp4mrkPhvHZXc4JAmLtPtdud6WSIiIiKelIkiIiI5UhK1cYXrR6yyx+Eve3RQtmIJVMf5rtdQCrX1roTAwIED0aJFCzRu3DjnCzmaANz0MbAltZ6Jl6IFgVcuA6p7F3M1jicCt38BbPJfs8ao2xAYcx5QmPVVcm7MmDGYPHkyXn75ZTRokD+GZ4mIiEj+oCCKiIjkSEGrKKqjM45iF0ratcx9NtwmM4RFXANVGKVR8N/CrqVRxywz1kr9258E+xiOYzcS8H/2zgO+qep9489NOqFQSsseZe89BBRBhiCgoojgHjgR99afC/279x6IW3EAKsoSEWRv2XsUyi4ttNDd5P4/zwmnJGnaJm3Sxfvlc2ly57kj95zznHckB+jOmThpHsQJ7ENV1C1T6Y/pxtOkSRPlrrJr1y41LygoSAWXpfXFoUOHVPrj/GjQoIGa3IPNcjtuz31HRER43JYuQkwdfCAnGdmrdgN7dgN1Il3deSii7DkGBFmBOtUAi9Mymw1YHQfsOOrYznmZ3QQOnUBmShjibMmobVpQowjpj0+ePKnSLa9evRoLFy5U3wVBEARBEPxJ2WkZCoIgCOWSlrgYjSx91OdspOF7+3AcwQavtz/PeARdjJvUZ7rxhKJKgevvwt+YZr8DmQhMB5nZhv4070Z1sxlusExHZdREWaF79+5KHGBcFGbmITVq1MD06dOxf/9+jB49GidOnPBpn+vWrVNBZrntkiVLEBmZv4D1rH01puRsxHEGE25TF/h5LBAefGaFlAzg5i+AyHDgFy7zYFHSqjYw+S5Xa5OTGcCID7EdyRiQMwPX2dviLWsv+MqMGTNw7733KvFE4qIIgiAIghAIREQRBEEQikWwEY5gOKwGss0Mlf64uunqjnMIa1WckVj0RjiiXJbVNjogwqjl9fFsZobKqhNIMnBCpUOmZU1ZgvFMatasiZYtW+aKKGFhYViwYAFOnTqFHj16YNu2bdi8eXOh+2IqY263e/dunHPOOWjTpg1q1Sr4PiSv2o5ju9YA3WOBmlWB2pFAqFNTItgKpKQDjEWSX2xbWqnUqAJUdsrEExas5ufAjgQzHSlmtpdX5HS5kpOVuBQfH6+uy9q1a5VFiiAIgiAIgr8REUUQBEHwY6USiouM1/NkJp5m3ol15vcYbHkd9dDVbSvJpOIrV1xxBUaMGKE+HzlyBL1790ZsbKyyxHj33XfxxBNPFLqPlJQUjBs3DrVr18bs2bOVGFMo7/0NzJoG/PMI0KpOmbl1DLh73XXX4bLLLsOUKVNw11134dtvmSJbEARBEATBv4iIIgiCIPgNhwtF3p51G4xADFoiEvVhGJIYzh/XWburVK1aFQ8//LBywwkOdnKtyQfGNvnhhx+wceNG3HTTTWjYsKHaziv3F8Yu4cR4Js4xTbyB1ib3DASCLA6LFT+j0zoXJ32zIAiCIAhCYYiIIgiCIASc5sZFaipuJ5nxSux+SIHr5RFh4/HMHJXGuSx1zG02m5oYVLZy5coYO3asSufLeYSiiKc0xnq7adOmKfcXuvN4kybZZvJa2GFqASTHDmTnOBbyOFaLYx6n/FIchwYDY3rnna+34z64f4NxaUxkmXYEwYClgOvOZ4IBcfW1YApnQRAEQRCEQCIiiiAIglAuSEE8ptvvQyJ2lsjxTuEwfrFfg8bGBehvPFem3I5++uknfPnllxg/fnxubJT169fj8ccfR7du3VSg2Q4dOuTZburUqfj000+V2wtdeZjVxxt+N+PwkX0zNj7UAbiiOvDSdCDplGPhJZ2Au/oBb84C/toM7EsC2nq3XyW4vDsH+Hcb8OAgoEkNICwEs839GGqbiYcsHTDEcM0m5ExGRgYefPBBFUz3m2++QaNGjbw7riAIgiAIQhERESXAcHSMwf4YwI9pJJ1hSkmOHAqCIAhevE+RjePYrcSNkoBWL8exR7khlTXi4uIwd+5cjBo1CvXq1VPztm7dquZ17NgRAwcOzCM2MHYKM/FwHcZTYQyVhIQEj/unFQtjpWj3oPiURMw9tgFoFAHUb+aIjbLrdODW3QkO4WT3MWBPApDlpaUQM/IkpTq22ZcIdGwAtK6jFqUgCzvMFPU3PxITE9U5LVq0CNnZ2fjf//6n0jPv27dPZeehlQrrWcZLIbTYiY6OLlMWRYIgCIIglD9ERAkwbORxxHD16tX466+/XJax0ZeWlhboIgiCIFQIqiEWN1pmY7P5G/4wxwb8eFVQB9dZ/kAkaAlR9jreFAkee+wxPPvss+o7xXq6tniC2WqYwvj48ePqOwWH//u//8t331FRUcrlp2nT01mWJq8CnnkFeO8a4JKOwHe3ATmnxZJfVgHnvwI8Pxx44ELgig+9O4Fpa4EnpgBPXwI8dQkQHZG76BIjFm9Ye6IaPKRIPs0rr7yigseyniUUjrQLE7P1UDgaM2aMymhERo4cqYLuCoIgCIIgFAcRUQIMR/E4mseGaJcuXfJkRli6dGmgiyAIglAhsBhBiEBthJvVSuR4Bni8Wgg3qqOswTgmw4YN87isVatWeebRQoN1EMV7b2Cw2tDQMymIG9esi2Fde+O/6jVwkEIFUxTnFqYm0KUh0LgGUKuqI4VxQZxIA5btBg4lO7ajCw9TJTtRCUGoa1QqcDcMiEvXJU9s2LABBw4cQOvWrVXAXSKuPoIgCIIg+AMRUQJMtWrVVCpK58wBGvqv9+3bN9BFEARBECoYtKrQdYs7ntxV2rZti8mTJ/t0DOfAtBdffLESba6zz8eP2O264kXtgcHtHNl6KJAUxq4E4NrPgKvOAaaM8z3Lz2kY04WpjPNbRiuVN954I1dokaw9giAIgiD4AxFRAkxBjTZPmRMEQRCEisVucy72mAvQybgO0UZzv+zT1/qD9VBxMtfweGogwDSAtCxg4kIg4ZSHAwEY1R2oWy1vGuOMbOCLhcC6eMfnVXHA83+4rlMnEri5NxB2ZhbdlD7//HP1+dZbb821kGGZsrKyMHHiRBw8eNBlNytXrlRWN5999hlWrFihtgsPDy/y+QuCIAiCIGhERBEEQRDKGQYsCDqd6tgM2BEsoAjgvZUERQYmYXYv025zPhaYL6O+cQ6izMZ5jmMY5UdQtzLZc0YObJ/+C2zzEOA3Mhz45xGgTV1XCxObHUjNBD5bAGw+LXj8t88xOcPgsrRQCTlzDSmUTJgwQX2+4YYbXNyMuIxZitasWeOyGwZt5/34+uuvsWrVKlx//fUiogiCIAiC4BdERBEEQRDKFY2MPrjO+AMr7J9gK373+/4pngw0XkR9oyfC4H38FQooc81ncNBc7TI/CTthwoZ/7M9iGd53WdbRuBadjOtRXnjE2gHDrTXwkPEB4j2tQKHknh8csU5evgIIDT6TxvivTY4sPAXBTD9XfQpcPBJ4oHB317CwMLzzzjsqxpgz77//vspC9Nprr6lYMMzMIwiCIAiC4A9ERBEEQRDKFVWMOipzznZjZoAMUSyoZ5yDxkbhnfhsMx1pSMxNibzPXIQ4LPC47kG4iiukBlqjsdnv9FEtqIyaKMvUTwKsRwyERlcF6nkQmOwmsGI3kJ0D2JxuzoETwJZDDjceuvkwMK3htt2xUwjOsKHG1mREdUl3cUWqVatW7mdngoKCcO655+Ypxu+//67cl3r16oXu3bv75dwFQRAEQRBU+0MugyAIgiAUjX1YjF/ttyhLE5KKYz5tv8aciE3mL+ozMw9da/kdIYgus7eD6ZR//WcWjn40Eoj1kLUoJR0Y+VHe+f+7GLi1D3DlR0BIEPDTnUC4U/riUxnAqE/QwlodU6ZMQY0aNXIXVapUCd98803uZ0EQBEEQhNJERBRBEAShXFIDrdAUF+IAViIDJ/yyz2i0QDSaoxKqF2qBEo9l2GcuRrJybCmaSUwmTqpJ7RPpKghtVTRBKFxjpxSVTNOG5eZRhMKK7kYNWPIJdO4tiYmJOHr4CHrGNEFOg1pYYSbA7nzux0PyBpTlMatXBkKDgL4tHcsbVAfCgl3Fl2ArQoJCULduXVSpciaFMgPIakuUwmBaY6Y33rdvH2w2G5YuXaoC0/bo0QPBwU7HEwRBEARBKCIiogiCIAjlkm7GHSqeyFf2QYjHUr/ss4txM3obDzN8aoHrpeIopthvwEkwSKp/fIrSkYSp5hjUt5+PofjaL/tMRhZusy1EXaMSZlmHKDGluFRBMD629kaypToG2mYg47QVTqFUCgHeu8bxuYhpjQuDcVDGjBmTG1j2gQceUOmdFyxYgGrVvI9vIwiCIAiCkB8iogiCIAjlEothgdUMRRdjDJpioJp31NyMzZji9T4YOLarMQbBcAQejTV6w2J4VzUyO5AjG4//oFuQdg3ylTjzJL6z73SxDElFNhKQoSxSXrT/hyCcyQRUCUEYY2mB6oZTPuFCGDFiBFq0aIEpP/+CA0hFjn07unXviiFDhuDXX3/FxpVrgISTQMSZDDouFinWM+JJF8RgmKUBpk2bhi1rN+Cmy69Gp9qNERLi5ObjI+3bt8eTTz6pPjPFMd2AKKgIgiAIgiD4CxFRBEEQhHKL1QhGN+PW3O8b7T9ji/lbHusQLXYwpbAzlRCD3sajiDBq+ZTGOJDplc+IKaYXZUHuervMFDxvX4NsD8LOcWTiBft/LvNiEIZLLA0RaTpEC4NXpwB3HwZ1vfLKKzFgwAD06dMHW7ZsUfN7jK2PZy7qhN2/vYPNk/5yiBaNY5i8+XT5HDFkuX9nuiMGz6Iz9v/xEfb+Oh93zX8OHTt2RHHo3LmzmkhqairmzZun/tK1h+Wia5AgCIIgCEJxEBFFEARBqDDQkuRawzXt8UnzIGaZD6MW2qGP5YnTXXoHwajkYxpjG+aazyLeXIp0HEcgOBa8CbOq3YJOQdehO8YUUBYo65Jl5lH1PRGZyPHBMiYFWbjDtgiVTzcFLrM0wm1Gq0K3i4iIwIcffohTp06p74xBMnz4cAwcOBCXXHIJHnnkEYQjEi9bB+BvSwI+tm/BA5b26G/UddnPplkLcemHr6B///4YPXo0Gjf2TxwYTWhoKN544w3s2bMHt956K3r37o0HH3wwT4YfQRAEQRCECiei0CSXE018mc5QEARBEDxRxaiLlnDtrB/HHkSaDVDDaI0WGArDKLo1Aq0+9pvLsQfzAnYDMixJ2Bc6D42NXvmuc8rMVvFOFplH8Je5v0jHyYId/5qHcr/XNytjmNkQUQhBeAEuTayL+/Y9k/756NGj+O+//3DLLbegX79+GD9+PKoYobjI0gAphoHfEIeeRk0MszR0HDcrSwWo3bP7uNru+uuvx+DBg30u/4kTJ5CRkYHo6GiPQWPZXqBwwlgo99xzj0uwWkEQBEEQhKJSLuxad+/ejRkzZuDw4cOlXRRBEAShnFEV9XGDZSYuNF52sUIpz3xt345zc6ZhoZMIUlwm2Xfh3JzfMddksFzvueKKK1QWHE9CyBVGIywNGo4hRoPceVu3blXWJ9u2bVPbXXzxxUUq7yuvOKxYuD9BEARBEISSIqBmHfQ/Tk9PV+kFk5OTlf+2r3CbQ4cOISUlBTk5OQEppyAIglCx46ZE4kwnviJAK5R9cLjT+IuTyFYTg9EWBC1DV61apSw9unTpgqpVqyorj02bNiEuLg4dOnRATEyMij9SyQhBFThirrAO53Y7d+5Eo0aN0KRJE8TGxhZaLm63evVq9blr1665Fqk1a9ZU269bt07FPenWrZuLtSrjoHA7DsScd955KkuPIAiCIAhCmRZR2ICJj4/HwYMH1WiTryIK16cQU7lyZdVIkwj7giAIglC6nDx5ErfffjsiIyMxZ84chIeHq/mvvfYaZs6ciX/++QetW7eG1eqaTplCx9ixY5U70OzZs712r+FgzLhx49RnBorV2913330qnfGgQYOU0MJlLJOGrj5cJy0tTaU+joqKkngogiAIgiCUfRGFViRJSUmoVKmSmudLZHyOdtEChcHh6PNcnLSHgiAIglAc9pjzsddchBOIK5ELuc9cggX2l9HWGIloo/npMpzET/ZdLrFM/M1v9r04aKbhBktzROeT/piixb59+5RwouORrF+/XgWbnThxorIScYeiBtsEtBZ59913PcYx0XTq1AlDhw51OZ47FGm4L7Y1OFjz1ltvqfaCcxuCAzmMicL13EUdQRAEQRCEMimisGHD0SeOHLEB40sjhqNPFFE4ylWjRg2XxpEgCIIglCQ7zTlYYL4c0NTGzuyBQ7SpabRDNJrnpjF+2r4KOQEsw4/mLhWsdqilAaLhWUThgMj+/ftVEFltOaqz3rz33nsu6zov0+jt8oNBap1FlIIGYLhvBrd94YUXPC6nBYogCIIgCEK5EFHY6KFpLa1IWrVq5ZMVijYZ3r59uxrRqlevXq41iyAIgiCUNB2Na1HX6Ip59vE4gvUBP15bjERHy3Woh+4oSzDFMYUSneKYgd8/++wz3H///S5Zewjdez799FPce++9KnOPtzjHSuFACq1M9GdnwsLCVBpjxl3LDw7i0C1YEARBEAShXIgobLxQ/GjYsKHXIoqOnUIRhVYsNMWlGFOQ6a8gCIIgBJKaRhtEm82xAh+VyIWOMVqgtTEcZQ261g4YMCD3O11mdNDX4cNdy3vgwAH1lwFo3Zd5C11xLrjgAhcrVWfRhIM0GoosjKHmbvniaTtPcFtfBmzoosRUywUhIo4gCIIgVCwCKqJQ9OjevbsSTzw1aAqDI0eM8s/t6QbkqyWLIAiCIAgViz///BOPP/64x2UjRoxQcVo8MWvWLDz88MMF7vuZZ57BjTfe6HVZGLCWVjYFwbLedtttXu9TEARBEISz3BKlsBEdBovjSA4tTmganJWVpebXr19fCS+0RuEoFAUZiipijSIIgiCcbWSaNvxnHsN6M7FEIrLkwI4VZgLSkIOOiIalgIEQutvSjcdTMNlAwFhpTFvcokUL1KlTx2UZg8n++++/alndunVdlrE9we2aN2+eZ9mRI0ewdetWtW9fYLuF+2zatKlqtziTkJCAzZs3F2qpIgiCIAhC+SKgIoo3UEDZs2cPNm3ahHXr1qnI/eTBBx9UIsrKlSuVOw8bZzTZjYmJKe0iC4IgCEKJchyZuN42H3E4CVsJyCgpyMYttgXoZdTEbOsQhBXQXLj00ksxbNiwEs9+wxgsDEDrzPfff4/Bgwfj/fffV2mYPXH33XfjzjvvdJk3adIk3HTTTUUuyx133KHSKTszdepUXHPNNUXepyAIgiAIZZNSE1GYuYejNJz+++8/pKWlqQw8HCmy2+3K6oTZeBo3bqxSJFNkqV27toqyX1T3IEEQBEEoDgYsaGeMQnU0xTrze2Qj1e8XNMJWH00zhqJ2SA/o5DiVEISbLS2w1kzEFHMP7AgsYbDiGqMZuhjRsKJgV1pPmfc4IPLjjz+qOp0uNG3bti12mZiBh2IHrUW4T8ZZYXwWZ9g2oEUr2xj5QetW9+04rzjw/P29T0EQBEEQyialFmSEDRwGnGP2neXLlytz1wYNGihLEwaR5UTrkzZt2qj116xZo8SUghpGZREGydUTxSHnSQfQFQRBEMoHFsOK7pbb0dd4EqGoGpBjVMtpjJ6n/oeGWWeCqVY1QvCktTNut7SGBYEfRKBo86i1A8ZZ2yLY8L6poOu7ffv24amnnlJuMq+//roKOltcDh48qPYZFxen4p706NHD5334ewCG+9OTIAiCIAhnB6U2TMJYKPQ/JgzixpSJjGDPESZap9DahKM4FFNogdKkSRM1ysMRJs4vLw0WikPz5s1TYtGqVavyLGO2AEEQBEGoCDC+GYUOWpd+8cUXKjZJWYFxW37++Wd07tzZb/vs1asXfvnlFxUEXxAEQRCEs4MSF1H0KBVFFFqWUCTp2LFjbuYdphdkoDY9skOXHrr2cD7Fk/JmvcEgd0z/SHckBrtzhtegvFnWCIIgCA63nkqortx5MuFbMNKC9hmGaghDZLm7xKyb6brDQZBly5apup2xUphy2F+wDUBrVf49duyYmsd2Ao/FvxyYYPshP2JjY9XkXg9zOw7QcN++lpcWtJycYb3OfWZmZhZpn4IgCIIglG1KxRKF1ibJycmq4cOgsWwQcfSK88PCwlSjw9m/msFnuT7nMdtPebFCIdWrV8f111+PK6+8Ek8//bTLMlriSNA5QRCE8kcEauNayzTsMufgD/MumH6IUlIJMRht+RmVLfWRg5IN0uoPxo8frywv6b7DDDgcBPEnzZo1w5w5czB79mycd955ah7bBAwmy3bE1VdfrVx+fIGuQVdddZWKr7J48WK/ZBjav38/Ro0apdyRFy5cqOK9CYIgCIJQcSgVEYXxQDhSQ3NfpizW6Y2dhRJacHBUi6M5XM6RHDaSSjr6f3FhmSmkeIKuPNoCRxAEQSg/WI1gVEcTnEI7NDTPUyKKCRMJ2IwMeJ/SNhINEImGuSJKDbRCECKRhCSP64chDfWxC8cRiWREw/+YiMYR1IUdQcjOnUtxgql8W7ZsmUcUYBDZXbt2KcsLihB0v23Y0HFO/oSDLBRSOAChxQ66+W7cuFG1DRh4nm0JxmEpDLZBuB3Lze2YppnCT3EGadi24T6ZcZADRNwn3ZnK08CPIAiCIAhlVEShcELxYMuWLSoWClMXs+FDwYRiCWOjJCYmKncfusDQMoWNG84XBEEQhLJCffTETZa/1Gc7cvC9/XLsxt9eb9/RuB79DG2laMCKEGQiM9/1axv7cI3xLhajP/41hyMQ9Db+RFdjL6riagA1ctP1MiPO119/jdGjR7us/9tvv+GBBx7AhAkT8Oabb6o6PpAMGTIEAwcOVJ85yDJ06FDlljNr1iz8/vvvuO222wrdBwWfcePGqcEaWrZERxdfkOLgD68DRSVazIgFiiAIgiBUTEpFROHIEa1N6tatq6wxaO7KBg0/cxmtNziKQxgLpVatWirVMbcRBEEQhLKUrcdy2vXGbtrQ1rgCteCazjfeXIb9WIHWGI5qhmtMjlijN4KM03mMvcCAiSAjGxYzcEmOrbDBimx1LGfLDdbTtLbQUCyYMmWKcuHhsr/++ksNgOQH63e6uXBgpFjlc0qpTCsP7pPl46CMN2mF//nnH6xdu1a5BNEKhe2M4go/HPBhFsHu3burAR+6K7unPBYEQRAEoWJQ4iKKDhbLxk7Tpk2xc+dOzJgxwyXAKteh2W6dOnVw4YUXolGjRmjdunVJF1UQBEEQfBJUzjHuzDN/rv1ZHDRXo7vlDjQ3LvLjFdUih7/cRQoO3O7ulrJ37148+uijuVnmvvvuOzXlB4WF888/v9giinOAebYnHnrooTxB5z250Oh1Jk+erCxqKP6cc845Ph3Pfb96GS1gPvroI2WBwnMUBEEQBKHiUmopjjlC06NHD+UvTHceHReFo0EcSaK/M0eHGPVe3HgEQRCE8ko7YyRqog1qo6Pf9tkCaxFpHMNy80IcQiO/7LMZNqC9sQz1sDuPMEMXGlqFMqVv7vrNmikxwtssc6zf3TPZFIX58+fj008/VW47AwYMUPOYBe/ZZ59VLjSTJk1Ct27d8mxHq1cKHcwI+NVXX6mBHG9YunQp3nvvPdxwww3KdcgZZiLisrZt2+Kbb75R7RlBEARBECo2pSaiUChhY4piCRtmx48fV2bAnM+GFl19aI3CGCk029WjPRKgTRAEQShPVEFrBBvNEYqiu4yYph0ZSEEmTqrvNYxDiDEPYyfa4/jpuCV2WJCFMB8sU0yEIj3Xbac24tHWWHV6WRQykIwMMxmhqKoGPDg5Q4sSZp4raRjg9qefflIDMZ06dcq1iqFr0YgRI1TMFue2AuOlMPvfpk2b1HZdu3ZF//791TJP7kfcloM32sVn3759aruePXvmiigUjrjPzZs348cff8QLL7yQK+h4s09BEARBEMovpSaiaNigYPYamgOzUXLgwAFlkbJ69Wplpstgb4zyzxEjHS9FEARBEMoLn9u34lP7FnxiPR/nG7WLtI80JOIn+2gkYqcKYOvARH9jKnpjuvp2EI3xp3kj7F6mR2amn8uNCYiEo9MfjrTcZRRQfrZfhfpGD4wwvkIQ/Juu2B+8+uqryiKFMCYLLVo9wWw511xzjWpfEAa/nThxYr77ZduDFjZaoPEELV+YGpl/Ca1RCnJlYluHx/TGfUgQBEEQhLJNqSkStCxhgLqMjAwcPXpUBag7fPiwGsFh6mM2iGiBwsj52lSYlit08eGIjlikCIIgCGUJ1mtbkYxkM8tl/jozSc1fbSYg2O6a1r6eUQkNjIhC923AoixCQlD5zDwDqOqUTjnbDFWuOAwLq6GgkoC6sCIHMTjsEveEIkoNHEJV43gBxyu8bCUNLVhpheIOrVqZXtkdtiUYj4V/vUm9TBFFB64lHMzh8WrXPiOAMcMg90m8cVHSrsqCIAiCIJR/DNM9GlsJQQGF1icMLEs/YooltEChVQpdeJwFFjY+2Ki59dZb0aVLF/WZDZjyzrp161QAOpofc4SK51QS4hCvO92nKEgxwK9Q8aAQyZThbORXrnym0yWUf7KysnDs2DF1X3UnTigb5Jh2XG6bg7mmw+JBk61sR0yEqDw+ru/4Jyyd8LS1i8s81n1JSUnq/cz3NGFVnYMM7MY/+MF+mZM1yhnspgGb29hIGqrgW/MhVMEJjDY+UGKKM0HMwuOh2glHdYyx/IMYtIQVoWVq4ILuOfwdeIJChXtWHLYnODDjbXOH58p9aCFFH8/ZGra4+9T1MF18JO5bxYKprvmOpks6M02W1G+Hx+W7Q8O2tAh3giAIgaHUhkXYKNm+fTuOHDmiRneYgYcpjNlopGjChgkrhOTkZGWlsn//fmWqy44hA8dVBBFFEARBKN/EmScx3b5P2XfYYWKnmYJ0eA60moW8aYmXmEfwgW2T+lzZCMJIo4nHyCnsiAUjHEFm/m41FsOEBdku88LMVHQwlqrYJyHIhMXwPjVyEMJ8Sr/siSPmBuwx/0VTYyBqGP4JusqOoS+dQ7YX2KH0x/HYdmEmHrZL3KFAMnz4cBXTzR1a1E6bNi3XpYj7YZuGHW0ODBEKZiNHjlRtIW+gkPPnn3+qmC35wTYV9ykDJoIgCIJQAUQUCiSMe8K/jGbPKP86qr1W7dlAYEODkfinT5+uGhwJCQmIiooSdV0QBEEoNbQFwkYzCffal3iQR7xjlrlfTaQuKqF/UD3U8mPVHGpkog/+REngySojzlyI6eY9GIGvlVWLO2XJwsUb2CZ5++23sXjx4jzLKIa0a9cOderUyXNuFFHeffdd/Pvvv/nuu3Hjxhg0aJBPIsqHH36Iv/76K9916tWrh4EDB4qIIgiCIAgVQURh5c/I9mwsMN2gJ7N0NkA4ssN16OZD8UT7NQuCIAhCaZGITIy3r8ZG83iRBRR3jiMTD9iWoqO9KsagPsoTFFBWmB8jHktc5h8zt6u/K81PsQuunf3G6I+uxhiURxh/hSmVnV1x2K75+eeflaXKM888k+uK5QwtabkdLWM4MKRdLl5//XXl4lMU2D7iPvnXuSxvvPGGcgsTBEEQBKECBZalPzH9+mn6SmEkvxEpuvdwPT2Vt5ErQRAEoWKRas/ClBNbcMjuISOMxQAiQulHkneZ3Q6cymQAkzyL2IX+FZtxzKyFm1HP43EtysmmGrJwSsVIIaYdyDrl+JsfliAguLIjGG1hBKMSwhCpgssWhN3MUeVwnImJPeY8bMJkj+tSXIk3XQUWixGMNuYI9dmAoYLYWoyyO0hCkYODP3TBoYUHUyk7Cxds00yYMEEFyX/sscc87oOiC91rKLDomCi0YPn2229VFiFfykIRhtvSJZr7dHYjosXMDz/8ICKKIAiCIFQkEYVCCCt/CiR06VGFcfNxZoAsxkzhX1qhsLHCIF1iiSIIgiCUKkdSgGs+BBKO5F1WKxL49lagZl5LBCScBK6fCBxNzn/fXXoAL57rcVE9dMMtlvlYZU7AUvNdNS89CfjteiDFNZ6tC3W6Ahd/ClhdY656ZIDxPFoYwxCJgjPZHMUm/GofgxxkKhElGQUUwANbzN9xwFypPgejMkZavvHo8lNWYBrjSZMm4emnn0aHDh08WpqUFJ9//rkSbB5//HF07dpVWbgIgiAIglABRBRam1AAoUjCzDvu2UM4n385+uIcXE37D3OkhUHYONpClx7nyPiCIAiCUNKwXtuBZGzLSkD2tkNAegrQlB1Yw9USZcMBIDYdaFrT1fwj2w7sOAyczPCwLAfYehinYo5gfVAyWljCUBWuHfUQIwI10RaVzZq58+w2IGkHkHYMqN7cdZe2HCBxG1ApmmX37hyron6BQWBpgZKArTho/ocj2ASbElF8JwPH1aStXw6aa2CHTQkpZdEihcFkt27dqlx5mjdv7vPAUcuWLZVLMgePigszF27evFmlX+Z+PR2PZWRbasuWLaqtxe9iySsIgiAIxSegigTNSRk1/uDBg1i+fLlL0Dn66yYmJiqRZdmyZcrShI0BbWXCrDwUUbgOR3x69uzpIrIIgiAIQknDVMUP2pbhn5yNyKA7Tc8mwPe3A1Yn15eDJ4BL3gM61Acm3QFYPfjQdG8M/HSn63aHkoFBb2JdcDJGRS7Do6Fd8BzOiCWFUbszMGoqYHGyNklLAL67EH4lEycxxX4DErClyAKKO9lIw6/mGNQxO+NGy18IRQQqEhwAeuedd1Q7iHFQnFPRBgJmJGKclfj4eAwdOhRt27bF5MmTZSBKEARBEMq6iEKhhKMl9PvVIy96FIQNCbrn0BqFViZ6ck5dTMsT+hjTSqWgmCmCIAiCUCLQwnLGWqTvXgdc3hloVQeICHNYn2jCgoGMbMeUHxRPKoUAQU4WF/xuGCpVcrphQ3YB6YjrGJ3R1bxNZWbZvXMvmg8DIhsBIVUc8U802anexUEhtdAeDYxzUd1oWsiaJrKRnhuTxV9wf459emkyU8Kce+65qk3CQaFNmxxpqZs0aaKy33AwaM2aNSoeiifYfvGUZnnFihXYsWMHOnfurAaLvM3MUxg8HttOPCYHpAIt2giCIAjC2USJWKLQlYe+wxRCfHHHofkpt+G2IqAIgiAIpY7NDrz3N7DjP2Dh40CdaqVSjBbGEDQzBuPLTy7HomV7cdNiIKpx4dvRIDQ/UaWpMRBDLG8Vsn3JCBw8Tlmr90eNGoVLL71UiSY6xTHn8fsvv/yiUh+TZs2aeb3PX3/9FZ999hlmzpyJAQMG+LW8JXWvBEEQBOFsI6AiCq1KKIAwGCwbFfzuS6Po5MmTaoSmZs2aKhK+p1EcQRAEQSg3RFUCXhsFVKvkOXtPEQg1qmKw8T+EGIlYbL4JE7Yzy6oA/V8GUvYDM8cBTQYBbUc5ljEbTl/jf4hALfW9ptG20E75KvNTxGEBTuIQAsEJ7MUf5lg0wQB0MW5GWYNWtU888YSysiUJCQkYM2aMskihGEIXGm/Ei40bN+LNN99UcUoYILZNmzZ+twSm+9D27dvx1FNPqfI5W/oKgiAIglBGRRQKJhEREco8lQ0FXytwxkWh6SzjpXCiFQsbBtxvWRuhEgRBECo2GaYNachGTqVgh+tNahaQkn5arQgCQoKA9GxHCuP8OtKVQ4Eru7nO47rcLjXTsV/l1gNkwY4UMwvhCEKwkX/9GYxwtDVGwmLsx2rzc9hwxo0oJNxE6ytSsXeBiX+eACKiQtB5lCO+WGXEoJ1xpRfuO2fYg3+xwfwRgSIdSVhnfo8gIwxdUPZEFFrHDhs2LPf71KlT8eKLL6rphhtuwDfffJOvSw9hG4bB8hlQf8aMGXjuuedw4403+lwOxojjIFVWVpYacKpcubJLG4vHoasXxRqKKPXr1y/C2QqCIAiCUOIiCmOadOvWzWcLFA0FmPbt2+d+P3HihHIRYmR8f0S3FwRBEARv+cy+BZ9jK/a83h/Y2xq442vgxGkRZewFwE29gUd+BhZud6Qy9ha7CTwxGdh4EHjvGiA2WsVM+ca+HX/bD+Bta09cYNQtdDd10AVjLPNcYopQlJhsvwHAfvW9vTEat1keUp8NBKlMPELR6d+/PxYsWIC6dQu/P4SB9q+//nq1/pQpU3zO8qO59dZbVcDYt956Cx988IESb9g2EgRBEAShArjzVKlSpcB1aPbKiWn4KJDwr7spLEdaaJHC2CpcXqMG00mWDxg4lxmGOPJEyxpn6KrE0SJBEASh7GPAgBUWoEkNgN6ltDzRmXcOpwDr9jmsSWgR4O3AweFkRzafk5kOa5bWdYDakbnHs6j/vdtXqBGB2ujgMi8l+yiObw1F1uHK6NihGZrX64TaRkcfz1zQsM7euXOnaq+0aNFCuStz2r9/P9atW6fEEQbNd4//xu127dqF3bt3q89Mddy6dWv1tyDYHuLx2AZiKmM9gFS7dm3ExMQodyKmOmZ5BEEQBEGoACKKN7CBwMo/KSlJiQ00S6Xw4CykcB6tUCjI0DqlYcOG5SbdMc/r+++/VxH4abrrDBtSDJ4rCIIglH1ut7TCtZZmGGGbg39rZQG/jD1j9PHmbGDI28CXtwCPDwUGFxygNZdvlgCvzwI+vwkY0BqodKZuu97SHM9YOit3nqKSeQL49TqgVs2O+GvW76hcuWKlDi5pOKhz9913K/Fi7ty5SjAhH374oYpt8uOPP3rMssN2zn333aeC7U+bNk0JL95kzOF2Dz74oBJfeDyKJ4IgCIIgnKUiCgUEpt2jOMLAZxRKOFFUoIjC0RYKKfzMhgbXpWsPfYDLU3A0phhs1aqVcm2iAOQusEyfPr3UyiYIgiB4T6hhhcWkE4zhSGnM1Maazg2BEV2BRtGOuCeFWaIcOA78vRnIzHFsR+sW5/2pwK8WVDFCCtwNM8PUqVMHs2bNQqNGjTB48GAVt0PD8QimObZnWhERUaXIAxBHzU2IN5fhuLkbJcExcztW2yci1jgfMUYLlCXYTqFbznfffadikZDVq1erNgyvr3tdz0GUtWvXKksU1vsUUdg24H741/2exMbGqkw92g2a7R9a4uZnuUpLV4o3FGY0bD8dOHAgAGcvCIIgCEKpiijHjx9XAsq3336r3HQ4j6M8rPxpdcLvKSkpSjRho7BTp05qFMaXNMmlDU116bfsifXr16uRJUEQBKGcc2knx8SOb3xS4etvPADc+a3DauWT6713/3GCdSOtIo4cOYJzzz1Xdb4pqjiLKP5il/k3Zpj3o6TYi4XYay7EZfi8zIkohNl5aFniDAdLPMH0x2+88Ubu9wceeKDAfTONMmOteBtLjm2phx9+2OMyZjYUBEEQBMG/lJoaQQsTjs7QyuSyyy5T/r4cbaFoQvGE6f4olnA5zV8ZyZ5B05ilJxANxEAimYQEQRAqGImngNdmAQ2rA2P7OSxTbHbgw7nAzqPAY0Mc1iXuHeHjqY7tGEz2/WuAzrFeCSiMqfXyyy+jZs2aqvOu68GSql+aGANwKT5V2X8OYGXAj9cQvdHZuB6xRm+UJWgl++ijj3rMwMN70qxZszzzR44cmSeALNtA+Vmi0KJI31fuk6IL20bOliZaROOzcMUVV+RbXlrKuG8nCIIgCEI5E1F0rBM2ICiM0Oy1X79+yhyVrj0cUeE6HFULDw9X661Zs0aZydKqQ5vOCoIgCEJpEIYgVDplQ/qk5TA71Aeu7+UIJmuzAdPXAzuOOESUelFnNmLdl5HtyNozaTnQqg7w5DCVhUelRPZ4IJsjgO1pF5JJkyapzvg999zjcTCBFp2sS2nRqeF3fwQwr2W0Q020xR7MwwEz8CJKDaMlulluL37MNTiyJwUh3C+CE687LUV8oUePHmpyhoNGbO/Q6ragAPwUSpxTKjNGinMslT59+riUjaJMYefJ68J98LlgO6uoLtJ83ngenvC2LIIgCIJQHikVSxSOqHFUhZYlHCFhYDbOo/8uPzPuCa1QWPly1EfHT2GFLQiCIAilBeOhvGXtie1BNXEz3sCxZbuBgW8ylY5DKNmVAESeVj6coeXJ41OABafTH5/MAC58o2ArlFvuBsb19Lps//33n0ssDd3pZt1av/7Zl8o4Bxn43bwDOWYGLrd8gVAUnC2wPLB06VIVaNaTMMbBp3feeadQa11u+/jjj2Pbtm348ssvVUydosDnbdy4cR4zA3Xp0kUF283PxUkQBEEQyjOlIqLQdYejIKxcacaqhRKOtFFU0Q1AiiZcT8dJcU99LAiCIAglCeunFohEaEgNBLeuCyQEATlOAn9sNFCrKhDsoSPLgQBWby1PZ1jJ8WwhUskMQkNbOGpkO9LZEtaTDFLO7HTuo/scdGD6W1p2eurQclnTpk0rtFVAtpmOJOyGCZuLiHLI/E/9PYL1CDHPiChMHl0dTRBsuGbRKetwwInWuTVq1FCuXc7QmnfDhg1KFOEglTO05o2Li1PtKLa3KIAw0C2tfYsK98n9sN3mnjWI5dy4caMqS1FFGkEQBEEoq5SKiELzYlawzqIIhRJWyIxczwqeDUGKKmwQHDp0SAku5SkrjyAIglCBoVAyeRxgT827jPFRmKHHfd6rV+YrnDjTKTsan6V0Qc3qMbnzaKU5efLk3EDrznDZzz//XKDbDoUWCjEVFQoo39gHIxMnneaayILj/nxtHwJDKVgOghGO6yx/oh66oTxy66234pFHHnGZN2/ePBWQlvOfeOIJl2XLly/HqFGjci162b5yF2GKyjXXXIPx48fnOR4zRd1+++148cUX/XIcQRAEQTirRRQ25tgITExMVI0+iieEbjwUTBhIlhU8K3t+p18tg7W5pw0UBEEQhMJIMbMwy4xHTVRCX6O2XywyKltCMDKyNTaaxzHPPFj4BoYHYcWNcFgxxGiATlmRqGpWdQk4SvEkv9gZBS3zN7E4H6ZhYoc5E5lI8fv+wxGFZsZgNECvQteNN5fimLlDfU5BPNKQlBsDxZ0sF3HFYaWyzfwTR83N6nt1o7EKZltWrXWY4njmzJmIj4/Hddddh+7du6s4cc7weaGrNK193aFgwlgubHNxAIuCS1Gte+lercty9dVXo1evXnnKwnZbfmURBEEQhPJOqYgoDGTGCpampQysxvSMbLjQZ3vx4sXYunWr+k7rEworHFlh8DR+FgRBEARfOIJ0jLMtUQJKH2ttJ3uEohONULxr6YXp5j78azuI4oduBaIQiresvVDLEoQkeJEmuYRhvXwOxqIDrsJn5nkBEVGqoRGGG58hBIUPmqw2v8Rqc0KRjmNDFuaZZ6wnOuAaNCxjmYCc4aATM/Ew1sjvv//us2Vu+/btVfwTQiGFgsratWuLVBZaEjOlMlNqz549u0JbOAmCIAhCmRFRaFFCSxSmNubICUdI6L5D39xBgwapyp7uPRRa6tatq3zAuY1U1IIgCEJBrDaP4Qv7Npg4M8qebGbhFLLxn5mIu+2LXdaPQRgetnRAVcO3AJjaYqEdquMDy3nqaHaY+Mi+GVtwwuv90PLkYqOh+lzZCEJ10Pqk7AZRV+ddAuHJCrII2WcuwTrzO+wzF/nteMw49CfGoR1GobFxAco6vlrMBNLCpqxa7wiCIAhChRFRWNnSEoUTI8k7Q9PSrl27Kvcemq5yncaNGyvBhaMuUlELgiAI7vVGJuxKwCCbzeNKyPDEbpzEx/YtLvMaIQJjLC0RZDpG9oNhQbDh/Sh/I6MKxlrbqM85ph1/mfsRZ7q6jmTDjhyYCIEFVjc7mF5GTdx1entNRhkWURwYCEYYrAiFDf5z1whCqJoc0XfzJ8HcghXmx/AnidiBRHMHaqB1mRRR2P7hwBLdoelOoy1ROBDFZXSb4VQSAfh1WTiwxbLoYMa0HmZ7jQkBnNMwC4IgCEJFo1QsUQoiJiYGUVFRKh4KGwlsIOzevVu5+FBgkSjvgiAIgiYLdtxtW4wNp91fEk3fOvWHkIYROXNyhZNxlra4wWhepAtMgeQ1aw9l+eLMBPtWfGlux2uWHuhpuAbzrGdULnc3k6mCR1i+xgFzFf4w7/KLkBKMSsqNp7bRUQV9FVxhtp0pU6aobDgDBw5UYgkFi7feeksNNt1yyy3YsWNHgcGF/QUDGf/www8q+86QIUNUe43Cyssvv4xOnTqpsmzZsqVYmX8EQRAE4awVUVjJ0y2HFSlHK4oCLVKOHTuGhIQECVAmCIIg5HLYTFMiCF141iKxSFeGViz/cdvTA/i9zURsMWPQEBGobPgW64EdyVaolseQYqWZgDZmNXQ1YtDD4p+MKKWJxQhCbXRQ2W9qmm1UkFaSggM+xUkJQzVUgSP9LWOg1DW6oYbRMt/1s80MnEAcTuIQAsVJHFaWLtUQW6bSH3NAqXPnzioeCdtFFEsoouzZs0e1s5jeuKjtLF+hBQrFElq+MNsi23h89hnnjhYqJVkWQRAEQahwIgpNPPfu3asy7KxYscJnM1Ouz4YC3XoqVapUIiMsgiAIQvngHftGfGrfgpPw34g3XYG+te/AFOuFON+o7Zd93mJpiWstzRCBihWAsyba4mbLP0pMIb/bb8cmTPZ6+9bGcAwx3j79zUBoIcFkk7AD39iHIj2AQXeXmG9jjfkFrrVMQ310R1njvPPOw8KFC9VnWoCMGTMGO3fuVFYqtAy56qqrSqwsDHI7f/783PbaXXfdpdIZMxX3gQMHMGLEiBIriyAIgiBUGBGFogetSJiBh/ga14QiDEczKKAwM48ElhUEQRA06cjBCbi6zhQXxiOxwUSOX/LtOAg3ghBe9rxn/WKREk7Lm9Od6EZGX1jczjPR3ImDWIX66Ikoo5HLslj0RrgR5fXx7LCBtijZSEOgYIrkDJgqik1ZhO0gujxrEYXphRl8n+4+tAQpydhxzmXh/e/Ro4dKdUy3a6Y3FgRBEISKSsAtUWhqStPTatWqKdNTTt5CAYXbVq5cWWXpoZmoIAiCIAhlC3bee2CcmpxZgY9x0FyFc4yx6GRcX2rlq4iwPfX444+jrNz/+++/P/f7tm3bSrU8giAIglBuRRRanjA1Ma1IGjVqpL7riPLewCw93JYjLBzZEBFFEARBWGMew9f27fjXHpjYGDbY8YF9Exaah3G/pZ1X6Y+nT5+Ov/76K9/lrPtuv/12tG7dGhUVT1YQtDYZindQ3+guGfb8AF12Pv/8cxXQdfDgweqa0tr37bffVrFJ3nzzTWUR4i+2b9+OTz75BP369cMll1zisoyBbD/++GNccMEFuPTSS1VZ2G5755131ADYq6++qhICCIIgCEJFI6AiCitUiii0JGnbtq1PAgphADWaq9JcNDo6WgVW0zjHV+FnHks34PQyHVPFU7k46fJwPecpv/WdjyEIgiCUDtvNZLxn3xSw/bPWmGrG4T8zEbdbWqEqChdRli1bhvfee0+5OLjXdToFLDu9FVlE8URto4OaigPrZRuy/JpOuTB4vBwzE1aElKl6ny4777//vnKb6du3r5pHt+mJEyeiQ4cO+OOPP1QaZH8RHx+PDz74QKUvdhdR9u/fr5bx+gwaNEjNY1DZr776CvXq1cOcOXNc2m2CIAiCUFEIqIjCSpejEL7GQtFo8YUNAjZMnV2BdOaftLQ0FR2eIgtjp+hljBrPYGvr16/P3ZaCDPfFxkeDBg3QokULtT7nc0QlKSlJbcP1uS+OqHBkh+kDuX+WxRd3JEEQBOHsgXUdR9/dLQFoOfDNN9+UWrnKO9lIxx/mWBw21wU0HoomB5mYbr8HNY22uNT4BGGIRFnjyy+/VCIFYVuIQkpp8eOPP2Lp0qW5giGDylJEEQRBEISKSsDdeRgLpahQ8KA7jydoYZKRkaEmCinOx2ElTvNWNioOHz6slnE0RFulUHShSMJtKZhQdElMTFTrUzih2xDLzv1SjOFoC/82b95cCUMipAiCIAjucLCgTZs2OPfcc13mz5o1Sy5WsTCRYSaroLKmzkUdYHisDPMEYJTM8XwZXOIAENszbLdo6DJdv359rwesKHIw+GthVitsK7HtU6NGDY/LWBYONjmXJTY2VgW7LUsWPIIgCILgT8ptugCKGjQz1a48zm47tCiZOXOmsjCpUqWKSgnIBgbX5QjJ999/n5s6mZU9/27dulVtS79eNlI4cXSHosobb7yhGhpsSFSvXj03Gr0gCIIgCIElGJVwheUrHMJafGe/GFlIDejxghCC4ZbPUB89EArPAzmlBdszixYt8rjMkyuZJ7gO2zUccKJlbkF069YNCxYs8BiTjimO//33X4/baQtiQRAEQaiIlFsRhZU/Y6ZQ7KClifNoCpdRSOEoCQUPiiS6AcC/tEqhCHPo0CHUrFlT7YNiCsUYNii4Di1OuE8tznCftFzhiIsgCIJQ8qSYWfjHPIhl5pESOd4pZGOauRdtzCicZ9QqcGS9Xbt2GDlypArEybgQ7p3WK6+8ErVr1y6BUlc8eN3DUA1hJi1OS8K6wUAoIn1Kv+yJZDMe8eZS1DI6oIbRyi8lY9uE7sXFvZ75Wfm6QyFEH48DUYsXL1aDUZ72SQssWsMUBq1+58+fj6ZNm6Jz585FOANHWVasWKFixBR0rfr371+oUCQIgiAIZ42IQisRuuowXgkz9ziPeFDoYCVNc9WYmBhVkWq4HucxffLmzZuVhQq3HzBggFquG8n8S7cdbksRhiIK3YC8bXgIgiAI/uUg0nCrbQESSyjAaAIycIdtEYYbsTjXemGB3fdRo0ZhxIgRuPjii/Nk6Rk/fjx++OGHgJdXKFvsxwr8bF6NQXjFbyJKaULhghYsv//+e55lFAp/+eUXr0QUWv5ef/31uPPOO4ssohAGtf3uu+/yXU7xZOHChWjfvn2RjyEIgiAIFUpEYWVOYYN/aTHiPEJI4YMjfqzUGc+kWbNmuZl3aIFy5MiR3GwJ+q/z9vzMdSm00NqF0DqF+xQRRRAEoXSoiTCMt3TFUvMovjd3Bvx41RGKeyxt0cmILtT+Yfbs2Uo82bZtm+q83Xvvvbn1BdO9Pvroo7jlllvQqlX570wLedlqTkOcucBl3jFzO0zYsc38E6fsrtZTVc2miMWl5e5Ssm3ErIv33HOPcm92Zs2aNVi3bp1axsEq522+/fZbFeif0JKFg12esiH6Wha2ze6++27UqlUrT7BbJgoQBEEQhEBQYUQUZ2htwgqVAkhCQoISQ+iWwxgpdMnRAdAotnAf7ibaumJnYFkGXqMYw4qagdW8SdfHY+mpoEaCdg3ierSsoeULj1XUbEbe4p4eWqh4yD2uuDincD/bfr9RCMVdljaItoeWiIhSFcG402iNWka4+u7pevP9zXqEbg4cGSccjb/jjjtQt25d9f3555/Hhx9+iAsuuABNmjTJI/wXxNl2jwvEBKxmCAxYYRq2gBzCMK2wMKW1aRQYxJbL7OAgjGOdXeZcLDPf87huHBbkEVgamYNQH4NhMxyplC0IgoHC45mUFmw/sc2iEwbcdtttypLX+XdAlzXGa6GVibPLEZ9hxqmbMmVK7nfuT38uDmyT3XjjjSp7ojMUbLSIUtq/oZI8vj6WBPUVBEEILOVWRCkIjgKysbp37141Krhx40blp05xhZYojH9CYYWTp0w7WnBZvXo19uzZg759+6pRFW5fWMXECmzJkiXKVYiNBueI9e7QPYhCDUcvBw8erAK4tWzZEv369cszwuNPnLMUUVQSKh66gcoRcD7nQsVB/37529WWdGcbJ4NPAeGBD4/Ba52UkoQgM29QTc2qVavwyiuvoGfPnmr0m2ixXb//hw0bpjp5P/30k0p3zPULimuh7zF/uxTYBQcmquEi8wvsCf0Layt9FJD73y79JjTNuBhWoyYSkX/9fcpyEAuqPoEs46T6fhy7fTrO4ZCV+DPqGtUGCbaHotfJp1Ejp+y6nUydOlUF5ae7Gi2q2B5ybt+w7cNnlc8usyO6t33Gjh2rRBbtzvPcc8+5DGoVBbbneFzGIHLfD5exLJ6WBRpny+eSPrZ2RZcskoIgCIGl3IkorJi0hYe23HCHFiYMGEuBghUYxQJObNiyc8lAsjqjj/P2uuJjxc7OJzPzsBHL2Cq0QvHWQoTb04KFgWsZmyU/dCXPctK8lfFduB1He3QnOJAjFc4ZjYSKa60QyGdJKHnk3gJ2awm9u8zToro9/98Q3/GMu0ARhZlTnNG/vQYNGiirlI8++kh1IFmvFPS7lHe0Z6wIRz30RLK5B4Eiyt4E9e291GcbPN0jEyk4iOPYgb3mImQZKUU6ToblOA6FLM+1fmli3wiLrTKqoj4syDu4U9rs27dPPedjxoxB9+7d1TznZ9jZMk4PRDnDASJORA9IFbd+YjuPg2Jsa7m3BWk9zDYVrb5Kug4srXc0r6k32ZkEQRCEs1REobhBoYL+5p7S7hEKLDQ1pVm1syklRZV//vlHVTTM3uO8vR5JYSOXKf0YjIwZFxo2bKgEGG8EFK5z/vnnqwb1TTfdVKBQsWnTJpVSeejQoXjnnXfUMdi44N9AVoS8dnR1ol8zr4FQ8WAnjYIc7zEDIwsVB4qszD7G+8oU7mcjVc0U7UURUCxWi7IKjFFmL/mU5XTcE75LneNAuMPOlE5Bq/ZZwLqshziaz33yNyy4UgWBuyaVIyojJqKA+4hMzLKPQTyW5lqhFBcTNiys8hSqoymut8xAZeR//NKCg0/6eff07LL9xAEsPt/MiljQ8013IJVxKSyswPUK46WXXlIi5rXXXpsn/snLL7+sguDSMrmkrTJ0hki25UoyM5B2WRcEQRACT7kUUWglokUUTx1EVmAUWggralb+bLxqMYWNU25LCxM2UrV1Cy1C6ALEzicrdppbszHAikm73vB4hVWKrDg5Fdb45eiJbkj4YulSXLRAo80+hYqH3OOKix7ZPJt/vw3sVXC5vRHWm4nYBf90ZJ3hW/g8ozbaGVGoZAmG1bDmCt90DaXFCUfBCS1MLr/8clWPTJs2TaV5dQ9ySffOLVu2oHnz5kqUZ71T0L1zzxInuBJlNkZr++U4hP9wAvmnuPUFWoDUQ3dEW5rn3m9PmKYFWUhBJlzTWBcLA8qiJQMnwOq5oOOXFrQi4XMeHx+fm52H7Rb+FihgbNiwQbVpdP0T6Oebvzf+FjnodfDgQfVe7NOnT+7+OFC0bNkyNa+kUxzrwTNtGVJS8Ul4XImFIgiCUDKUO7s/VhLMrkORhI1XT5UjBRZW6rt27cLu3buV6KLFFX5mxcsKuGvXrrmxRzjyd/ToUfz5559qZIMVLxu8FFMoqtDdZu3ataoBIQiCIJQe5xm1MNk6EEMtDQOy/yBYMN7SBR9azkMkg4yehjEhRo8enZtlhLAe+fnnn1X9wmXMTuIOY6FcddVVKjbKp59+WmA8FKFwmqA/rrZMRlNjoN8uVyPjfLXPFhgit8ADFFD4HNOSd+TIkWp69tln1XP/22+/qXgny5c73JNKivfee08FlWW7jFkY+fucPHmymvgbveGGG6TNJgiCIFQsSxSOGtAihAIFK0COaFAUoTkolzFYH5dxNIFCRp06dZR/K83XaUGiU9vl585D9Z9iC1McUxyh2KKDyXbu3BlNmzZVliL0l2UjgKn5WA76/VKgoZBCqxMu53f+ZRklvoQgCELpwtFWju0GcnyXR7B4GEF2z7ShynJ6PdYlEydOVB1NZ5ixhNtJzAI/3Rt1vQ20wQjlAkNO4TBWmJ8odxtvsCAY3YzbEIkG6ntNo43jrhdgNbDV/BNx5r9+s35xJx1JmG++iHpmd3Qyri9TVgXaaoSZd+iurJ93Cilst7344otKxGB7K9AsXbpUWcNwoIsuPYRtRO0Kzd/aqFGj0Lp1a0yaNEktu/3221U5BUEQBKFciyi0KGF8Epp/rlixQlV2FEgoXNAqhJUkl9EChCMMjE9CqxH60tauXduryp4iDc2oGZ2d+6YYwr9dunRRlaqOB0LLFZpax8XF4fDhw6oRQAsWDYUTHnvgwIGlnipPEARBcGCFoRLD2gpMRusbFhgIVv97WGax5Juljcsotv/6668e9+tNdjfBN1oYQ9REjpgbsNb8DplwjkPGNMR0fzNVCmFn2S0Y4ehs3Ij6xjleH2+3+TeWmu8G7DZlIhnLzQ/QCpeik3Fd4NNP+Qif3yuuuCL3+/z585V11b333qvElJUrV5aIiMLMia+++iq+/fZbXHfddR7LySxCvXv3VjHqKK7cfPPNIqIIgiAI5V9EoVBCf1WKKUztS+sSWpxwxI5xSTjCwYwG/fv3V/6u9Lft1KmTV/umdQqFF4otjCLPClRbnPAvhRTnEQk2bocMGaLEFMY+Ie6NXa7D+CgSiFUQBKFscKelDQYZ9fGQbTk247hf9nmL0RJXW5qio5HX5YYdsQEDBqBjx455ltGtgG6g+cE6xdN2gn+ohsa42jIFJs6k/c5BJmbaH0QOMjDM8h5CUPnM/YAVMXBkixGKBp9nukCzrSYIgiAIZxMlLqLoIK4UNGghQoGDYgfdbdjIpCUIXWr4naIKg5nRBYcWJdzGG7RQwokWJ4VBqxWKOIIgCEJgOGZmIBXZqI1KCPVT4MwWRiRiEYFWRiRSzWw1Lw05SID3GSpoyVIHlXJtT7oYMehnqetxXbqBcvJEkyZN1CSUDqFGBBqjr8u8bDNNCSXZSEcjXIAww5FJSSh6+42WJpmZmaptxYGlfv36KbdrWvLSRZqCCged/HU8ulazDch2oh78YmIAZl/kfA66sSzOA2N6O7p00w2b5RIrMEEQBKHcB5ZlrBMKKKwUY2NjVaOUQgYr4T179qiKjyaiTP9Ln1fGQmHFLFYggiAI5ZPX7OvQP2c6tvozqwmAEFjwmfV8LA0arqYXLN182r4uKmN60EW5219naebX8gmlRxDCcbllIq60fI/QAKZFPlugOPHYY48pVxmdiYd89913ynVm8ODBmDFjhl8HpZ555hkMGjRIiSUauhQtWbJEWTNzGduN7jz//PMqGO748ePxxRdf5Bs/TxAEQRDKjTsPRzE4gsDRClqiUEChqLJjxw41mqAtU5iaWAfi43wZSRAEQSjb5Jh2LDaPIBlZLvPXm0k4gDTMtR/EXsORMU3T3qiOxkaVIh2P9UI0znSQ2hpRuMRwzdqTihwsMg8jGqHoatRwiTRBy5gGqIxqRmiRji+UXfhsVEJMsfeTYh7AQazGcfNMrLRAwiC5W/EHapptEG00R1mCseYYhH/27Nm5qbwZC4VWxIxp557eu7iwbUjrF2dLZLYNOajGtiTj5s2ZMwfbtm1z2Y7pyBMSElQcPVo1C4IgCEK5F1FoicKKmMIIp+zsbJV2eObMmSo+SsOGDZWIQvGEcUro/kPBhd8FQRCEsksGbHjYvgxrzGMu83W4Ty5zD5f5geU8jLUyO4p/0h//ah3kMm8nktE75w/0MmrhJ+sAlXlHE+gsP0L5Z6+5CL+Y16gwtSXBfqzAJPsIDDT+D32MJ1DWoLBxxx135A5slWbAfcaxY2Bb90E2thvZjhQEQRCECiOi0D+V4gjNMZn5hplwOGLAkQW67dDXlSMPp06dUuIKLVV0SmJBEAShbLHaPIbf7I60r1mwY7+Zmm93k90t9y7XNHMvDtrS1OcaCMNtllYIN4pWPansbG7zaphheNzSEbFGhMroI1aNgi/UMtqhP57DdnMm4rE04BcvBq3Qwbgascb5KEvwd3PttdeqwS5Py9q08U4IpRs3s/l07dq10HWZqpjrMbaJOyNHjlRx8/KDls7+towRBEEQhFIXUXbt2qWCf3HEgBUk3Xjq16+vhJSNGzcqH9h//vlHZeWhvy1NOAVBEISyAUegmV6YVif/Z/+vyPuZZe5XE2mNarja0gwhphVWP6UErm6E4SFrB7/sSzj7qGm0VVOaPRHxZkmIKC1wgfEUDMNSrN+mw3LGVJmI/CEcch8UNYoL23hPPPGEV8djXBOX942NKasdMDYLJw0H3Lw5T+6D+/J2/YJg+5WTM3Q94jHc5wuCIAgVh1IRUWhxwtGBMWPGKFNMTtWrV1d+qxRS6LbDzDocrWCAWS2scFRBEARBKBvsxkk8ZFuGnWaK3/a5D6cw2va3Sl38mKWjWI0IQhGggDLXfAYnEIehxjuojLyWHOWNrVu34tFHH0VWlmu8JdKiRQu8/vrrhQaQpXjyzjvvYNGiRXjzzTeLnVFr7ty5eOONN1zmUTyhm/qFF16IJ598slj7FwRBEMomJS6iUPVnCmIKJTTDZGV48uRJ5bvKdHmECj4DlHGUgGIK54sViiAIQtniJLIx1zyIU3CkF/YHDAI7zzyk0g4LglA4djMHp3AUtAvLnQcb9pmLcQzbcNzYgxzTNe03A+4GG+Hl6vIylTJFC7YNGTDWXRxhwFsOxum2pIbtTLqI69gty5cvV/th27Oo6H3SHX3z5s15LFGYZZIDgIIgCELFpFQsUbSYoiOsU0BxNqmkwFKnTp3cCk8CygqCIAiCIOSFAsr39ktxEmfSDpM0JMKObHxvHw4DZ1yDLLDicsuXaIoB5fJyMsXxiy++6DKPQsaQIUOUu9FLL73ksmzLli0qfkpaWlpuYFwKMcWB7uh0NerTpw+WLl3q0oZlpiBnNyRBEASh4lGqIkp+vqjaWsV59IHZfBg3RSxSBEEQSj+N8TLzKNaaibAFKGPJQaRhphmPNohCIx/SHx86dAhr1671uIxupJ07dxYXIaFI1EBrNMMglT0nAyf8fhWDEI6G6IW6RuEBV4+Z25GEXepzqpmA44hDOhLzTZnsDLNT7TMXwXY6DXklRKMeuhUrBksgoWsMhQoKFwMGDMA555yDevXquaxz8OBB9dunQOIOB+vatWunYvGRDRs2qCyRxS0Tj0eLFJbFuT3LZX379vU60K4gCIJQ/ig1EcUXWHEyk89FF12EZs2alXZxBEEQzmrSkYP7bEuwVo10B4Z/zUNYaDuMdyy9cLe1rdfbMdbB1Vdf7XHZiBEj8OOPP4qIIhSJbsZt6Ghch6/tg7APS/x+FSNQC1dYvkEEaheaeHud+R3+NbXFhQ4i6x1ce575PGA6jtEUA3Gd5Q9YnaxVyhJ0u7nrrrtQtWpV/PXXX0oU8QW2GydPnpxr3Xzrrbdi6tSpASotlKjy0UcfKbd0QRAEoWISUBFFV1hU/Hfs2KGCx9KahDFPqN7T/DIzM7PQfXBkgS49kpZSEAShbMCsPIHMPWGePgb/eQMzvU2cOBHp6el46qmnXJYlJSWpZZItQygOtNSwmHQDMQJ1BOVqYzGsBVqgbDAnYY/5r0sMFF9x/vUmYgfmmy+gMfqiiVE2XXx0thu2BX118VZpz0+777BN6c+2JK3exo8f7zKP5aTrUJcuXfIVdAVBEITyTYlYolBEWb16tRoNoDKvg8nOnz+/0MBerIwovtSsWVNEFEEQBMEjiYmJeO211zBw4MA81iY7d+7Ezz//LHWI4Depg5M/ZUTuj/8KIxHblRWJP499HLuViEJRpqyKKDodMduEOs2xFlOc5wUSHkcPDmpBdt26dWpyd1Hn8muvvTaPiMLtuYzrFjfen96X8zFL4joIgiAIJSCiMEo5RROq8nzBh4SEKN9Vjhoyinp0dLTKwONpZID+q4x+Tj92RjkX00hBEATBVxio/Ntvv1WCvFg0CsXBgmAMsryCo+YmzDQfQhaKnuFFY8CKAcbzaGD0QhhcM8sIQEREBD788EPl2k1hgu1K8tBDD6n4KI888oiKc1KYZXNxYRlmzZqlPnMAUAeqJWPHjsXQoUPV53379qkyeYIZhLisW7duePjhh4v1PuJ1+N///odNmzbliipaRGFcwZdffhkdOnQo8v4FQRCEUhRR+FKn2h4aGqoElODgYFXRUSBhGjq+6Nmw9QQrKK7H7D1MZ8dttYIvDWFBEISS57iZiQRkINtLN5vikowsHDTTEINQhBTg5qChOw+FencY5FGEeKG40NWmIc5VcUuqmQ2RjuNqfgaSkY1Ur/djNUMRaq8Gi8WA1QhBI6MPYo3eBaYxTsUxpJmeg8f6g0ycQop5EOGojmAjDGUFth0ZqJUDbszKowPEMr0w449s3LhRZcQJtLsehZqZM2eqwT+2QSlY8J3CtmyrVq2U+w6XsVx169bNHTR0hssoxDgnTygKOuECBRQdSJvtbU4UeDh4mZ+QIwiCIJQDEYXCB61IrrvuOvWZlYpOady9e3eEhYWpyZMowoqAbjwMJqZHEE+dOqUy9BQ3PZ0gCILgG2ygv2Rfix/tu3AE6SVy+d6yb8A39h2YFDQAXRFT6Ppz585Fr169PC7jSDEDPooILxSXSDTADZZZuW41dIdZbX7u9fZ1s3qib8qriIioqto0EahZ4PoncRg/2C/HCewNWDSi/8yvsNX8HcMtE9AMF6Ks0bZtW+UGrsWC//u//8Pbb7+tftN0Gx89enTAy0DR5KuvvlIiCNMmDx48GG+++aaa+vXrh59++gktWrRQLoXz5s3Dueeem+sCpK1HCnNj94b3338fX375Jd555x107Ngxd98UmN544w189913xT6GIAiCUEoiim6oUjzhRFiZcDRB+4Lypc90cLRUoZjiDNdlIFruR1uvcDtWYuVFRGG5ORLBUYOEhIQ8IxLaLFUQBKE8UBvhaG5UxQkzC9kBDS3roCbC0cyoinB4985n/dKyZcs81ikrVqxQbqSC4A+sRjAiUT/3e12zK04gzmWdUziKI1iPaDRHNcS6LKuJroiw10NVMxJVvEjhzXglKTiANLi2I/xJJlKQhVPIKSGB1FfYTmzQoEFu+7Bp06bqNx0bG6vaV4ESRw8cOKASIXBAjymWKZLwncL2KF2NGjZsqNqxdNWhBQgFFroQctCQrj18H+lyp6am5mkLFgUmXNi/f7+y0ubxCcvAdjLTuOtlgiAIQgVKcczKhBUNTSOdKxxdyWgolrCSZGWwZ88eVTmwkmQsFS3KlHVobsmAhsuWLcOff/7psszZf1UQBKGsw/fv/ZZ2GIOW6JfzJ9YhKeDHvNPSGuMsbRHkZUaU888/Hz/88IPLPMZS4HxBCGT6467GLS7zNpu/4mfzKnQxbsF5xoMuyzKNTJxAityQYryL6K7CdhQH1fwhTOQH0yrffvvtKiYK44ywzcr2q7cwPTNjppAtW7Yo16RAcv311yvrbwo8giAIQgURUfRIASs+jiDQrFFbmDCALCsn7WtK1x2KJ7TY2L59O9q1a6f8TMuLFQqhmW7Pnj2V3y598p1h0Nxvvvmm1MomCILgK1bDgiDTKLnjwUCw4X0WC9Yluh7R0KLxgQceUHUNO0H9+/fP1+VHEIqCIy2xa9ukJtqgL55EQ+NcZbnijAGxQi2KRQjdVOi+ctFFF6m2IH/TTBZbM8EAAQAASURBVF/O9hR/4ww06y+OHDmi2mhLly7NtRr2ZgCPmcI+/fRTZYn85JNPqjLp7YobC8UZtpNZvgULFqjvjAlDaxTCa3PDDTegcePGfjueIAiCUMqWKPrlz5EDCimcaHZIk0c2fPnyZ4VFK45Vq1Zh69atKngWTSgZtKs8iSg0Lc9v1IFp8eg/KwiCIAQO1hvszEyePBmjRo1SZvYiogiBppbRDrWM/yvWPhzxNMzTcVBKJpgzj2aaPF7ZCuJPd5nx48fj5ptvxqBBg3ITELz33nuoVKmSipfCgSt/cfjwYTz//PNqQE9fBx28lvfFeVDQOfUx27aMVXLxxRerrGD+uIbOx9Df2Y7+/HNHHB7nY3AZRRu2Pd1FFL2f4iRocC9LfkgSCEEQKjKlJqLo2Ca1a9dWFhoMCjZp0iQ0a9ZMVYIUT+hzyhc1K0fOpxUKRxTLk4giCIIgCIJQFBgLZZ75POLNZbmZgAIJxZoF9pewxfgVg4xXEYFaKGswQ87ll1+uPutYJO5xkPwJ46Dcc889WLx4ce5xmexgwoQJ2Lt3r5q3fv16ZXny6KOPqjYqY5/4k0OHDuGxxx5TbWWi0xoTusO/+uqrqu1MF/nvv/8es2fP9rgfijq///47nn322SKnP6alDc+Tf/ODcVmefvppaa8LglBhKXERxVm9pjhCMYVBwZiijRYnOlCX/kwVnVYqnMe/FF7K0siIIAjC2YYBA9FGGKqboTiOzICMj4fBikiEoJJxppqihWJSUpJLljdv0NvR9J9uo/4crRaEQFuFJJhbcAj/wQ6Hq0agOYbtyDbTYTMyUZagdQUzNtL6ZPny5S5tSZ122BsYIJb7Kcy1hsu5Xvv27XHppZdi4cKFucdt3ry5SmnMAK+cR3GDliFMt8ztmPaYx/EXtIaheMS/bAvrDD88Dt3Fu3XrpgYZ+W5kvJY1a9aodWlN48zKlSvxxx9/qDgtRYUDnBRptBW5p+vOtro31iqCIAjllVKxROGLlZUMlWqaPrJipEjCeayk2OC94IILVMRxpkHWL2g2fEVAEQRBKF0qIQjfWC/AWjMRo21zkRqA+A6DjPp429oT0TiTtY2jvkwryiCx7777rtf7YnDyK664QsXV4mgyR5EFoTxgQRCGWd5DEnZhkn0EUgOYnceBgcHGa2hmDEYE6qAspjjWLjXOeMrw6Am2IZ966ikVP4UWHAVBC2imTNdtz8cffzxXfGC8vuHDh6N3795YsmSJsrqYOnWqis/CclK0pbDjbxjP6YMPPlCxnb7++mt88sknykr7mmuuUe1lpjdmEFy+J2ltcu+997psz3L5C7pE0p1IZ9t0hsKWWI0LglCRKRURheaGHBFkIDCaP1K9p4rPly4z7+gKkmKK9r3kOs4+qIIgCELpYDEM1ENlJCBDWaUEgggEoTGquLzzabrPlKGsO9xh/cEODUdj582b57IdA1IyQw8tGxs1auSx0S8IZRE+x1VQBzYzC0YJNNn4e44waqGa4UibW1TSzRM4jLWoivqINpr5pWwUSfj7LS58R3AqDAozzsej5QXdakhcXJwSUmgFQnGXliF8r/A7t+HAoDeiTmGwPUxLbSZY6NGjhxJK+B6jJR7bxLQ0YZuaZeE7kEFm+cyw/cx5LC8tZmihQtiWpiWPP6BFCs/d+X3Ka8bj+ePcBUEQyjKlIqLQj5KNYAb5Y6VEc0hWOlT9GXWdlQ8Vfa5Hk0AKLXxZswJhBSUIgiAIztSvXx+//PKLqjuGDBmSJwijzq4hCELgOYIN+M5+Mc4xxmGw8WqFuOS0fqOlifM75e+//1aiLcWJQAgHFEgefPBB1WamVYyz+MPjP/TQQ7mfmUVoxIgRLsvZtmYCA7olEVrhMOitP6BrEN+1ztAqhhblDRo08MsxBEEQyiqlIqJQsWfmHb7gqabr1MV86fIvFXOq7bROoZJOU0r6lsrooSAIQtmhJsLwgKUdVpoJmGXu98s+oxGKay3N0NPIG9CSbjgM8MhMbe5w9JV1R+vWrXH//fd73DfrGrFmFAT/Em8uR5w532XecexBNjIQby7FQruriELrlPbGaFic4h2VByiUkKuvvlolRSCMgTJjxowCt5szZ46KUUIohtAS2xsomixbtkxZvfDdRtd35zgubBMz2xjbyEz9zEHGYcOGYdGiRfjvv/8wevRodOrUScUt0ZYo/mxHU6Chm6TzPvmZZWnatKlyKZJ2uyAIFZVSqcEojtDKhEo+3Xcuuugi5Tuq/dQ5v0+fPkpA+eabb9SLmr6rhQUBEwRBEDyjXCOVub5rOsziUNeojOet3fCFfRtm286IKEUJJ6hLVBuV8JylK6KM0DzrcDT1ueeeK3A/tGbkJAgVjUC5zrkf5cyvseC0y5o95nzMMR/3uO5eLMRec6HLvIY4F22METBM3fkuW6mU3dFu5ZwoRlDIpcsKYRu1MBFl2rRp+PDDD1325w0MAEvrF14bBrLlds4pltkmvuOOO5Sg8+uvv6pMl3w/MhYKswVxGeMLBgKKI61atVKxWZzb5nSd7NmzpyoLrWJERBEEoaJSKqoEXXOo6DPaORVyCiRaJdfwO5cxKjorCJpq07VHEARB8J2dSMGzttXoZ6mL24xWfr2E/Y26+Nk6UH3ORA6etq3GHjiyR3jDrUZLDLY4zL+rIhiVS6dqEoQySyXEYLjlM+wzF2GBScsO/2c+aYMR6GC5BvXQtcD1MpCMv80nccp0xCY6hm0+HScB2/CL/RoYsKrv51keVMJKWeWff/7Bxx9/jNWrVysrEqYaZlYcwpgghTFmzBj07ds3N8g1XWq8hdYnzzzzjLIyue+++5R7D6FIQmtuLqMbEQcn6V5z4403YvPmzQgkHPRkQFtakotIIgjC2UqptFS12XXLli1RpUoVFYjKeRSCnxnVm0GyKJ7QQoUva86j+MKXdlketRAEQShN0s0cnHJLh7rbPIlfzTiE2a24zIh1WRYEC6ohpMjv1UZGFTWRVDMbXxjbcdJ0PT7LkwGbOg6P50wvSy2MtDQu0rEF4WwgxKiMlhimxBPDNFTqY39Tw2iFtsYV+S6n9UMmUnASB7HNnI5k7CvScdKRiC34Lfd7c/MixKAFwlCtTLr40J1mypQpKl4fxRMKGM7QoprphPODmSg5EQoc48eP9+q4PB6t7y688EJ1jFdeeSU3u05qampu0Fm2iRl0mxbezD7GZYGEbXO6DXmCZaHIwkFPxjxkG19SyguCUBEpldqK+ewphvAlW5CKzZcvY6No00cGoGVFQcsVqvOCIAhCXn4x9+AFm8MHX0MBIxM2TDX3YGHOYZdl7YwofG/tr1IXF5dwBOFLa191LGeesa3C7+ZefGHtq47nTA2IlaEglH1M/GU+hh3mbCWk+Iu55tNYaX6Kqyw/IwplV0xlimPGIPEEXWh+//13vx6Plic33XSTskLhIOLMmTNz47JQUPn222+VhQyDzbJcdDF6/fXXVeDYSZMmoTRgWehatGLFCmV9w5TQPA9BEISKRomLKBzppIqt0X6mFEc4sYLQPp/uKZGprjv7hAqCIAhAtmnHOjMR6XBkoFljHlPuO55IRraanLGaBhabhxFmOszrWxiRqGWceU/7mv64ISLyzO9ixOAYMtHaqIbmRqTcNkEoAuGojlj0VoFbkxHvl2tIC5CaaItqKDx98EnzEE4gDv7kFA7Dhiw1+QO2E1MO7kXmqWRUj22BoLDiibR0KWf6dA78MaUwoXVFhw4dlPXH9u3b/ZY2uKBUzE2aNMn9TMGEcQMZe4RtaoosLBPXoSt8IOB13bRpkzpXxp2iFbk7jI/CFMy8Jkwrz+sjCIJQESl1u0mdJo4mijT9Y+YeiibOgbc4j1YozNBD88bY2FiPL29BEISzEbrKjLEtwDacUN9tPpr6b0cyLrbNzv0+wXo+bjDyZsApDvdb2uNetEOwmyuPIAjeUx89cKPlL8wzn8MC8xW/XLq66IJrLb8jCP5P0VtabPztC+xf9S8GjZ+IqIbNirUvJj8YOHAg7r33XjzxxBNqHuP1MVbKX3/9hdtuu00NAgYixXF+MGjsrbfeqqyyKVaUBBzkpDXO1q1b8e+//yoLGUEQhLOVUhNRaE1CyxKmOmaKOPqTcqLCTVGFMVO4DgWVzMxMNVF5pz8qFXdBEISzHYrNM814rDETcRhpyELRrPQouThvO8MejxQzG6MtTVDD8I+rTbAh4okgFBeLYYUFVsSiD85FppqXiZPYYE5CFryNhWGgNYYjynC4zkSjBYIQrvadH/vNFSrLThIC02HPQQbWmF+httkR7YyRXsdGsWVnYc/iWcg86RCQFSZwfO92ZKenYtf8aQiPinHZpl7Hc1HNB2GFbU5OAwYMyI3vQfHis88+U1bSdFlhOuKdO3ciULCt/OOPP6JBgwYqHgktPmjZ/csvv6jgtgwoy2w5nHfeeeep9vOSJUuUwMKUzM4W4N7AQLV0CapVq5ZKAqFjEV5yySUqjfwPP/yAZs2aYfjw4S5u+WzHc7uEhAQlOp17btkNGCwIglBuRRRal7DSYSVAhZsdAoomXEarE87ji5wvaFZgjKXCIFsiogiCIDj41r4TP5r+7dj8ZO5W4kwfS51ixytxtiqUgOCC4B9aGEPURJLNeOwwZ3otohiwoKvlVrQ0PAcH9cRu8x/MMR1WGIEgG2lYaL6CBuiF1sZlsBTQPHV+p+RkZmDjb18iOd7zO3DT71/lmRcy7nlENmjqMs+bdxPjjuiYKAwu26dPH1x22WX48ssvlZASSBGFosTTTz+Nfv36YejQoWoerV8++OAD5WJEwYRuPBR1hgwZogQflu3gwYO4+OKLfRZRKNowAC4HLymcELa9aQETHx+v0hjTnYnLnK8d2/XPP/+8cjOaPn26S/pjQRCEikSpvd0olvClz0rgqquuUi9+WqFQNKGIQlNJvnw5n5HRd+zYoQLKMlOPiCiCIAjlgwULFuCjjz5SpufMMiEIgn8JRzQusXyMbPNMXA4Tdiw0X1VxUwYa/6diqWgMGKgLR7aY8sjBtUuw859f1Wd7Tg7SjrkGyi6MbbN/xsH/FqnPETXroePouxAU4puLeMOGDfHFF1+oDJIlybJly1SbmcIFBxrpWhOoGCiFwcxAtHJxtkRhO17ioAiCcDZQ4iKKcyDZ/fv3qww8DFCl455w4nKmg2MQL67H+Cc6VZqvarogCEJFhNl2cpCpwjEGAo71JptZSEYWqiLYZysSumVSFKe75s8//4z+/fsHpJyCcLYTYlRCK1xCdSQXu2nDZnMq7LChlTEcVY26KO/YbTnKRYeuOnFL/iryfhJ3blQTqdawOVpddBXMKpEIDiu4fUkXdLqW01KawsWIESPUd8b04+Cev93N9fHY9tX757HoOkSxgoOMXBYZGenyfuYytqnZhuYyZ5GDbWjup7AMl9yG58j9e1rGfRw6dEjFhXGHx/W0nSAIQkWiVCxRkpOTVeOaliV8wdO6hOIJRRVGImcFpf09+aKnZYqOlSIIgiAAv9h344Oc3TgI/2eFIKnIxg22eSqrzrfWfj6nP6Yv/rXXXosDBw7I7RKEEoYuO0MsbymhtTLOZHgpz5yI34VF7/8P6ceP+W2fKYf24q/xt6PRuYPQ6eq7CxSLmVaYLipMLdy2bVs1b8aMGSrY7J133qkEBcYs8Rfvvfeeii9CdyFaZ/NYOsXxa6+9hu+++06lOO7Vq5cSPLSb04QJE1TMErrVcECSgodm7NixGD16dKEWNMxING3aNBUs11mEIXSr/+233wpskzN2jFiNC4JQkSkVEUWnLKZQwgCy/MuKIT09Xb2UtbUK52klXhAEQThDEjKxDckBuyQMMxuHU6huhsLuQ7YfvreZBpPxATgaqQMxCoJQclAMiETxO/QZZjISsAXJ2IeSIAunsB/LUc1smBv4VmPLylSpi/nXX9izs5SQkn6icGHmyJEjyn1m5cqVaiCQrFmzBtu2bVMW0y1aODKaZaadQsre7bBXjymWqw2Px1TBbBuzrdy8efPcZRx8ZDuZFidcjxPfvWwvb9iwQb1/Y2Ji0LRp0wLTJucHBzAZONbXZYIgCGcLpSKiMHo3rVGcg4NRWGFlwGBWWkBhxbFu3TplMsgKxF0NFwRBEMoWfG9zVJaN+ZkzZ+L333/H7bffXtrFEgShCBzCf/jOfilykF4i1+8INuIb+0XoYYzDRcYbKIvvNwZX1e1RbRnisk7iEaz97FnU63I+6jZ/PmBl4aDjfffdl6dtTDd4aS8LgiBUQBGFggiV7KNHj6qXPQUVjppQWWfUbwaRZSRyiilch+49jPTNv4IgCELZhgKKjmdVmO+9IAhllyqoi67GGJXiOB5LA368CNRCG+NyNDB65c6j5Unc0jlI2rMVdg+ihT84Eb8bW2dOQp32PVDNLXOPhplx+E5zJvnAHhxavwxB8RuwZcYPah7djRi75cS+nWqfLsc5lY5bbr4J7Tt2KrRM559/vhJD6tbNG8+GaYzdrbTp+q5FHbrSeNpOEARBKMciCn0sWRFRMKFJJAUTiiiMkcJMDjSX5HeKLRROGJCQ6dRERBEEQSgdKGoXFlzW2bpQEITyT4zRAkONd7DA/grizcCLKFFojIuMtxBshOXOy8nKwIYpE5Rg4S2mkwsisxEVRsL2dWrqNfa5fEUUZqJhZhxnds2fhsUf7AO2LcKKbY6MP5rEXZvU5Exk/SZ48cVvEFK5SqHv1SuuuEJNej1nmL6Yk7tlCl3lnQO8BiLlvLfveUlpLwhCRaZURBT6yXN0kpHNqbJTUImIiFAiCnPOn3POOUphp9hSr149paZTQJERTUEQznZ2W1PxbJV12Go9WSLH24NTuMW2ABda6uFWo1WB606cOFEJ4bfccgtiY2M9NuIFQRACCQWUlAuTkNkkHVGTayI4McSvMVTWTf4Mp446AmafOrLfp+3Tko5i6SfjYQlyWOg1veBS1Ot0bqHbHT58GOPHj1du7+7UqlULzz33nFfv259++kkFqH3sscdyg+P6CjMEPfvss8r9Pj8YCPeRRx6R4LKCIFRYSlxEoTJNcYRWJnTR0bFQOI8BuNq1a4dGjRqpuCmsEPiZgWfLq4BC80qeI00sad7uDM9bRm4FQfCFZCMb80IScNJwfZ8EihRkYbYZj9pm/g10it6MFbBw4UJMmTJFiShMXc+sapxP+JlZ2AjFc4rpMlIpCEJxBRMzzA7TLWReeptUpHY+iSrzomBJd007bMk0YNh8j7GXk5mBrFMp2L/6XxyP216k8manncLepXNyv1dv1AI1mrdHUFglWApIj8z24uTJk5X1NtMUO8N28t13343o6Gj1TnV+r7Ltyfa0bmsuX74cP/74I2688cYiiyh8pzMT0cGDB13mMxEEj8d3O9eR9q0gCBWZUrFE0WaHjH2SmJiIvXv3onXr1ioVG+OisCKg+KBdespzQ5uK/a+//qoC5M6fP99lGc0u2bEQBEHwllY5VfBLck/8ErofH1baFfAL1wKR+Np6AeoZrg13Z5j285lnnlGNajaex4wZkzsqqoWT119/XVmqEGZ2YJpQNrYFQRCKCgWUI/fEI7t2lsv8nOrZatnRu/fDyHZtQ1b/sRYiVkb6fKyNv32BuMWzc61Q/MHmP77DnsWzcd6451G9UctC12dcljfffDOPlQrTyXft2hUvvfSSyzK+k7mMbVHCLD7FhZYvbNc6DwyyzT5u3DiVTej7779X73hJcSwIQkWm1EQUvnAZUJYTG918wTNGCtNh0r2H7jt8Abur6uUNlp1WNDwnMW0XBKG4hMOK5jkRqBnsGuAwkMdrbVRDhJG/NSCtBfl+c0+nSbRQTEFcvwNpeVie3+vC2QvbLkxpy9F9d/hMt2zZ0itxkG0fDq4wLW5RxUSO9LPTqtPteoLtD1r98vdXHKqgDuqiG5KwExlwCKP+xAIraqA1ahitc2OY8PzoLnPq6EGXtMY5VXOQU8MhmtjD7MhsmImcWq4iisZdXGGolMzGGQhKcrzPjEwLQg6EwjAdx6RAkrhrMyLrN0ZQqKv1XVpSgk9xWbyBqZWzUk8qK5eCnrfdu3crFxkONtKCxPn9yfYlUxrXrFkzT4wVfuZ7V797+a4uLnym+Jy7D4zSLZ/757IGDYqfXlsQBKEsU6oiyoEDB5Q1Ru3atREXF4dFixapSoDWKIxKHhUVpaxSyjM8F44C0MTRPRXehg0bMGjQoFIrmyAIgj8YOnQoBgwY4HEZRyWZEvShhx5SFiranYdCiiCUN+iee88992Dp0rxBVilU/PnnnypzSmGsWLFCBSplnIuHH364SGVhm4JxJ+bOnZvvOowrN2/ePPW3OHQwrkEbYwR+tl+N7ZgOfxOKSFxh+RYxaAUrzgg+6375FHFLZsOWfUYMST0nGcduPJT73Qz2IaC1ARwfnoATlyQ4jhsXjrr/1whGpsOVZtPvX2HHnCm48NlPvbIMKannjRYkjGXCNrIvMKYgrUa0aw0tBt9///0AlVYQBOHsodREFDaiWamzEaBdeBhYVi+j6s4GCZVtxkrhOvzsnl6uvFiieIrpIpYpgiCUN9gh4/t5+PDhiImJUfM4+pjfCKceAedfWhoKQnmHgz+s0y+//HIXMZD1PcUVuihzmXMdz7YOBRYdR4JWKLTS4gh+UeHxBg4cmEcgWbVqFVavXo0hQ4agQ4cOeWJoFAWrEQyLaVUWI4EiGOEuWXlIrTZd1XnuW/EP0oKOI7VrCtLbpsIMLUYmsOAzuXtyorORMuA4QuPCEL45AjVadlTiSWjEGXef5P17cHjTSiTv341AYLfbsG/5XKQmHETDc/rDGhKa53lj3Ck+T762gdmedr7/gYgvuHLlSiUK0pqccVHoqsnnjuI6jy8IglARKRURhYo4X+SMg8KGNxvirCQ5nxYpVNz//fffXDNwmrvSjLFhw4YuJqliDi4IglCy7+7vvvsOP//8s/K/1yKKIJwNOAfKpEXAG2+84WIty44uRQ3GqLjwwgvziChvv/22atv4C7o833vvvXnmM1PLf//9pywYLrroIpQP8rr3sY3XfMDlaNijPxK2r0dK+BEcu/lg8QQUN3JisnHspkOoOjcKYZsro0mfi9Fi4AiXdY5uW4tln/0fAoVpy1EWMFXrNkLdjufmEVEKSlFcFoK3MiYWLao0//vf/5SVNZ89EVEEQaiolLiIol/4fPlzVNI98JROd0xXHo7QcMSTvsdUuNlYYawUii9cztEXeUELgnA2Msioh4bWGvjEvgXLzaN+338YrPifpTM6GtURGsDRZ0EoL0yaNAlz5szBlVdeqWI++GJZxbbO448/jptuukl9X7NmDT744AOULwz0styHJuYAzDdfQBqO+WWv5xh3IRbnIwK1/bK/igQHHClKcIDxiSeeyA3mOnr0aCXYMWA3LY88pT4uKS677DKVIUgHEn/hhRdKrSyCIAgV2hKF8VAopmgBhGIJ53HiZy6jiSytVGiNwkqDgdNooUKBhRPXYywVIkKKIAhnG62NKPQwqmI29mM5/C+ihMCCSy2x6GBUd5nPdzPFbG/fu7Qe5PrFDWwpCKUNXRYopDCFd+/evX3aliKKs1VIZGSk30UUtpXYZqJFDNtR/MzONcUef7STOPjVBP1RE+2w2vwcNjjilOQgEzZker8fFfWk0mnrEwNNjQEq3kpBMIAsJw8GK37BDDJhD7cDQaVv2eH+3NAti4FjX3vttdwsOwwu261bN+VeuWzZMhU7pbTo1KmTmgjd1T777DP1vtfpmCX+lSAIFZFSEVGY1pgv102bNqmKnlYlDDJLP+KEhARVGXCUh7FQbr75ZhUPpUaNGqqBwEw+CxcuzBVUuExMygVBEAIPO1EcTb/zzjtVCktvYMdxwYIFqF+/fsDLJwhnM8uXL1fuPezIclCKAWt1OnGmpfUX4YjCaMtPuSLKGvNLLDXf9Xr7WmiP4ZbPEHQ6gGwkYgtcn+IG0xgnGAeU2BEIUrucRGbsbqTWyD/TUWnCNvEff/yRm6CAYh7frY899pi65zfccAPKAmyrT548WVla0VLm1ltvxV133VXaxRIEQagYIgqFEJr8UTRhRc/vFFZ0ykC69GjhhCaCFFkolDC4FkdVKKZQfOFoS3GCsgmCIJQUfGftwUmkIgctEIlQwz8uMo2MCLQ3q2M7ktV4sD9oiAg0NCJUemNPjXlf0lfyXc5JEMo7FAIZMJMiBTuJhO0TtlM4EMTJU+rjkhQ5aXHCjCwM1L9r1y41KKVdQPwFg8wyHbGmttkJddDZZZ0snEIidqIyaqAqXAPf1jY6ojY6IMjwMkiqxURW3UxknxZtAoG9ig1ZVWywGWfeoUw7nHJoL1KPnckEFEiYgej43u2oXLMuImrUzZPGuF27drnfmZGJ1trNmzfPTS1cEnUYnym2xRmr0JN1oU6pTRf89evXq/hAgiAIFZFSEVFobcJYJ4sXL1YiSuPGjVXQWKYFZH55xj5hQDY2BjjpioQvZ1YkXEYTR353j6kiCIJQFuH46VO2VVhqHsHcoGFogqp+2e+zli64y9IGA3KmYwf8M4r6uKUjrrc0R3jpJXAThDIHA7XSOpYxUZiRhIwYMQJfffUVPvzwQ5U6loNCTZo0KZXy9ejRQ7l3EFossJxbtmwJ+HE7GtegrXGFy7x9WIzv7cPR3hiNgcaLLsuY4cc5jXFZ5eThePz9wlhkppaMdQrFmrkv3Y3YXhfivLsLjisybtw43H777ao9zPZ0ScBnitZNW7duxT///KPEOkEQhLOVUmkhc6SGvrr0oaSSzdEdWp3Q3JQjlvTfparurMI7+/dyGX0s6VMsvpaCIJQ10swc/GHuxUlku4goW80TSEQmfrLvRg23VJ4DjHpobFTx6Th8R4YhCNXNUIyyNMFhM13N34zjWOpDsNkYhGKY0RBBcMRNYByUCMP/qTAFoTzDQRwO7DDziBZKOOgzceJE1S6haDFz5sxSKx/LUKWK4x3CAaphw4YpS4Vp06ap8rLcgYghZzVC8ogiUWYTdDFuRix6I9TH91pZIaRyFcT2HIikvdtxdIvD8iiQBIdXRoNuF6g0y+4kJycrdx5aGPXv3189i7zffN4YdHbkyJEq6YK/slayrc3j0Qqcmaa4X059+/ZV4slvv/3m8ZliimM+b7TWouDILG6CIAgVkVIRUY4fP66ElMsvv1w1QDzFNPFUEXA7uv3oQIVMMShBZQVBKGukIAtP2FYq9x1PPGl3jGJr+Lb72TrQZxFFU9kIxguWbrnfP7Bv8klEiTWq4EPreah0ukqQ9PGC4BlawDIOhYbpvq+66iq8+eabeOqpp3JTHJc2bBvdd999ysWoZ8+eyhWEZSupNlOM0QKX4GOUZyrH1MY5tz6Bnf/8ViIiSni1GJwz5jGERFTN8w5mHMD7778f/fr1UyIKoTv7q6++qp63JUuWqDiCdLXxBwxgS6uTLl26YMCAAcrqmxPLsH//fvTq1Qvt27fP80zRVf/RRx9VLj1MfSzW4oIgVFRKRUTp2LGjCnbG7DpU071ttFNwoZWKzvSglXFBEITSZoZ9H6ba49TndOQgAd43Zmml8ol9M2bZ49X35kYkHrS0R7DhfYfH+V3Y31IPE4zzXZbvMU/idft6nGfUwrUW16CwMQgDx5LlfSoIvv3WunfvjgkTJihXmpKElgAzZsxQQgkztXiitH/PxT0+LZBXmxMQh4U4hZKJS7LW/BqH7GtxvvEoqhkN8z2HpPRsTN+WgGy7Pd99Na1eCX1io3y+DgWtv3r1atx222251kY7duzItT4qCXTZeG82btyIO+64w6W8tBjngKf7+oIgCBWNUhFRYmNj1QuYCrW3L1iup9MbSzYeQRDKCjmmHemwYYWZgInmtiLvZ655MPdzL9TErWiJCDO4SAFo2xpRanJmlT0BE7AVnYxo3GppVeRyCsLZDNsujHvCv0zfSpcGTgx0TwtbDgxxvr86j87H07HiyIYNG5QVzKWXXqoC2zov09vRKoGdWpaHy8sj+7AUm81fkYO0EjnefqxEorkD3Q0KFQ3zXS81KweL9x1Hls2OYDfrHhMmsmwmsm2mElH8Ae8t27+MKfjTTz+5LKMrvLfPG59PbwLRcn8ctPT03Ohlhw4dUs+gp+Xl9XkTBEEo0yKKuOAIglBRWG0ew932xThg+q+Rv95MUoFiGdz1IWsHv+yztVENfwUNRTS8zIghCEIemO2GQT052s6AsnShIB988IHq3D700EPKdUbP90cwzwcffFBlO+HxGD+O3HLLLRgyZAjeffddFdT266+/Vi7OGp3imEFAP/74YzV4VR5dK/oZz6KzcSOm2m/GCTgs/QIJLVAYJDcazb1av0OtKri8jWv66KOpWZi4er9fy8XYgYw14ikjJYURPm8UzgqDwWgvu+yyQlPU01J86tSpSoBzb7PzOeMy/hbygxbj5fF5EwRBKLMiipj2CYJQkWDw2LVmInKUU45/YBrkdUhCf6T6bZ+Mm9IJ0X7bnyCcjbCjShcKihq0BmGAe7Ju3To1Mehmfu41RT3ezp071TGdUxXzOOzMHj16VB2X6WTdRZS1a9di7969KushO+HlDbYXo9AIYWZVBME1EHegiERDlYLZGcYoqdawOdKSjiDrlGumnsohVjSMDHNp21otdDX34aCGgSo16yOybiMY+cSsYRIFptcuCG9SWderV09NhUGXecY8yW+Zc7plQRCEsxHJXykIgiAIguADDK7J7De68+yvgJ5FgUIKA/W7WwzQlYeuHkLxqN+1D+q074EVE1/BrvnT/H45rUHB6HnH06jRogOCwsQNRhAEoTwgIoogCEIR0xjPMPdhxcGdsM9ZyqHfvCvVjgQGtObQZME7oxn2gu3AkRTgonZAVUdDerN5Al/bt6OPUcerzD3sTP31118eTb41rVq1Utk6BEHwHboo0I3GkzsE40w4W4MUBK0BmBKZv8eC0CmVGZCfrhXOUMBh+lmmvc2PqKioPNsJvoscnHanZGPR3uO5gWVtdhPZtbNw8oITLuunHsoGFpvIrpV3WcYJYNcsoHpwCFpE69g5hhJPgsO9v08rV67Epk2bXObR+ki72PA5pchHiyVBEATB/4iIIgiCUAROIAsP25Zj78aVwO1fATkeRJS+LYELWnohogD4aB6wcDuw4PFcEWW2uR+zbfvxk7W/VyLKrl27VOaGgkbFx44dKyKKIBQjxfGTTz5Z7OtHV4m333670Mwq7Aw/8sgj+S5jDBahZKCA8rlbrJOMlmk4cleaSlOvSdoM2D8GMlrkXZawBfj6baBTlUglohQVxt9hWu38oMtN8+bNRUQRBEEIECKiCIIgFBGXKCiD2gKXdHJdITUDeOgnYEAb4LLOrst2HAE++IeRIx07WrvPu+N4wQUXXIBRo0a5zIuLi1OdNkE4W7BlZ2HzH9/CnpONtsNvQlBoWLmM7VbQ8c6GOHPBqIT+xrM4iP+wxHwbdhQe+8NXGuJcdDSuQ6xxXoHrWUOAHg8AkacT90S3OL3AAGyZwLJ3gNQjwAUvADHayMjpFkXUAQa+DsQEpyOh5kG0N0ahiXUgqtQqPE5JnrJYrSrFtbaKoiUK46IwAO2iRYt83p8gCILgPSKiCIIgFAW64KRnATk2oFIIcE5j4I6+ruvM3wo8/RsQEZZXRKHrzg/LgGyb43tmDhDlH7N7Bv2jxYkzy5cvx/vvv++X/QtCWcO022HLznRRHHOyMhC39C/YsjLRfOAVjt+sxgCswaH5BvIUyg5BRhjaG1ch0tYIC9PeR7aZV0ThbbSGqRithZLDx8QGBHH907e/htEa3Y07PYpSdI9kCmvTko3QSKDNlUCtDkBOhuORyj6dmC0nHdgyBchJA659GAj3EMc7PArodDM/ZSEFSahiNEMjYwiCipA1jSIKM+2cf/756jsFFFoh7tmzR0QUQRCEACMiiiAIQlFISgVu/gyoagOm3w/Ui/Jt+44NgFkPODp9bIn/byqw8YDcC0EoAieP7MeSj59DTkZ67jzTtCPlQJz6O/elcTAsZ1KuWkNC0Ov2p1GtYcGpXoWyw7HNwA9jgYzMvMtqtAaGfgQEFRKXla/aJa8BcfOAiz8FqnuRyXjGjBl44YUXUP/qOFw93bHN8d3A9DuALKcEaqYdSNzq+PvTpUDzi4E+zxa876Xme9hs/opLLB+jNjxnwxEEQRDKHiKiCIIg+JhyNB6p2JOViOz1+4BmEUCXWCD4TAfNK6qEAV0bOT7bTSCqcr6rHjBTsc08gUao4uJf7054eDhat26N2rVr+1YWQSiHpCUlICvVkXI25eBeJO7a5CKiOJO0Z6vLd2twCI7v25lruhBcKQKVqtc8K9xjivPuY1aikydPelzONMpVq1YtdD/MGsTUywx668u7ioLF4TWAGQZEuG2Wfhw4ttUxny4zzmSnA8l7HeIGObIWOPyfw4KEqZOrIRZVkH8A1oSEBKxatQo1bwXqdDmzz0P/AVmnMx7zuGFRQGSsw9LlyHogpk3h55SMfUjFUWThFHyBAYz5rpegwYIgCKWDiCiCIAg+wHb4o7blmJmzEafADltEwK/f0/bV+NC+GbODhqAhwgt04/nnn39UUEFBqOhs/O2L3JSzdOfJT0DJL14KLVcsVof4GdtrEHrd+UzAylpRRJTHH39cWWa4Q/Hp66+/xiWXXFLoftavX6/cUMaMGYOXXnrJ53K0GgEMeMV13tENwI+XAu2uBga+5roscZvDMkS73fCv9bT3TDSa43rLdISjerEEtJ4PAR1vOn28rcCkYQgod999twoiXlhgYkEQBCEwiIgSYNLT07F7924cO3ZMjeA4s2/fPuXDKghC+YHN7G5GDWRVaoTZl3ZDGv3zf14JWE43wM9vAURHAHM2AaviHFYmxaSzEY22RhQqI7jA9ZhitVq1ai7zmPKSaY858jty5Eh079692OURhNLk5OF4JGxfj+N7tyMr1bNVhDfkZKSdybYVvwt7Fs5AdNO2iKx32kKsDHLgwAH8+++/StBwh+ls+/btq9IiFwS3nT9/Po4fP47BgwejcuX8reDcOXXqlIq7wbTLERGuAvL27dsxZcoUtcy5c8/jMdAp2zx6vcTERGWR4g2MR8J32Jo1a1R8klqhLdAjqhuWLF2CfQfi0GQgEBwOZCafEUqcYRyTJoMcgV951Q4sAzKPBaGFcSFaGp1RCTUQbOQNOszrM2fOHGxPWK7EmepN8+67WmOgXk9HjBTGO1HHozGOD3qMHTbsNGcjDcfQDIMQZBQeH4UWKO5WKGxjUkQPDQ1V73pv020LgiAIviMiSoBJTk5WkdKXLVum/gqCUL6xGAYesrTHNdFN0eutNOybuxK45F1HimMKKT+PBXo0Bh7+GYg75pdj3mNpi1FGE/U528fMFKmpqXjsscdUh4cNbDH/Fso7hzetwpKPCgk24SMJ29aq6ZxbHi/TIsp///2H66+/XmVicWfIkCEqyGhhIgq3feONN7B27VosXbrUJxGFREZGqkxfjRs3dhFK2HF/9dVXsWTJkjwWEu+99x4mT56MoqDfYVu2bFHfmxkXYqTlfUz79HpM/yMONy0oePtqjYCLJ5z5/setwJ6p4bjQ8jI6GB3y3Y6iz6233oomV5zE8G88r9OwN3DJFygWzDY0zxyPGLMlGlrOLVKQWUKRidYpzz//PD755BN51wuCIAQQEVECDBsSF154Idq3b4+BAwfmGVF65513Al0EQRD8jDL7Nk8PNbaoBbw5+ozFyfLdwIJtwF39HCLKp/P9d0wfYKfmm2++UZ0ums03aNBAuflIzAdBKP8MHToUF110UR6x4cEHH1TzudyZzZs349NPP1UCCt8NmzZt8ul4tMj4448/0LNnT1x66aWIjo7Gjh078NFHH8HGNO0A1q1bl+/2fAf16dNHfaZ17gcffODT8Z0tbxYsWIB7770XK1euUhlxFr0C2HMAWxYQa/TGMGMU1prf4gg24FzjflQxXOOdrDW+xx5sVp8Lex86H5erMt7JivcdcVWYnefASmD2/a7bpCc5MvUcWuVY1mYk0NCRQCcgMGbLW2+9pe4tRSzeI3nPC4IgBBYRUQIMR3i6devmcRkbHGyACIJQjmlQHRjbz/GZo8PXTABW7QH+ftghokwoZJg0ANDkna6Cf//9t5pogcIghIJQ7tMY52TDnhM4N1h7Tg5ysjJhDQr2Of0xO9x0n+NfulT4syPLDjL3zd92WFgYevfujXvuucdlnZkzZ+Kpp55C9erV84godPWYOHFiruDBffkS1HX16tVK+Pj1118xfPhwNY+WLF988UWuWzL3SXHFHV4HWslo6Nrz8ccfe31sbs/rSRGYx9iwYYOagoODEWwNw+YfM3PFjlpojx7G3diXtRKHbdvRPvwa1LacyXrD9WpgDWUlr47LYN3BIUwH5DhHezaw7TeHiMLHIzkOWDvx9L4Za+d05iBrCJC8z7GsRpvAiCj6eTt69Ci+/fZb9OrVC08++WShlkgVEV4LLRA6T7yHnOjqSgr6TToLZvydue+D11V/DqRIxfNwPhddbp6D83G5TP+e+Znl02WsCOhz1+fpyYVRn6ur2Fly98oTuiy8hyy3LktJ3Rv93Ohrpp8bfx3bed+m03Xncbx593j7fJcHREQRBEHwF6wAxg8HTmUAtSP95s7jK+zocGTyuuuuUyO2sbGxpVIOQfB3LJSln72AU0cPBuzCbp35A+JXzkeP255AVEMv8t86QTHhvvvuU/E+PvvsM5V9xl8cOXIEt99+u4pzwfggvv6mzznnHCWo6s7mI488ouIkFYdOnTqpsujGMDvwtHgJhEXvV199pTLkMKAqY6SQJ554QolJd9xxB/bs2eOyzeJXgb8WAld9CtT2EMvEG5o2bYo///wTcVG/Y4PhCIDLFMpDPwayPSTToZXKzLsdQgrTLYdEnImbEgjY0efzRqvmL7/8UsXEKW+dEH/BjFFbt25VYiGfBVrnMCYh3VcbNWqkXOAowmkxJT/4HDPmD583/ua4Xw6GMtZYx44d0bBhQ/Xbo6gXKOLj45VoyXNJSkpSv9datWrhlltuUQKqhh3ZuXPnqnNlrKJmzZphwIABqEjwvE6cOKF+h4xRxM+EzznvCe+pfqfxvcDrQ+Gza9eu6vfAiWJrabBy5Uplwcf7QsGa72BfXSd9hdciJSVFTT/99JP6zmDfFNZr1Kjhl/cD983zOnbsGA4ePKh+U/w9sL1Zr149r55vunzy98V7yu1jYmJw4403ljsXRBFRBEEQivTyNNDUqAozNVNVCqheGahRBWhZG8ixAfuSgMRUoHktx/wiEIUQ1EI4quJMth028GgOX6dOHRWbwBk2GunHz4mVExt8EkhWqCjkZKbj2I6NLgFh/Q0FmvTjichOT/O6QcmGJKFVADv6jIXGDq4/4b7ZserSpYty17CezirkLexwcDvd+aLA44uIwkZ4y5Yt1bmxs0rY4O3Ro4fq6NEawrmzkpOZgdRjhxESURXhkdVRHNjIpmDDDkCrVq3UO5DwHchysZPCThTfe+xkbdu2DVmHKyMiuTkstqJ3dkMrWdGkezWkm5Ww4fSAq8UK1Dpj2JLLqcNA6hEg6rRgU6/H6QCzPmBDFhKxEzlmJqqgjrqmPB+6Yrp3LriMnRD+5bPBTiPFJn1tSgvHKLUjnXROjvMoNUfiHdcvEEIPj8vfHDvSDFjMZ4GdPHZa+WxQDGFcsMJEFF5Lrrtr1y4lYrATTwGDnXWKpNpCJZDw98nzYB1+6NAh5abH++oeB0l3mPn74++S5axoaGsOtm34W2DbR1tVUBzTsZe4Dq8RrxWXUTDgPL4f+J3vy5IWGFkW3j9a5/HZ8xTHKhDwOHxW+X7gZ14Xf9ZHWrBKSUlR58fv/F15++7R94rPLbfnd/5mtVVVeUJEFEEQhCIQgzBMsQ7EvLX/YvSo+5Fz1wXAk6fzWialAVd94rBGmfUAUDVv5gdvuMrSFC9YuiHCKSsPgyteeeWVuOmmm/Dyyy+7rL9x40aVOpTLFy9enCd7hiAI/oWucgw+qjtWbFiycV/R4Ej+5ZdfjnHjxuGBBx5Q82gF8ssvv+D777/H+PHjVYdTC7tJcVsx/7UH0fzCK9D5qnF+KUObNm3UyDvh9X700UdVDJBJkyapYzNWy9SpU5V1DOe/+OKLqFrVRyXDCQoa39qHIQ2Jha677C1g00/A8K+B2p3OWKH4wgnsxbf2IWhjjMBwY4IKxksLE1oWUqxyhq5VEyZMUBYTHOHmdS8LnRD2E5OT7Eg9ZeLYEUd52HeNqW1F5QgDkVEW+Kj/eQU703Sdp9jGDiQDH7OTxo7s4cOHVXIHim1t27YtcD/spFOAoTjFbWnVwOvL558dRXbGfRUwfYWWLrSgYKBgxh1i8GdP0HWC7xree3ZC69evj4oG7yvbMXfeeacSb5lGnedNUevqq69G8+bNXcQWXrMVK1YoqzvOoyUuxVaKKiUNrU84iMXBLFpalJRFDK1x+EzQcorvSR7bnxYw3PcVV1yhfiu0KOFfWl/68nxfddVValCAlou+xucqS4iIIgiCUMQsPVEIRdVsC5CUCqzZC/yyyrEwOQ04cAKIrOSwUAkp2qs2DFZEu6XeZEOBI1TO6UE5esbOBSslmvZyJJaNiPzgiAwbhhWxsycIJQnda7QJPX+bTD8cCGiJQLNsNpB1lht2JpiNh0IBf/9s0AZqlJydSZpss1OgR3TZMaFosW/zWjQNt3ElRFYNw7H1i3EqOw0ZKceRtHsL9iye7bKvwxs2qfg2vsJOiI65wvPs3Lmz+ksTcnaUWS52JGmVwc4VR6GLQyiqoLFxARLMzTiA0+92N07EAQeZ4T4IaHQBULUBEOaaZd5rglEZjdAHNdFOfWcnnkKAjjlDaPXITjUDhtPSguKAdnHQcXM07Gjy2eDz6ewG4m8cj5yJ48cc4smBvTlISzWRfNzuyPRsACeS7KhU2UC92CBUijAQFc3YCbQo8E8ZdMeaQgf/8nx1HB0+N+zo0RqL18hTfAj9u2H9yWusLVh47bl9oN0wnNFCjS5/fhYUnM/fA3+bvO/+dB8sCzjfJ77/eE95n/X14Xnr+6JdevhOomhBSyJaFPF+cr2SFFF0mfm8UbjjPaIYFGjxTaPda5o0aaKuC68dnyN/wXvAexEWFqb262sMJn3vCnu+ywMiogiCIPiDaWsdUynAUVhm5dBm9rNmzVJTQXBER0QUQSgeDObJidDEmdn42KH3NxxNZNpaxgagRQgFGzaWp0+froJGjx07VsXGCCRsLD/88MO53+fNm6cCxg5sFIm7zmmQO3/b92/mft6/eoGanNmRmAa7rXjm5Wx4Mz6KRl/zQYMG4cMPP4Q/iERDjDC+whp8gQPmrR7X2bsA+GMMMOQDoN+LxTteVdTFZZaJCIfDBcETFE04iqs7/c8991yB+2RHiuJaIEUUwuLs2pqDA/tsWL8yE1mnA+xqeDohoUCnHqGo08CKzj3Z+QpcedhBowUDrQH4W6F1Aju15557br6uHbym7Hwz6QOtF9j53blzJ8oqPAfnNON63tkK308UUSka0K2S7iy8n7wmFDNK+tromCwliQ7QyknXS87LBP8iIoogCEIxaNGiBV5//XXMscVjhj3edWH9KMDqRUuRddsNvYD+rYGYCDRGFdxpaY0eRs08q7KRwAwcHG3VsNHw2GOPqVFLb8kva5hQPqCl0YwZMzwu69+/Py6++GKvxDe6DHC0mubShcUL8AZaSL3//vuqE3PXXXf5ZQTMlp2FrTMmKRcRe/aZkfZAwQ7+lunf48imVWg97BoEhYbnu65zwzSQjVS9b7oj8H2jO9Hz589XQf4YYJSm/59//nnAyqDLkZ2eqq7PiS0bcWXrGmgY6VsmophKwRjVrjbqndiBlV+9jqZ9L0H1xq0K3Y4xXJjRkFZ0NCfnMRkrgc8b333PP/98buwUf0B/fe7b1mE1Qq50CAGak4eAVR8AhhUY+DpQ/1zX5cVBl5+umewkO3eUaaL/xhtveNxOW05oaEFB6wQdNyJQ0OLkRJINcTtzcHi/DZ7CL/BxZVKtvTtzkJlhomYdq3Lt4RQo+D5r166deifFxcWpTjUHGhhjhoKKyzkkJyurBW5DAcXb9xatHfjscf/8q60n+PukcEUhh/ePlhDO2Uu05QQ7+RQAKYDSmoTHZX3O8tHCKL8YLAyeq7djfAluy0DITCNO0YjPAS2W6GbBc+P+WA6eO8vCa0LXQ4oNPAd+ZluGVhy07GI5uB1dmyjcEZ4XBVueE62kdEwMrsv3Pd9NfN5oHUIrKWbQ4nFYPh6f9QzbHdoywp/vS+csPc6xR3TGIsJy8H3BZ4D3SlttUVTjOrw/jPukY5jo7XgeDBKr44rw+eByWiHS7Yuxcyig87hcxv3oOC68Tjx3/gbpksd98pry3vF9prPc8NpQKD/vvPNys9TQ1YXXl9twOS3vWFauv379emUxxeusLZJ4bIpF3I5xunj/eF/oBsl7zvvK54XPOV2/WTbC+R06dFDnwf3R0pnnwnPkPhmHip9pPeIt8fHx6pqxjcHrQBcg3ne68tBC0BvXM54nt+fE8vL+8bnW95TXiWVq37692jc/l7RQJCKKIAhnDTYGn4MdVhgIMvzTeGOj4/7770eWbR3+tp8x+c6CD+bqHD0Y1gkWh/EzGhlVcJ+lHULZQneDI2tjxoxxMS9mY40xUoSzB46s0u/fU1pBdp5oEaF9+J1hQ1DHTmAjnSlq2VC67bbbiiyicH+6gcmGNeM0sNHHbDL+EFGY0njPktk4vmdrsS0YvMG027Bv2d84Eb8LLQaNLFBEKWloWaBjkvCas6PNTgHdiNiw5v0MFCoLD4NenkrB9r+nIjXhIC5s6rvLTFR4MAY1iwFOxmPzH98iukkbRNZvAgvTSrulcOU5skHPZ1qLGszioEVC/bzxfUhBKde8X0U3NdlDKnLDmp0Nxh5pOvIULr5Sl8mR5vjUQWDlR0CLS4GL/3cmO48n6OrDgKq+csEFF6jJGXZ0aXXoCXYwnIM7slPhD2G0ME6l2HEo3oaD+3KQcDj/eo+35PABG2w2E0cO8N2EgIoofPexU8n3HDvM7CBStGBH3z0oO58jdmr5nLFzzE4xt8nv2dEZqdjBY+eT7lXcXl9vLmPHmR1GdvD4PnR+F/OZ5rPNbRgTgr9ddjbZWWX52LHldrrT7A5/C+wsM804z4/l6Nu3b66IwvKzTDxfdmgpntAKh78Pdqh1YE9aKbFDz3MYOHCgqkvYmed58JrQEmfatGm5dQYtz7icHW0KCOzc8jljWdlh53G4nMdcuHBhbtBbWmSwnqGbnXa9ClRaYS086YCyun7k9WW5KYrwuuvfirbc4MTz4DPg3CGnKxgHLLg9oVjEa0jBhcI1LZd4jrxGFCzYHmMZeCy+QygYsN1GoYL75rXhdaM4xfvEsnIdPqs6aDiPzWvP9fid144Cqj4X3le6b2/fvl2ty/cCy8Xj8LlgmSjW6GDK2u2R5eF+GTeKn1lmijMUYfgMUpzjdiw/n13uUz8P3ogo5un7QMGS72M+I7w2PD8eQ7c/ChNR9O9Lu2QtX75ciT68XvqeandFPltcl+XT972kEBFFEISzhhXmUTxuX4GbLS1wk9HSr/u+2tIUvU5bjiQhE2Nti3AIjkrXG561dEFfo476XNUIQTACaOssVAjYWODoOwN8OrNgwQIlorzwwguqYe0M42lodwd2ujgyxQZacfj999+VoEN0x4CjQ/7CGhKGXnc8jaS4bVg+4SXYsgKbgYSd+XPGPIboZm0RHF5ysRB8hY3JV155RY32sqEbeEz89+OHOLxxBdJP+C99+7rJn2H3whnodcdTqBzj+iy+9NJLqgFNCxTn542dC+fnjZ2X3FJyNHrxPzD37YF12BVAlCOOij/IyQBm3wscXgtkpwG75wDfDyp4mx73A60uR4WFAWS3bshG6knv4vGknTKxbUM2gkMYIyWwvw92HClKUHxkp5liIztwfOc5i88cuWenn+9Sdnb5zLHzlx/szLEzTBGDVoG0MqCgyQw57CizM8/OKkfj+T7mesOHD8+N6UPRgh1dzuc7mKIgt+XvmO9ldhjZyWZ8M352F33YudWj+lqw0PD4PPfRo0er4zDdunt2J3Y+2dmn0M1znThxYp5rxw456w+KBbNnz1aCC0UDCiO8TswUxnOmCMRzZTB7bkehhNecgV/5+6QYRWs5Cj+8/rSIYSwnf6LjAVFU4DXnvaOAwPcCz4MiEy1z2LHnwBevH0UJXgPWoxQOKEzwXnFiOmneK15LWodQ4OC2FBkojlAI4LNFSydafvIdRKsfPke8J4MHD1ZiBo/pLJ6xTLTG0UIey8rtRo0ape6nttDh/vlcMJEAt9cZdrTAQlcdlolBtSlwMPAxLV64z6FDhyox5uOPP86TMYf3huXmxDJ/9913SvDgveX+eE+5fwpzvGc8nylTpijxzNn6uTDCwsLU80yXcYobjKXF68Lnzpv04Px9UbRizC0+N/z9cn+0iuHvlu94/n4osHz77bfqvHgNeb9KQjjWiIgiCEKFJNHMUGKGMxtxHIvMw+hkRuM807WBVAlBqItKRVaxGxgRaiLHzAy0NKqhsukajf0Q0pABG+qjsotIwiN2M2rgfEvxOrNCxYcdZjZs2Ghko4eNE/cGKRtEixYt8hgxX2erIGyo+SOjB8vkvE9/p/e1WK2IbtLaYSofyEAKpzEMC6IatURM04IzeZQGOm0mG6Sc2Ihnp4udJTZ8adJf3ICqnp43NtCjq1dH8v5dOLZjA/xJyoE9yExOQk5mXlMOWtmwM8kGNRvmPD8+a3y+dYDvelUjUL9yOIwTSTBPp782D+6HGR8H89gRR8oYJ2pWi1SN8sIa81zO4zWslYpoA0jFUWSbKUhLBDJTgGqNzqQ3LgiKLQVjoCrqoRpiYUHJBJ/0B9pAIiPdVBl5srO9E1G43onjdrVdoNHWOOxIs8PFZ4cdbD7XWlhgh42/K4566yCk3qRC5r74W+RfWnjorDrsyPE9SEsOfuZxOWkxhJ1ALqOFg+6Qs2PP7dlxZ9n47maHmZ89pcblfrRVCffrLAhpdweKRfzL59i5I8/3KMvFiYIGXZEKCh7KY9CqhddEW+hQ7GFZabWjXZpo4cHlnMd3EDvQWhCgmKBT2hYnYxbh/lgGbemhXXgoGNDygRZH2iVKB97l9eZ9olDC3zRFNL4DtHUFt+c6FIS4Xz4j2ipFnyvfRdw3J9ZxWiigFQivMcvC8+e6PHeeL++Rcx3La0gBhdvxflNo4Xq8ZjwOr7tO1a0nfmfZeH68jywTryGvLfdF4YX70u8znhufDx1w2BmKODwv/UzxeDrFMLfhfrgdy6SFRIotvMfayqSgNrLt9HPPctMSi+fF68G2irsLXUHwXLU7Ga8rhScKP7x3PD7LT/GHx+Hzy3tBoYzXW0QUQRCEYvKpfSvesbs29uliw6rjc/s2TLLvclnW36iL76z9EHTapaY4VEcoJlsHwoYzjUQTJsbYFmC5eRQ/Wwcolx1nqsK/5q1CxYQ+7AwsefPNN6uOpPsIZWFwdJBZXggb6sOGnU7LXQxGjBihAnoSNny8icciFA2O9t5www0qva9262DHgSPCerS0uJ0UZ2gyzueNgWv/9+STpXrbOHrMlNIcNX/iiSfUvIiQYHw9Ygja1q6JoO8nIEe/vinI2HJgm/oDewou+3niysvx8JP/KzSbCa8nR2OtoSZCLMAs8yGsDf8Ol3xOFzPvyx1SSEiSIIRguOVT1EcP5ntDeUOLKN5qp4yNwvUz0n3P0FQUeJ9pmUdxmR1hju6zo8WOGTtj7Dizk8iOLzuy7PwVlnGEHUVmxGJnj51oihEULbRYwb8UVGixwWDQtJCgGMkOL8tDKwNaZTDGCEfX6QbDziY7iDoTDTv5fJ+y418WYNnYkdWuJ+yw8jppQZLXldeRlisUhSikaBGF87gOO8WcXxy3C4rFvP4//PCDKoMWUXgcnbGnX79+qpwsB+s5vjcpWlGQoHUKBx+cXYq0GxLdZGltQisHHoPPiHs5eW95r/hM8ZwoavB68Pnhs+DJjdYdHovb0oKIzxDvMc+BzwPPj9ZFfA4oGvC68jlg+SkG8rni80NRiPfDOX5LUWBZeD14HymY6fOl5Ql/G5woUBR2z2ynM0fS2pXXgNee58Pr4mt6Z94DnrcWE2l54/y+ZjloMcbyMgU8xTm2jfic8TxKCrFEEQShQpBm5mC+eVBZepA15jEkwLPZfxpy1OTMNjMZv5lxsJgGEy8q15zahqsJrLdwdDQartkQWAHRXacmwtHQiEBNo+zEWRDKDxxZ0qNvHOXxFTbM9Ais9hkvLs771KbkQmDvP83AaepMODJKSxQ2rr0ZRS/K8Q5u34R9y+ci7bj/3HicseVk4+C6pcpNqFbrzjBOBxFhEFk+U+zY8i/Pr0OD+risVTO1vFJIMGKrVUVUaAiQ7giU6EJGXpfKKicSYRw7BBw7BHtYOIzYJrnHc4bX0Tk1apDJOAlAuP8MfU5jIAxRqGT4z+2oJGH/LSgEsNkZi6bw9RmOLDiEndGSiV3A54Yj/+y8s4PNjhlHr9kJoxUXR9rZCeUoPDuk3nTu2RnnfviXzwn34R7ngx1fCpzsJHP//MsRfwok/MxJx3VgGXVHmMfnZwoCxe0g+xstUji/53UwXB1UV1s7sNz6WlIw4MTr7Rz8uCjw2Nw/RRLdsdZCCufzXUFxQcfyYOeelhXaqofvSvf7rGOpaGsPWr7pGCjOcBvePy106Xetvh7aQqQwdPwVlpXXk+XjtjwPbdnJMvKZZHl5LfkscRu+53UgZA6i0MKjOHFAtGWLs8US/+oAwNpilZOnzFamaaplOngzfwu89hSAdKwcX+E1cE7vTncxXg9ndNwZHciZFlnFfbZ8RUQUQRAqBAlIx222hcplhvhqKLwWiRhlm6s+M/Dsb9ZBGGY09Fv5+KJ/xNJBlUsSzQmCUBx+/PFH/PTTT7nfPQWf9CcUUOanbi7Cm9U7cjLSsGLiy6jRqhMGPzsB1hBHY51Bu91HQAc3b4QBox3WVCjC+9S+cjHAidSuh6CbxgGhIvwVldAwA1UiLbDl2JHlhYgSFORYn9uVBOzEsTPKiRYHHOVnJ5WxLNhpprsYR90ZxNfbTEbsrLHDyL/sEDNmCGNpOKM79uzcsaPMv7QyYIeYI/vsBLKTSasGT8Izt6HwU5LuCQXB3yCvDzvuzr9Hlo+CgnYjYqfevcPLzjgn7Q5UHHQmm0svvVRZHhQGj8n7TSsZ3g/GsKFVkie4DsuuRRT39yrPT8cz0ddAd+K5zD32TH7oQLYU9+h+QwsdQosLCgO0mGLMFrprUpygqEBrJl5nWi7R8oLCAq1huI/iCG38ffA5cxY79LnwnukA37xvnlKlm6apltEyS1t2MSYaBWhfMvq43weeI+8df6O0OvL0G+HxeB1ZTv6mivts+UrZ+GUKgiAUI+POF+Y2rDaPIRlZxWri623phvOlfTvWmom4y9IGUYbvSron1EiNX/YknK3QbPjll19WDQamtSZs9I0bN041vujqkF8DsbwTHlUDna8ah6Pb1mLv0jkBOUaD7hegVpuuiKhxJj4RTbvZiKObkr8DIvoKG9AMJuspTgLNmHNTqDKw5bzfkH4iEa0uugohlau4vIfoDsZOYGF+6nzeGNw1bP96IH4tAo5bp0WPbqtFycdhX70M5oG9ytrPL5xMhn3eLBgNG8Fo3aHAEd22xghUQwOsMD/FSRzwy+Fb4VI0MvqgGvwn2JcU+lIxw06DxkHITM9GVmbhNXBYuKHWD2RmHmf0PaXlHjOR0Oyf1luM06FjVOgYI/zuS0wnbkMRhKm1PWUcYQdTj47zt6szt5QFdAYUXwRY55TBBa1TEhlSnN8N3sBOOIUCBl2li4kndCec1h7uYpGn83P/60vZed0pNPC50ZZMfDYomPD5ZFn5zFL8oxUKxT+Wi1YfOoYP635vrV8KKosnCxNnCnpOMk8HgaX1j45NwvqJrqUMysvyecoi6A06U9JFF13kUZBhmXh8Cj68VnR3KklERBEEoVxjh4mf7Lsw1zzot32yqphi7sFS8wiutzRHFPwjoghCcWHj7+GHH8arr76qOreEjQdmYuBo1rvvvpsnIn9FIbxaNNpccj2CK0UETESp06EnWg+9xmUefbNfe+01NWLIGAc6haanBrjzfAoZdrvN0eh2cxfRnStPYkhhosYjjzySuw82qJ33oTtoSkRZOAvJ8bvQuPcQWENdRxCvGDHCqyC9bMDzedswdSLWfF8CIkoBmCdTYF/6ryOohr9IPQX78gUwsjJhbd2hwFWbGxchFr2xzfxTBZlVZVI1kG/BmS04Ex+gmTEIPSzjUJ6hVUm9hkHYv8eGlBM2dx3MBfbTKKLUaWBFlWolO6RAsYNxdRgAlfEuGCyVlhU6q4m2IvBF5GDHju9fWrLQPcgZ/S7QHVC+B/iOoHjpaT1P+MPCrKDOMd8dvhxDuxrlt0+9vCy5IGl0WlwKaTrTjHtKdedrUdg5+gNagLBeYZYmCgasEyii0F2HZeUzS3GCz6TOjMRniKIF16OI5631lK/31FthJjs7WwkZPA/+lujmxokWXoyLwjgxRXHx5fEpvvD8mCVKx/oqyj0LFCKiCIIgCEI5g8E+GS+CaKsUNmCY/vWXX37BhAkTSruIFRI2GB966KHcFLvuHRLO13E0jmxZg3U/f4wWF16Jxr0vclmXo+FPPvkk7rjjDpWesijweNwH46N44vje7Qg3s2C89giqVXYyM7cY6HLNvajRomDRQMhLEMJxseVDZOKk+r7TnI2F5qteXypm4BlmeQ8hcHR8otG83F/m6JpWVK5iQUqyHZHVLdi9LdujzsU4KE1bBSsBpVnrYCWmlCS0OKHoQSFax0XhyD5HuX0dwWYHl9uyc6vjnuQHf+uMa0ELCHYIWQ4d44fvbp3txR0uY6e5OJYr7FTqWBfs6DpniuFnnamoIkPrCFp78Hpy4vnyfvG6uHe6KZjrbDm08uA9DiQsF5+DmTNnqueIgbNpYULxWgfupXBO6C5DFx6uw3c/Y464x+EpDSqftsZimmGeD0UfCpUM+Lp+/Xp1vQcOHOgSX6owKGpyPxwYotWNjiXkfr68jxRDdbBfToUFDPcnIqIIglBuYWV37MRxpNuOAKZbwMOoSkA1L/xTc2zAoWQg2ArUqnrGRpmLYMc+85RKR1wbDCqYf6OPvs4sT35wW1bMrHAEobhoH3/CAHOvv/666iBwxIYZVSoyweGVEFGzHjJSjqtYGv4gKDQcYZHVERzu6stP+Jtl9g2OhLHxykYb0z+yga1H2DJPnkBW2imkZuQgunoUUhMOISN+Fw5vXImY5h0Q07wdkjNykMXom6cb63S7Kmomo8xTKUhPOY7VK5djwb8LUC0smNqICzxeRIgVB7esRUa4U3YEw8CJ+F3qfNW5h4QhrJojM4g7OVkZyiWIxysJbNlZOHX0IMIioxBapVquVQ14/JMpedx9/EZWBsAUyZUqw3Cz2nHGYlhRD91yv6cjCVFmYxc3UjuycBKHEIxwVAI7DmeuazSaoRH6IszwLatWWYaxTUJCgRq1rWAfPSnBhswMk8mRcrEGOdarXc+KmrWtqFKV6cpLVkRhB0ynrGUcCcZcYEeaI+i+jubroMN0oeSkO+Y8hrZS0KlqaXnCziAtIHgcHlMHjaUoy7YDrQu4Pt8n2sKM+6TFTHHS0GsRhWWi9YKzFR3fZeywV3QRhfdcpzrmOVNI4XXV2ZCIzu7D2Cm8X3znl4RAwWeA957PE+8Ds9LwfrFs+r5xcIQT75vO1sTtuE5ZiJdjtVrVteKzTcsaih0UBllf6vIy+w+/cz1vrEW0MMN96xTPvB46Rgvh/eJvjm5OPCa3KWlXudK/+oIgCEXkk08+wbvvvYcTZqZqurrw6EXAvQML30nCSWDEh0DL2sBXtwBBZ17wx5CBy21z0M+ogx+s/QtMf/z111+rWBX5wYrj888/90tKWUFwhg2XKVOmqAZHWWhUBZr6XfuquCWrvn4TuxdM98s+63Y6Fz1v/x+Cw/OKnDo9qnNHiwEqp0+fnjvqtfanj7B51s/4cPk+pB47gr//bywqWR2Nva0zJ2Hb3F/x0fJ92Jnk6LCw8VccU/3tcyZj47RvcGz7BlQNDcL9vWIRGXbm3ttN4NOV8Thyiu9GN0wTq75+AxamVAFQq21X9Ln/FRjs6bqRuGszFrz1qBKISoLje3dg1jM3o8XAK9D5mnscM7MyYZvyHcyEIyptcSAwt21GTtwuWAddCqODw9TfG1pgKGIt57nMS8A2fG+/FE1xIS62fOBSa1gQhNDTVigVCfaL2nQMRvM2QWjdIRhpp+w4doSuTo5lMTUtyloluqYFwcEUUEqvrHTJo1sPBz3Y8aKo4qu7AUfKObrOlLgMpMlAoHQHYiBQ7RbEDjmXsRNJoYUdQB5Ppwru06ePWkZLMnYyWQaWhSPv7IRu27ZNWbYVx3WEAgKtA3iutGJg+SgYaFGFx6abSEWGAgRjc1Aw4n2i6wzvxyWXXJL7TmcnndecVkNMRU0rT96LQKMH1fg8UAxg2mumVaZ1FOsWPiu0kqLAQlGBghstUUaMGKGCt3oK9FqaGKdTdDPg77XXXqusZ/iM8TvFK/7uvEl3zEELni8HhHg/uB+6BTEYtBZhKHZRCF20aJGKB8Z4Zd4G9vUXFb+1JQhChYUv5aNHjwDnNAFi3EaQUzKA6euBcxoDNdwardsOAztO+yUnngL2JzmsUNzC0tpPCynHUXjEbzZ8+FJnY8jdNJiNF1beHJUSBH/Ahi+fKf28cVSUjUB27Dm6yQYiR1j9xe7du1WDnr7kbPB5y6mjB1THuHrjVqgc45+gb0GhYWqiO4ru3Genp+Lolv9g2r0btTUMi8oEowOu1mzVCWGRnq0x2FDlNeb587q3bt0arZo1gZEQh+xTjvdISHqyEjOCLAZMe46ykgkOdTSxaC1jS0tFlP0U6hgOs/9kSw6S+Xf/bsSv+ledS1jVws2QaRVybOcGbFq/Fsu2xiE61EBkrSqoHh6MiNPHI3bTRFABKWSzUh3uKCTl4F7sX/UvIus1QWT9xi7r0TInplk7JB/Yo6ZAExxWCdFN26KyU2Bfij5mWiqQHsARc/qf6MkHgo1wZXHiTLY9Aw0z+6OOtTsiQmqVuJ9+SeM4PcORtjgIqFbdolx1clMYG47gs5zHyRIACxS+89hJ5sQOMkUD1rcUIjiPv189ks2OM8VmWibwO8ULigoUNel2w/coXSs4is790tKP7gnsVOv0vewI0rKUYirdGGhNQPcgnQKX+6PLEMtBwYUdYj2fcB63Y9m4LcUUHo8dR46mU+Cg2MHtOJ9tnc2bN6v3PK1o2OnnvAMHDqh2B7fhsfiOYjm5f54vy8ky6vLw/CgisCw8Ny7XnVp20NmR5/Y8Po/Ndg07sbweXJ/XhtvyuDrNL5dzv9yG6/BcKBJzvzqVMwUlXkd+1uXk9dMClqffiI4bxevDcrEOopjAc+G95XFojcBrwnLkl56a++cy1lsUkfidZaDApYMJa+sUnVZY32PCdXn+vM68F9qFi+fAAQxtfaEHMFhGBoql9RHXZxn5nDG7Du833cl0DBId94P3nct4fbXljHY30gFxtajD68zyURxyFv9YLl4vlo3Xmuekrz2fdZaTf7kNLV5YRj5jPG+2UVlOnYmHZWH5+cwQihVsb/DasHw8r/j4eHVNuC6Po/fB82M59PH5mb8N7ldbRvGc+cywrLxeXEbrTD4TvE9cznvB34jObMXnjEHeuYznwLKx7Fxf/76LEnulOIiIIghC+cZqAZ69FOjXynX++GnA6I+B3+8BBrRxXfbTCuCl0yPY1E38ZCLOCuKJJ55QqfecoasFYxcIgr+YPHkynnnmGfV3+PDhah4b+iNHjsR9992HqVOn+jW4359//okHHngA3333Ha6++mqvt9u/ZhGWf/4Set/zf2ja90xaWn/Q8qLRaDl49BkLhqdvUmKKN1iCg9HthgeVQKAwCg9K98UXXyjrN6Yzbd+kPmY9dZNy41EU8g5hv3FEm1q539ccTFFWK7v+/QPzE1Zj4FMfo057R4ybgji2cxPmvfYApm48hD+3HsX958aibc2IYmX9Oh63DfNefxAdrrgNna++22VZVGxzXPDIW9jw2xf47/v3EGgo4lzw8BuwhpStEVZfiLDVw8DkDxAWFg6UfsiCEoU/oSqRTGFsoEbtkjM3YUeMnTxtacBOHzubTAXO4Jask7UAQYGBkydoCcDRbx3nhPvl/tiB4yg4M+ywk8gOG/+yM0uxmpl+Fi5cqNIc873L5VxGFwa6WHIk3nmUnK6ALAs7fZw/a9YsdSx2HCnysKwsI12AWCaKFl999ZVKe0sXQHbg2RHWVhX6/BkLi+XkduxYct+0wqAAw44sLepoyaDjR/Tr10+JJ4QCMTvc7CCzY8p0u5zHGFvslPMYrGPYeea7UgdFpWsjO7c6tsu0adNUHA9eB+6PE68pl+sON8s5ePBgdXwKEPl1frVVDusd3hNOhMdnzA2WgRZBvJ5t2ri1806jrzEHHNgp/+uvv9S1+Oabb1QZeb35l+sNGDBAWUHw+mtRhJ37OXPm5IoiFB74fPGedOnSRVk28VprqxaW8fvvv1fl5nXTKdr5LPL4Y8eOdamb+ZnxTXh87pPnRLHCuT7iNeIzRBGE149iA6+98zoUlngveX68H3xmKWrQWopl5765Xz6TM2bMUOdAgYNiCtsLtOTg861j8fCc+WwR3mOKVrSA4TOqLUS2bt2aK5TQGpa/NZ4fxRVaoPAasIz8bfA3QUsf/bvQIgrvMa8BrbkZnJlB8nmeXIeDQbyGjPXGZ49WJ9yey7kN1+Fvm89ySVuhEBFRBEEod7BSYyX1b3AC8OxwoFlNh5jiDm3aPfVtKLgwBoq2WJnwb5HLwoqFL3++0P/v//5PmSu6Nwgq+kjk2QgbF59++qlqFLrDxu+dd96ZG02+INignTdvHq677jrVSPIWPWLExiUbSYSNITZm2JCnwOIMG/xMa1tUdx8er6BMMly+d+lf2LtprbLCsGSlYu3PHyM1fqcSGOKWzEHygTiXbWKatUXDc/qjqNCaRKsH4dVj0OHKO2DPPmM1ZrflYMffU9XfFheOhJVD5Xpba5CyjPEmQ03u/ug3n52t9hlcL9oRj8VLAdY9vbl+JajrynLOnYqk3VvQYtCVKuZL/pgw7ZzoKuE4tqd0v5zTu2EUjqZmYd7uRNSKCMW5Davlnxo4nxSW6t2lyl5y7zDe1/L+zjRg8es1Y2fks88+Ux0Od9iBYIBib2I4UABcvHgxbrzxRtVxKwrsqPHdx1Hg/GBn8YYbbiixLC3sZLIDx44UBQB2BPl+ZMeW72N2OnUnq6BniyIF19Wj45y0IMJ3qI5DoffBDiUtPfidFmq6w8w2AEfsuS3L4x7EVK/De8B6gh13vrt5DzlpKw+uQ7GFy7geP/OY3I5l4bG1tQe34zKWU1sp8PpzJJ/zKFro2CvshHKiq48O2MmJ5dSCgLbKoAsyrwc76VxHB2rV1h89evRQ++c15/lznhZYuB8KHPxMUUvH/+A6dMHgNSrofvAYPE8KJSwDn3+9vr5GvHYFxbTR63NdWtfQXYYiD8ujLSO0VQj3xWvnnK2GzxWFKQoovAY8R23JxPPSViMabk8xRmfQ0eigwu6/Ce6LdT+vO68Vy+B+TXgPWW66tFC44fV2X4fXksfgenwu2DZhncWy8XrrVN78ThdV3i+uw+14LXmePBfeI5ZFCzY8Dx5f/wa4Po9x8uRJJXrweeJxdLplrsfz0NdMiyR8Hrlc/y64PZfx2ea5cHs+386iGudx2wsuuCD3Oef2+jeo00Dr9MeSnUcQBKEQaBbJ9K7m88OBx4b6fr3Ob+GYyP7jwI/LC1ydnRUGmTVMA1a3ioujQYyFwrSjzz33nMftWQnwpc+KRgePK++dhLMddiDee+89NcrmLpqxgcnRFB1d3z0lnzabJRxl5LPMzA2+iCj6mfrtt99y96kb5hzt4eR8PI4ysVPjLqJwfW9MYPXx8qQX1O4zJrBv+T/Y9M+fyD55ApnpFmz69UuEBDkajPtXzVeTM80HXoH6Xfvkfmca4KL+LsIjo9Fu+E0u83Iy03Fg7RLYMjPQ9tIbc113ioqjU2Jg5/xpQHXdIXMIFmYBmm2hmCb2LJyBhG3r0KTvMI8iir7WKsiqF0fhdezZoBqS0rPxwrydqBcZhl4NqjnHOM17DKZktuUoYUkJVGUAdb6czBI6nn6my5iQw5Hht956S/11/73+P3tXAd7WkW7PlWRmpiR2HGZsmNoUU2Zm7paZdguvtOVuu4Utc5sypkkhadOGmTm2EzMzSbrvOyOPI8mSLdtSajtz+t1GvjgXZ+bM/5/Tr18/ER3mypXC+XtDbYHnn39eREd0lERh54ffPo5kO5dFHu/oo48WxPDBIlHYmeJ3l1NHwftNnQlOnoLfeE7tdXGx77Rzag3sNDujPUK47GCyg8zJFUjykDxyBXZi3W0n4cm5u9t/a+D1kWQPI1a88YxwYpROe0BCgpOnIInSnvLyHSLpSJCccAU+Y6NHj251P5II8+T8PDkfkoLu0FaqcFATwdRZyPerPc4+BxMqEkVBQUGhDazVi3GCZT4uMAzAJVoT+dIOnHnmmaIRwZDETz/9FC+88ILPrfMUDg4oQPfQQw85dBZIsDD1heHFXGbf0eCIMtNtGKJKMM+7IyBJQ30SGRXDfXIUh4SePVHCUWMucwWOSlHsWObOtwamDDHU176DQY2M1e89KxxVxLGydiHQZMDFY5JFxENrmhxE9prF+OWR68RvapwcdskdCEv0vLHaFgx+/phw2V2iU2xiakUncdVVV+HI2bPx8uMP4Nsl28S8QbEhOHFQHH7fW4IV2eXIrqhDqL/3m1Z15SVY8dYTqGA0j48cajL++gkle7Zg1NnXIX5Q+zs93oaI0vnrN+i7dwAVTWlTPoZ12WLoO7bAeMzJQLTvhSXbC6YO3H///Q4ED99/Rr6xjrn99tsdlpHk5fsvw/KpW+AtsMP38MMPu/y+KSgoKPR0KBLFxyAjz5AphkcxJMoeZPE7o86voHCoQo6slFr9UJFlE76CqcmiuMEMFFYBFY7vW2dQAzN26OUo0m2ikO0FQyBZXuopMKezp1sK9mTwmy1F5hjyytEahhrbdySYM37jjTc2CwlTxJMCqLSUZSQSU8D4/SdaC4lvDRy95HPFTovMdebfLIs9IcKyussV5qgVO2WewH4kk9EBFDilIGnOhmUOKTRGg4YBMZ7ZeNeUFIiJIMlRkZsFY0AQgiKjvRIJYTAYETfA81HltpCWkoS40AC8oPkht9J2b6MCTSiubRRpM/lVDWiwdLxOt9LWtLhAnHtAuM2ZQcLSUI/8LatRW+pk5d7Kc1rZYEF5XSMiAv0Q7s8oorZFgKsKczD4OM81b3yOqgroJUU+c+VpgepKW5rUQbbKbOt7Q9KVxDvTRRmKb/9sULfiH//4R/P69svY9iRxwu8EwfD6zpSF5SAxI799LIv9t4/fIvvUBgUFBYWeCkWi+BhUD+bI85o1a4TYjz2YB+Yqv1VBQaF1MDWBAmmP//d5vDT9CdvMlCjgq+uBTfuBK94Fyr1HVBymxeED4+GIPNRUAhVagCQICRJ2TCj0x1DotkLWd/zyBbb+8CGm3/gY4oeMFRFJJNiJ5557Tkwd7dTceeedInWHoqckVg6GxTHFW/947k6U7dvtQKB0Bua6Oiz+z72I6TsYs+58Tri0dDVs/f4DbP/5c5wUXY1jZ9lSITYXVOGRRbtxTP9Y3DMjHa+syEJVg2cOQc6oLS3AL4/9A73GTMOU6x46IJzSAZDK+WhDDnIq6nH5uF6ICfI7iKom3oNh1rEwjJ8C8ydvAyRTfH28abNhGDEWCPaMCPQ1SIJQ74TEBYUpnZ3f2gK/TxSRlN8bRqpRW6Uj4D5uvvlmISbJ7410fVFQUFA4FKFIFB+DI4IMsWbj1jmfjSOQzG9VUFBoH2SebNiAFGBUU/h/WCCweAdQVAmM7AXsyAMym6JUOokAGJGMYJg6ODrOyAM2PNmgZaQAczwVujc5zpFdWg5SiM2e1CjatQlFe3ZiUJQ/kgy1ImWFgqE1JYXI37pa6HQ4oMoWZt9RsA7h6DDLIS0QnaNNKMrG0WmKSjL3urVcZ0+g61aRXtLsTOMV6KivKBWitL5KV+ksGE1UV1aEECMQEmSL9okL8UdqZBDiQ/0RGWizOO4oGOFTV1aM+qq2owUSwgIwIiEMhdUN2FJQhQExwfBzEtcmmVNZb0ZYgMnB/rg9qKsoE5bK5Tm+tzcmGqoqkL32L4QnpyKydz8gKNgmh3KQOutaYCC0sLYFoQ8WxDelqEi85xRQpGBne0BS1Z54ocZFZ799/N5Qo8D+2yfBKBQKSrJ+puMMhTA5KSgoKPQ0KBLFx6DAEC0nhViZU8Nww4YNonGroKDQQZw/GTi7yQpzXzFwxFPA6D7AZ9cCD38HPDu/S1xa2sfR4pgjiaeccooaveuhoPbGuk9fRs66pbhwIDsrRVj05M22b7+uY92nr7QQq9yzJd+nZaLuCZ00aDE4Z84cEfZPy20F72BgTDAGTE4VUR5mKsseJEzpHYkJKRF4YVmmSC26f2Y/RAV5n2gozdyBRU/eAou5EQcD1NlZ9PStGDznPEy49M6DckwF74HECqNUaI9KHaV77rnHreC6goKCQneGIlF8DKnA7QqeOCIoKCi0Ao76Nrl/ICoEuPFIICnCpo/SiRHh9oA2ff/85z+F8w5FRCn4SQHOFtaodu4pCt0XDF+nyw0FYRkWnxgagIm9I4SdKSM0KnMyyaY0W8na3FSa4IJMHxQThJMHx6Fm7S/YbCnCgNmnAcbWRV7bA/nMsdz2Lh0dAbfNWvaLiLYRESM+ADU/Nn75BuIGjkTvwzrvyOBtWKw6/soqRb3Fipmp0cJ9iHd6Y34ldpfUYGh8KEL8jPB3ZbnekeNZLMLOPWvbJiRVVjU32nhfxSfOxs+1REdvM52C/pyHipwMDDjyNITGJ2PE6Vcif/Mq5G5s3cXMGwiOSUD/WSchfnD7HDR6KhhJctlllyErKwsvvfRS83y631DU+r333sO6deu6jM6W/N7wXz67rdmiKygoKHRnKBJFQUGh+4IjvxarjTCJDAZuOdrWo5DijuzIdJJLYRfJ2LQTNgg52VsUk0T517/+JWxq6ZrAtD1nEkWh54D3niRKZmYmpkyejHhUIWBSajNp0l4MjgsVU83aX7E5YwP6TDwSfuHtC9lv0+HExXPbUWQu+0V0sn2F2jKSKG9iwOxTuwyJYrO9pc2uDquuY3FmKSrqzJiYEtnsQEQS5bc9JbhjWl/h2NO549mimgjeN9FRXvIH/jmrHyKb0ogc1hefQlvZ5AyrYFc6dvy9f/0kRGxTJx+FsIReGHXm1dhoNB0UEiUkNhEjz7gKRn8ncVLhJa35NtVLHqMLkigUj6UINNNpZFoO65p3331XiJV3FbJCfm/4ryRvFRQUFHoiFImioKDQffHBUuDzt4AHT7Kl8RArM4BHvwcO6wt8fh0wqml+BxCNADxrnIQhiBRkyqeffoIPPvhAkCYTJ0703nkodDuEBRhx1fje0KuKvSbYSS2Mv/77L0SkDUafo8/xyj7pxnHbbbcJ8mTu3Lno188miKrgOUgobPrqLZTtP2BHXVrXiFdXZgk3IkK69XgDRTs34NcnbkT/w09Grwmz21y/qt6M11fth5+TpXRGWS382huRp2mCNEkYOg6BES01L/4W+AfAePwZ0HP2wfrrDwzP8fohtH6DYJg4HVp8Eroi6MzDiCQaEhAkTs466yxB6HK69dZb0RVAkodloSMY01iVHoqCgkJPhSJRFBQUui925gMLNgHnTQTiwmzztucC8zcBk9KBY4Z3aveBMOJwLRl9NJsYHx1ZKJZ37bXXttqIpM2jPTpqY6vQdeFvMGBIfAhq/bxnpU2nm/zNK9FoNqP3UbrHGgQUnKT4ZFhYmBCXdbY4/f3330UnjHakPcF+lK52ZWWuRW3ZeaMWmauIG6Y8lJaWtqkh4yy+SYtqaoM01FSKv8P8TQj2MyKnsh6NFh3VjbZOvVHTBKFRWmvr6JLUYGqPq7Lw+WFUSSBTD53QWFOF0sydQryX4D2lOKjBRSpgqL8RIf5G5FW1JHEockt74/bGAsSkD0XSiK5DEmuMoEpNh5XnL8S9vU+iIDwSWv/BnY7U8hUoRk5RcomVK1di8+bNIpWUYrMUkD4Y4PeGorK0Xea3hH/bXzPaui9cuBBDhw7FMcccc1DcwhQUFBT+Dqivm4KCQveG2Qrc/DEQ2BTmzg7MQRR4dGU5+8ADDzjMr6y0db4UFLwJdl6efPJJQdpdddVVSEtLE5FSdIXryfj+++9x++23u1x25pln4plnnnG5bN68ebjlllta1YV5+OGHcemllzrMSx41CXMe/wDr5r6Cnb98iUvGpKCxKX1iXV4l3l+XI35bdB3vrMuGX1MKw8iEMFw8JtnlcQbFheD+memCjHFG/NBxmHLtA/APCRed0P/85z8oz92HVc/figY7LRoGmZw3KhmNTGl0A6aZhXfQmUeh64I263xOSaBSL+VggOk5L7zwgkhlvPzyyzF8+HC8/fbbSudLQUHhkISqWRUUFLotaNdKgT2iFmYstxaiQY5S9o3zbCeBJmD6QCA1xiEffgxiMFiLFNEoEtQ/4Wg+R+KcwWWyLO46vGzwKnRvUDy2ePdWlGfvgaWxwSfHaKyuQMm2tTClD0J4eHjzCO/y5ctFpMXYsWOF1gCfKUYpmM1mYTvKZZ0Rjm0NVYU5wjmFwq8HA9XFBchet0TY3IbEJDiWpaoK+/fvF6PdvXr1cljG81+wYIFtWUqKSAGB1QotpY+IYNm3b5+weO7du8kavQm5ubnYuHGj2LczTAFBYvILDBHXPJzfjCaE+du+D4mh/ogNdowGoCTTpoIqIT5MK2R7UHg2xmn95uP5ByAkJhFaExnD70YwzC06q9pBJEhCE1KQNGoySvdu84mosGY0IW7ACMT0H+bWzljYD6cPgF5SBBQVeOfA/gHQUnpDi3N8xroa+OyuWLFCRJ2MHDlSRFvx27Bq1Srs3bsXU6dOxahRo7wWSVNbWyu+NzzGmDFjmk0SWPfV1dUhPz8fCQkJPvveKCgoKHR1KBJFQUGh24K54BdccIH4nYUqTDN/hzy9yaXASR/ALWJCgbcutREoTfoB1D950DgOc7TezaKyxDnnnCPy0F057HAE/PTTT2/1UMqZp/tDt1ix9qMXhcimFP/0Nir378a6/z2AEaddgcR+NpFipqFw5Ll///4iEuNgCzbuW7kIK99+SpBIBwM565cgd8MyEZHR/4hTXK5zww03iBFxezAS54QTThBOJlddeimsP30D3dwA0yX/aF6H6XjXXHONw3Yff/wxLr744g6Xd2ZaNI7uH+swb3VOBZ5fkoEzhyfi2AEekrpdFGmTj0afCbOF/fD+Vb97ff9+QSGYfM2/EJ6c1kwetUBMPIxnXQLrqiWw/vS1dw4cHQPjmZcAAQFdNpWHyMnJwbnnnotZs2aJZ5WgPgojH/Py8kQKTVRUVLNmSmfBdJ0LL7xQELbUNlF1l4KCgoIjFImioKBwUPCzdT9W60U4z9C/WWOks2DDTjbuovVg3GQYiUrYGpG/67n4S89veydsOJuMSEcYzjakC6takiiDtAiYRP696+O1VhaFng2SJ74iUA4cw+Zw0fy3rouIE9qGugPD7J944gmH55Aj2CRgqInSGcT0G4rhp16KrBULUb5vN3yNqNSB6DVuhvhXgp3F999/X2ib3HvvvRg3blxz6pJeXQnr+lXAzq2267RjC6xLFkKvKENRZRU+fPoZVOXux93TJ2BcfQUMKxbDMHIctLAIsX17392qBjP+zCxFndmKEwfFoX9McLPIrP2nhUZh3sgu9A8JxZDjz0fJnm3IWDIfvkD84NFIHD4B4UmpLZaR2ODX0FdEA/eqGYwudV+a1+GxqY+S0geG6U2Cu2az7b7XVHt+rIFDoSU0CciGhgN+fu6Jmy4C+f5v2rQJjz76qLgW/DsjI0O8A0z74jPsLRKF4Lemte/N7t278fjjjzsQutT/UumrCgoKhwIUiaKgoOB9O9Am2017/Kjvw8vWLZisJSAFjhag3micR2kBuNs4uvnv+y2rsNSJRJHlEg12p+1JmjxsGN+COFFQ6Arg+yFTeNwtZ4fqoYcecrm8s5Er8YNGI27gKFTlZx8UEiW231CMPe8Gh3kkUahZwmiwN954Q8wT1sNEZQWsf/wM69YN4k/r9s2whtuaOPkFRXjkzf/ghEHpeOvUY6FVl8C6aAG01H5AiE2QWmu6Rvx+sePo6lprdja7VfUWfLe9EEPjQnHdhN7eIxfEMVreK+qjjDj1cuxb9Tsylv7ME4e3kTDsMIw59/o2ymfwgdUwowA9t6M39EoFOPH+19XCuns7UNsUgShhXz6ne2MYMhKG0Yehu4HP5NatW1tobjE6zVvfEefjuftucD5JlAcffNDtcRQUFBR6MhSJoqCg4FU0wor7rauwTXd0z9isl8IMK+61rkQMHB1CLjEMxGlaX6+W43xDf0zQHEPoV+mFeMS6Fudo/XCOwdHqNR6BIgJFQaErghoIr7/+unDpcI6a4LLXXntNRGi4A100eprgrHXlX9DZgSbq65nf4PnGFjOsP38HBAaJP6f5B+Krr77C0qVLcfbZZ+ORRx7B4MG2VCqJ/rNPRfyQMVj78UvI27oV3kZgRDTGX3QbIlL6tuj4dwloGkaedgVSJ87GqveeaXYP6iyGnXwJkkZMQHB0BzSj/PxhPO5U2/23g3XZH9CzM2E48gRoEVEOy7TEzkVl/R1gJNl7770n3LacwW+C1E7yJAWW+inUVWkN1D556623hFuVM5FCHaY333xTaKO4A3V8DnbKoYKCgsLBhCJRFBQUOo1a3Ywy2Bp39bBgoZ6DVbprAcolLlJsRusxmKzbhP1M0BBNOddOdiKGaJFiskew1YQkbMd4LRYnGVqGrCv0TFgtFtRXlsFg8oN/SFiHR0kba6uF3a3F7L2Q+dZgrqsRQq7+oWEIDAx0sDi1R2vLfAGrrqO6wSLcaJzBdDja7jqnthCM8qhys50E33tu7wpMWaCYJckgRqVYt22BvnENooMCxZFLamtRXtfS6tclGDGXtbf5z+TBI9D78Fn4+ccf8cMPP+C2225rsUlUn/4IT+yNLd+9B4PBJupKG+PyenPTuUPYDfMa8PrUNFkfewqK1yaPnoygSEdtFXsY/fwRFBkjbJDN9d6x1xbvRWg4/AKDW11PCBkPGI7Q+GRsm/dx83vUWFcrnlWPj2c0wT80ookn0hA/ZDRSxkztuP1xWv8Wz5m2Z4dI5TKkD4AWe5BFY61WGGproLl4BzoK2m4fe+yxra7jSSoPRZU5tQWKVLsTSg8KCmpVRF1BQUHhUIAiURQUFDqNn/Vs3GRZ0pwukw/PG9TES9bNeM+6U/xO1ULxpfEoxIAdI+9iipaAv0wnIRKuXTEUeiZqivOw8MlbETtgBCZddV+H97N9/lxs++kT1JUV42Bg18JvhKDr5GsfQPLISegqoA7IKyuyUFDdclQ8yGTE9ZP6ICE0wOV2r63ch7wq90RHcngg/jGhj8tlAwcOxK+//ipIjsmTJ4sUjmDdgg/POAF+RgPOmfsd8qo818awByNazG/+B9Yt6z1aPybID7dPTcOWgio8ssiW3kTi6OrxvQW58uLyTJTUeJ9six88BnMeew+bv31PEBneQGz/4Zh6/f8hIMyRdHYH/7AIzLrzOegWG3m0fcFn2PTVWx4fLyptIKbf9ASMTZFRAeHR8DYMM46CYcosINSWrnUwYawsR8SPn8OYPhA4zrUosoKCgoJC94YiURQUFDqMar1RiMWu0AuQgZbWoJ6iFA1iIhp1qxCFHYAIDEeUV3OrgzUT0nDwG9UKBw+1ZcUo27fLYV5NcQEq8/fBFBiEvI3LHVIljP4BiOk3DEZT26kuAaERCIvvhcaaap/ZGzvrYIQl9IIpwPuEYkdBy+H4IWNRuTQbVQ21SI0MkqZWAn4GAzLKakUUhm3ZgYUkWEvrGkU0ivN2FF/NKK1FNfwRP3QcIlLSWxzb398fqampSIuNQV+DFQgJhL/BiI35heI4vcLDYLHqKK5xn2bgDvmlpdiyfReCo6KEAwrTGFzCYEB0+lBYrVaYdm9BXHVDs30xy5BTWY/i2kZEBvrBbNVR2eBJNIqG6L6DENErXUSFtAY+C6HxKYhOHyJEYAk+i8W7N8PajggpCvZK0oSiwdxna6Ku9jAYjA6209Fpg5rLIsGIrZKMbWK9sERHUiyyT39hmezJO9cRiDojxDvi5W1Br6yAXuQUXVlWAmNFGbSifOgZuxz1wfz8oSX1EhE0CgoKCgrdF4pEUVBQ6DD2oRpnWn5BMTwMofcAOajB2ZZfcaqWhk+Ms5VKiUK7kL9lNRY/f7djx4WpG1YLCratxc+PXOewflhCCo595B0ERcS0ue/+R5yMvtPn4NfHrkfephU+vzN9px2HMedcJ1xLugqGn3o5kmeegpBvV8HP0oCbJ6eKKBAJkidPLt6DQJMRd07rC39TSxI0IdQfN01Khb/pwHZ1Zgue+GMvwhJ74/C7nkdYmHuNh6P7p2LWBaeJ39UNjZjz/hdotFrx00Vn4Nttu3H1twvafV6L9u7DZV/9hKeffRaPXXedW7cepqIcdsntqMjJxLz7L8HA2EbcNtWm52S2WvHckkxU1Jlx14y+2F5UjVdW7Gvz2OxQj7vgZiSOmODxve4/60T0m3G8+F1dnI95912M2tJCj7bVNANGn/sP9BozTc7olDtN2pRjkDrJMZ0sf+sa/PLIdegz6UiMv/AW5wJ0qWe6M9D37IDl209bLqC71t5dsGQ6iTDHJtjstoNsWjwKCgoKCt0TPZJE4QgR1fXpc79//37RGKLAFefzN/M5o6KiRG61PWgXV1VVJbajVWRYWJhYlyHE/FdBQcER9OGhkKylhRdP52CGLqb2oLy8HB988IF4h92hX79+OO2005TgXQ/BL7/8gtWrVzvMK83cgb1bczEkLgR9o5w0HkimWMzYWliFPaU2PYmAfTXY8vyLIkpFgvUEHWD69HEcQbdZsOoHzXlC2Mr6aLS+o/jhxx+xYd0aDA/TERgQJQgUk11ICTVNGFVC3RPdTqNiQ14l9lfUYUxSOCICTIJccd5Ok+4hRpPLqAi9qhLWTWuArAz4NS0P8gPOGzlEHC/E38+lFktscBBumDRGaLk889cqzO6XijFJjiKmXEYihpEDhlV/QRs2BghvGY3C8mlGkxCBHXL8ebDU26JecjeuQMHOTZjYK0KkLTGtyT4KxxnBccmIGzkFAQEBCGB0SUIvcd6egs+iJCIYITX42HPQWHvg28drnrn0Z9RVlKLfzBPgF2TniKZpiEhKa/ezxX1SfHfnzp0ty6NpOOWUU0R7iWBky7CTLkbc4NHien377bfYtm2b232zjXXBBRcgOjra47IwrWvz5s1u1+G1Pf/884VIqregWyxCh4eW2uLvnP2CMHGzdkt/a1pxL/9D2CoThr4DoSX38lr5DnXwuWBbPycnR7QJ8vPzRdveldMWBbmpNUPRXj4r1JbqDNjvyM7OFjbP/Le+vh61tbUYM2aMqEsYSafEdhUUeg5MPfUjyo8XiZC//vpLfLgoSMcPHAXpWEkPGDBAqIfbgx/akpISUSn/9ttv4sPKyrd3796KRFFQ8MDG2OvvMv/TPbNLLCsrw6OPPorc3FyX67PMc+bMwamnnuqj0iocbHz33Xf4z3/+43LZOSMSkRZpI0acnwd26OftlMLHecAyR1tg1hPjxo1rQaIoAB999BG+/eIz3D+rH5LD2o7ekVieXY61ORW4b2Y/9Ipw3VmRQpzi+0JxUOf3uKoC1oXzodfXNVuVBwgNlrHN3yS4sDBPCA3Bvw6fgg/WbxHRJv/x92tBokjotEb+LRharzRoTSSKfXlkmQLDozD6rGubl1nefQbFu7fgiHSKwtrmNZdFbON4LqFJaRhw8mUID48QAzaeQh7PHqagEAw/7fLmsvFfiimXZe0U/444/UrhfOO8HTub9rA/P3fHfvfddwUhItdrPk9NEyS1tNsNiUvG6HOvb16PBPfnn3/u9tvMdtkxxxzjMYlCfPLJJ/jwww/d7pMpWbNnz/YaiSLO1dwIy/LFQF52x3ZSXQXr73aRUsf6wZCU0mNsgZ2fMVfw5Xnymea0d+9eMa1bt064CDkfk0R53759kZSUJNr3fFY6S6LwuLR93rdvH5YsWSLaJMXFxbj22muFoxH7IYpEUVDoOeiRJAo/XLQpJBtM67dRo0YhMTFRfNxJkvzxxx/iY8aPJokUMtG0hiRrvX37dlRWViIlJUURJwoKbsDok39ZVws9lCrYxAW9jeV6Ac60/IoLDQNEao+nYOf37rvvdmisFBUViXkKPQ9GDTh1aAISnYRMqcvBVIpThsQLsVJnsL9+8uAEpIQ7brckqwwbi7zjetJT4RcYhAmX3YX4AB3rPnm5XVoc7sCOzNNPP41y3R9XXnklZs6cieuuc0y9kli4dx9eXbEOVx02Ckf2s7lsZZVX4l+//onEsBB8cvaJGJ3YAbtcN+BgzHPPPYdLLrkEJ554osMydpaeffZZnHT4FMy64xkxLzc3D/feew9MjbX4x8Q+mHnSmTjsCEdnFS2IxEn7O5OMvHriiSdaECDE2LFjcc8994gOIqOYRp5xFRpqqkWkCjuTJJldbSdxxhln4LzzzmuzDGw7Pf744ygsLMTDDz8sBqjYvnrqqacEqWGPk046CRdffLH4TbLoscceEwNUEtyO16+1KJW2XGS4Tw522YPkKs/Zm7CuWgp91zbAi8LS1rXLoe/LgHHWMUCs957Zvw0kUaoqARKd5aW2Z5zkHDWGqO0UEuZT+24OnvJZ4sQ+wHHHHSeeO3uChG19LmNfgH0Ctvd79eolItQ7A753w4cPF/ui5fSmTZvw+++/e+GsFBQUuiJ6JInCKBQy0Pyg8cNJpjk93SZSl5WVherqapSWloq0HX7oSLSwEdDQ0CCWsVLnfAUFBddg+s4iPQfLdc9y8DuqjfKVnoGJevsaliRMGW1ir2nA9/6hhxyjDRS6LziyyEawtaEeEYF+GBoXivRox9SdncU1WJNbgdn9DkRLNFqsqDVbRRueDipD40MwIMYuzQHAnpKa1kkUDfALCRMd0/rqClunwctg+gOjC4z+XUdQVoJ1Y2x8AkLShsKEOlQ2WOFv8hODEZUVFahqqBepMZ7A6BcAvyDbfTMFBWP20UdjT2EFbrnlllajMzLLKvD1tl2Y0icFIxNtUQaZZeX4bvtunDpkAE4Z3L/V0e6qhkYUVDs6iFXUuxcKZlrwl19+ienTp7tdxsGaoPSRYp6mhWF9QQ36hxkwdUgaho8Z30IzhGH+bIe0F7R2ZkoNSScSCPbgOdu3a+jkI8G0hq+//lqkLXCZPdj2YceyNetbto04wMQ2FTudjOrbs2ePIKsZ7cv7v3btWqxYsUJ0RknWcECL32N2ZHlckif8zYgVCba35s6d22EShVFjjDZh59V+nzxXb5Moet5+6Dvcpw91CPm50IsLoU+c3o31v2wRozCbRaSOXl4G1FRBLy5oWm4A6OQUEgLN5AedaWQmU7PFtTfBd2rHjh3ieeczyMgopu7zXeH7wWeD5B8HVn7++Wfx7LMuYZ3SWfBdYNQT3y/uj++qgoJCz0WPJFH4UeTHix9OVuD2DDQre84n0bJmzRrExMSIMDt+9Ngo4d/M9+VoD9N7FBQUFBS6nhbKzTffjCmxBtw9o69wQvEE2wqr8f76HMxIi8K9M9IRSUGNdoI6FBMvvxsVefvw+1O3Cs0JbyMidSCGnncropvC/LsSGHnA8HQSHRm7d6GmtBAXnH8+HnjgAdx22234+qdvUFprRp/ItoVDe088HGPOvUH8ZgeHKSco3ORxWZ78cwVeXWnrKDdYLEJk1hM8u2QV3li9oQWx0hkw8uG9994TvxsbG20EwuRjcNxjryIo3DPr4PaA0Tr/+Mc/HOatWrVKRPBcf/31uPHGG11ud9lll+Gmm25qEWlz+eWXt3q8999/H8888wz+9a9/4d///rcgREiiENQyueOOO8RxWYbPPvtMdGIZgcL0rwULFuC+++7D//3f/wkCRqEnQoe+fRP0/BxYt20SkSiw2DlTUe8nIBCGoSOhxSdCG0rC0fu0EQmS9evXC20ePmsk9Jw1DZkyxnmTJk0SfQESfIxOV1BQUGgPeuRXg40xkiX8l2ywDDUlZMQJP5z8zcYO1+OoNSeOakjSpSfkpyooHCpgQ2jixImCFF28eLFDOg87NBR3GzZs2N9aRgXvgOLBzD2fGJKE+BRqUHiGOosVBdUNQvAz3in9RyI2xB8DooOwc+smQa6PHj1a1CcSsrNvpVihj2xKDX4BCIpNhF9w17Lj5rlzEIIdEIassw5FWl8Yw2OwdsdeBMYkYsCo8aITwwiThCFjYKksQUVulm17o1HY6SbE28LmY9OHIjzRlobBQYt169eLQQx2bqRAKaEzBSUvB3p+thDxTAwNxrTUlp3xtKgIDIx1H5IfH+J6OwlumxwWahMgzsuBleKtiTZttBkzZrgkAOQyZy0IWjGPHDNOnJ832hJsyzCygppPjIjhcyn1RyR47UhsMEVBgm0dRohQ6HLatGniO+i8HSN32yojv6F85xjlkpbmmF7JjiqjS/i+sB1FLSF2SrlPRrhwYqQKNShcgREwXId6dIzQGTlypEfaEYMHDxad5q1btzqcM+8FyzRlypQWUTcdgV5VIaJFRJqKL+D0vHU3+2O9vt6WvlOYDz0/FygrFREpLVBbA70gV+RSalWV0P0DoHnZvp3fJD7z/J7wt7POD3/z2WR7gc8p+wMUmLUnWvj8yH4CI1ukzorcnr/ZV+B2rBvaYzzBfZJglKKzfM45ccCX//J5lmXnfllOfmO4jO8gt2FEmDwvPufss/C9tH9n7Ps8fLf4/WA0mVyHy/mb76XcXkKuz2gded4knrgOl7HsnHh8Xgem9zFykNfCnauZgkJPRI8kUfhBYGXNDw0bFTJElR8TfoAyMjLE33zh+aFUUFDo/mDn7tNPP8W8efNEyLh97j87fL/++qvoBClhN4XWMDMtGlP6ROHFR/6JhrAEkTfv7OR2qIMN5jfffLO5of6///0PRx99NN544w3cf//9mDVrFsLCQnHEvS9h/+LvsfzNJ8R6poAgTL72AQxvIjPtbXWpS3b11VeL95PvMBvmzWhshOWHz6FTzNNqxdH903BEuk0LxRnC5ccNITA7vQ9mpjlqZzhDOAZZLLD+9JXQqKAdLc+HBISr0WpGfjDSwhW8+a1hx+vss88W5AmvDzsvnoCdMuqcsB30448/OhCCXQWMUmGH7cgjjxQk+Pz589sU+eQ9vuuuu3DVVVeJZ49Eij1ee+01PPnkkx5fp9ag79oOy/efteLC00k4PW9oSnHrNmA6Us4+WwRKYZ77FEem+mzfDL2kGFp4FJCYAs3L0XbC3ctgEGltJCPY2WdbwPld5HNBkk1uY//N4Pp8b0hYMuWH/QaSCtwH12O/geTF4YcfLtoU7shBVyDZx+gspgGSlCRJwlSjSy+9VHxfKL7Mvgsnkp1su1CriOuxLuI2jPaSg75HHXWUIGwnT57s8nvD7yo1Iil2u3HjRrENj8PrwneM3xPKHZC4lgTRhg0bBLHKlDiZ5kTRZ67z559/Cucjas/wW0JyhaTu+PHjlZakwiGHHkmi8IPEBgNTevjh4AiM/ACSVeZLzwgUkiq+6FDt2rVLfHwpKkXm1x24Dj/GHH2hsBpHd8hGcwTOG6Mn7sBzJ/gRVeiZkOQg77EnavntwV9+RVhrKkOufnDENxfrufC3GHB8fSKSre5HfNjoYKXPBgbPm5U6hRYJNhpIsLCxcOyxx3brKDMx+t/0Hrdm59yTEeWn49gBsahttGDeTpsuT4ifEZN6R6K4phHr8yqQUeaoeeEpaJEr0vsbbQ1wfsNdXed6K5AyZQ7K9+1C4YYlnT4ncWz/QCSOPxzhfQZA0wziPe4O95h1FjsBbMzzubTZjOqoq29AiF8QhsSl4ZTjxmCUIRQ//DgP69ZvEIKj9h1cXmdeb9bJ3IeDRoHZDGvaAGjUotm9DRzrNHag6jYaDB5tp2sa6vsOhDUuAUaWw2J1qDvbA3f1rNyXp/dYXh+uz0l+B+zBzp4cRZf7dN7OlbAs05iZHsRlTNlhh8k52mTo0KGCsGA0jLQ45vGYBsR7xjYM57PTRoKNbRimDnH9ZcuWifvZ2nnyesjRf67nSTo1XRTZ4WNbj6QbnylJdLETSHLv5JNPbpfjjysYamvh5+J6exWMdmg029qMTc9b+3dhbW7XHszBAhGpk5sN1NW2rRHF5XW1ghDVQkIBL5MoJDf4PeIzwc7+okWLBDHHtjWjLvicsI/QWtQE3yEpPst1SJQwfU1qqnAZn1W2Ndju4DHlPtsC3wu2TUjM8zfLyHvO8jKyhWQI3yEem84+fI6pM0TimsengDKPRzKGx2bkGf8dMWKE2B+/qbKcHDAmmUSCke8FSRASJywnj8F3jXpxPBeWn+fJbwH/5Tokj9mHYmQhSVz2bXgdZD+F14FkEPtYfN4YqdKeqBwFhe6OHkmi8EPJkFVW6Pw48SNEoSkyuTIcmfP5kfJ2RcMP15YtW0Sj4e233/ZIWIofYk5klOkswvIfjJFPGZKn0HPBhqs3BNPsMTd0J94y2KK5DgZ+0PdhgXU/eldPRGhjjNv3jpU5xWNZ2RNHHHFEsy4AK3k2sJnOw5Qf4V7RjYkUQnaKDkXE+es4Z0QSPlyfg5+32sQLE0P9MSYpHFnltfhkY96BqIJ2QpCOTR0BppFIMU1X66Udcy4KNy1H4caltpSTJrTn2bInOY2Bweh7zDkIjIr3+B53hCT1xrNvb23LBjwnXjc2rHktaK1bUV6OKC0QY5IHov/MY1GY2BunnnIK/AMCMHXKFJswalNZeJ0lMcDfzp19fehomIoL4J+xE5qvIgIkDAbUDhsDc0IyUFtnm/7melgSECQX3LVd5KAN98d15LXkvZLbuYqmYaeIEUQvvPCC0DZhR8qZeJCk9BVXXCEiRQiO5NON5/XXXxfbSdA9iB02jrizHcT2EAkXWSZnsHxcJqyi+dxUVLT63Mtnj3bLFPUlOKJOBzY+U1xOzSRGCJH8YdpPZ575wLpa0Vj2dY1htVqEOLPeQX0ePhOs2w6elW7Td7K8DNZ9GTYSxRPU18G6PxOGOO+3c5n6wm8RyQkSBLTjJonCZ5fkAMlBtq9dRSjZ23aTwOC3jP0GEgZsTxB8PrlvRoRQB4ntKy7ndfeERCHRwIgrlo1lXbhwoeirsP3C+0bBZqmpRMFlRo/wW8h1KV5NopqDxCQPWQZGpXFfxx9/vNie52Ujsa1CrJlEColMpsiRHCUZQ6KD3wW2i0h+kmjhN2Pq1KniWnGwialOJGyWL18uSBT2ZfhMkZRkdAzfM7qZsoyMSuFx+A5KO/Hu3r5SUDhkSRSCLzs/mGRm2XiQ4XysnPlB4QeAHxt+IL0JfjhIhPBDzUYEGw7uwA8fxfgmTJiAa665RjRk2HDhh6uzfvWtQboQ8UPqy+Mo/H1ghciRBj7n3n7GrzaNwOHGNDxkWYNdcN0o9ibO0/rhFGMaJoZHI8ra8lzYqKHFJclSNt7lSAgbGtKykM/5q6++KkZtbrjhBhEey6k7gt8zNoBkGPChiEqOYAKYlhqFATG2a1BntuKjDbnCdefaCb2FVfHmgvZHcSzbV4Z1eZUYnxKBtLReSIqNRpgL60uGe7PjmZ+5G2V7MgXvQs7m+EFx6BPh+WjcqpwKrNhfLn4b/fIRnXsXho8aI0Q6peC5O8jIAZLwnuKEE07AhRdeiM6AHXoKjLJsrMNk58G6fDEC9+zA09PGwWQyIubPBfBv0pEI2rIOCXt24KmpY2AwGBH758/wGzAEhnGTxHJ2AGTnjyOyHEyQYD3K42gFeXhkUC8EdSQMpV3QEB4WBr2TlqferIf5vjNFhR0nPhtS04DEATs1fBbZaeIzwX3Kbx/rAaldwHmtCWhyO67La+/K7pXHpIUyo44IEtYkKzhIZd9JpIAs90PxYRm1wmfZ3T5J3lDon+fCTmJ8fHyr2gokcd566y1B4px11lliHp8ZtqHkdjw2O3wkWtiu4vPT0faOFhxyUJxzWHaeR0fTeXjvpc7fQUVDPVBVYXPn8QRcj+v7YBCPBAnvM593kgR8X/j9oHgy57POJEnI55QEG0kDkiD2pBN/U+OHfYgBAwaI9e2X8W/2Jbgt2x+M0OC+W3MUa+2e8R0gySF1hfg330Uen+6iUteR6zCSht9bphDxeIy0YXuPRAifH7673Ce/LyRgSM4MGjRI7JvbyvdffiNIzHBb1iF895hC5KrNyHKQnOK/3I7HImHCMjGaniQKj8lyKgJF4VBBjyVR+BHhx5KTzGMk+LGgyBo/sJJI8Tb44ePEj0trILvLxgYJlzPPPNOhnL4GG288dxV61zPBioyNZ1/c4wkIwgg9Fi9pm7HL++6uLTBSi8GZhnTADRfERiPDXdlYZ4eS4abO4DVgg/qHH37A7bffLojO7vrss6FCEoWNoe56Dp0ZqW2sqYJmtY3UpkYGiYnIr6rH99sLMSg2BBNSIrCnpLYFicLIlFB/oyA8qhrMCDIZRfqOPfaV12FVdjlm9Y3GqIQw+OuNMMEKU6DNItP+HaNLENMyCd6L0JBgmP3DYAoOElEYRpNJNHQtDXUw19cJosditb00fv5+CAsLR4WhEbtrbeXUa8wo//lXVNbUCeeVtu4x6zl2YNlBcAcZfi7DrTla2Nnnhp0SNt4jwsLgZ25EoJ+tKWEpyIX/vr04NrXpHczc3byNX2EeWNse06dpWdZuaGyM602pMroVWhMxwA6JfRlJHFIsms4f5n5nM+8JvgRvM6NlDD5+v1gPe/oey28YCQSSxexYcVsSGew48RvIDhNhv09eS6kTwXmuSBT7bwoJB+7PXZmoAcPnjs8UtRZIYPMbzO1IrrEDxtF0trW4TEafSCFNduTsCRI+nxzYYmrOI488Ijp8bYHn+d133wkChToxrkCChZ1kOgmxTO0VABVlY8QToyagw8exTwL8ugQyuoMd+iZzhPaA98FVupbPwQgypqc1vcttgutxfav3U6T4veXzy2eaJAefST6LjKSQgq1cLlNfGEnCqAs+H7I/wHeFRAHX5Tb82zk1n88w3y0up55PR6O6ZVQVyQm2XaQphhR75cQy2ot6Eywf1+U7y7Yez1NGHUsDDdZNJPsZgctrIaPxCdkH4jFlVAqjX3geriJqeF1JUspIFoLXkPNYB/H68FooEkXhUEKPJFH4QSH7TPDjx8gOfohYwbBCp1YJPyoMXZOhZwoKCgoKXRvVhbn449k7UV3cMk0yJtgPt01NQ0ArUQpDYkNw38x++DOzFI//vgeXj+uF9Gj3o7607/3tseuRPHoKJl5xb3PqiStQU+K6665DdJAfSgptIqBMI3jlkVew/adPsXXex/h4Qy52FNsa49OmT8drz7+GGRYd9zXYOhNs7LvrFLoCG8TsJP7zn/90uw5z57lPNsCZWsFRfm9BL8iD+d1XYPZvGoyobF9kmr5tE8z7M8Vvc1099JIiICHJa+XriWC7hYSS7CzRcpq6BRT15Ygwo1rbi5UrVwq9k9NOO00IR7ZlQyyfKXbkKNjNjhw7T0yfJCFCkKz7/fffhT4KBV4ZKUONkk8++aSF3kqXRUkRzF980O7nusMoK4X5g//BMGgYDEefhG6DwCCANt6V5UCjBymmJj/b+l525rEHo7PYwWckiSQJSSgwFYedfpKPFI1l5A+fZ5J3fGbtQaKQqWhM7eG32T6Fkf0MSaCzH9HR1FqZBiSJHXtIooMT3zV7Uk06iXJ7losEiiwDz5VllhpJjJxxFSXDbUmu8JrwW0IShedEssV5gJnl43naz+d7z/n8V0a/cFIR7gqHCnokicKXWaYzcCKRIkWU+GHhx4SjIdKeTIIkC4Vn+UElqypHeuTHkyMtKkxNQeHvAxsKDFFlxS3z3DmRFGXFzzxhNnycc+D57ksBQgq3sYGl0P1ANxf/0Ag0VFeiFkUorG5AeZ0ZKeEBCPIzIiE0AJX1ZuwqqRFRJ/2igxFkOkCqBPoZkeRnhFXXkVfVgIY2BBzl8fyCQsQwMXO/OWJHsK5gtKHsELKhyvolYehQBGt+KKy1IEX3Q3hyGqqNwdhZXIP9FXUoaYAIi+49eCQiUtIQbTcqLxukHl8PTWuzw8v6S47Cs0PhjfQ+k8GA0UnxCC4vhaG0iK3pju2ovs42ccCjoRGj4qJhSIhtER3Exj7DzlGSAlOfvkBDHVBaDJ8gMhpaZBQ0L6dBegt8RmS0BtsoHMHm9433lt8+5zYK7z31TNgJY4eQo+6c7MH2ETuWbDu1FgnCdhBThjhIRbFKrsvjsnPKcH6mGMjOHTt+TJOQA1VSSL89nU0ejxGGfNf4zsj0RZ4zI004n5oN9svkdkyxYMo0y8D2Xoc0QhgdHBQMnc+oe48A74HWv0zl8e+az15L2J412hRrEZHQa6s9JFFMYn2N5IuXwXeCzzG/o3z2+VxwnhSU5fePERP8ze81n31GNtmTy9ye301O/N5zfW4no8WlcKvUVpPpNh2BFAHmvpxT2GQEGSfnekGWQ77vMi1IXgP7qCRu6yo9Tto9y2XO29lDugE5f1/sI+h5fG8bGSgodGX0SBKFLzRfeFagzPNjI5PECcPdyPRS1IkhbCL31A5kYX/66SdR2XNbqaMio1ko3OSL9B8FBQXPQBKEWibUEaLbjnzXn3rqKdGIp9UlBeQ+++wzh0aDtAcdPny4CIf3tk6MwsFBSGwijrjreWQsXYA//3Mfft1djN8zS3DblL7o36SNsq2oGv9buQ+nD0vA7VPTWnTI24OgyFjMuuMZBEWxI6g1j6oT7IhSuJKjncSjjz4qnj86RDl3RP/MKsVTf+4VqTzJKSliNJ7bd1e77bAAf7xx8jHQiwrg7yV9kmA/E1458ShheRrEkWo7kABiFAPzsPyNRljXr4L1h8/hCxgmTIPhsCmAses3j/j8MBKJbRV33zSSGHzemHpGZ7I777xT6Nl0BOwgcVum0pAMkc85989oKOqPnHjiiV61UeZ7xfeMApwkxwmmNTFliFE3XM5UIKbu2IMpT99//70Q3iTJ3qEyRcXAeN7lsK7z3fPmgIgoGM+5FAg+oAfULRAbD23QMOiM2Kn1wBUtOBTawKFiO29Dujsx+lxGRMhUNrb7ScAx4oTkCd8bRmEwtd7ezIHPNp8bLmPbgWL0fK7Zf5DPEaO/Xn755U6nRso2TGsDtLIf8ncO4kqix74MztbQkkRRKT0Khwq6fiuhAyDRwYYDK3h+4MhAs4HBjyv/5Sg0P7DOHyR+cLkNP7IcUZEfAjLUHMXprg1eBQVvwwQDztL6YQAi8Jm+B/U+yBjvhzDMMfTBOC22RZSZ/Wgm31E2bPhucz5HVF988UWH95sjlhx14kiLDIFV6H6g7a/RPwCGpg6uRddRb7Zixf4y7Cm1Nd6zymrRKHVHWung69CxKrsCWeWOzisZZbWODVw/fxibOvUckZS57zJ33D50meHTX3zxhSBWGM1IYo/P4tJly2FuKhMhbSZdRRnQFpadgHfeeQfTp0/H4Ycf3qFrxfqLGkBbN23E8AgN/VIiYPBiI9zfZAQ4eQm81gHcn5sRU3uSQPOlsCw7K04kTlcCBbRJYlC4nmQynyOG79MlhyPn1NJhp09C6itwxJmRfJ5YB9uDnUUSgySnGcUnbYgJjuC/9NJLIm2H+5Y6EQRH8L/66ivRWaWYNzulHKB67733WqRR2wvTOkMez36EW46e83vO6Jv333+/mcyUYMQit+uMgYCoQ0x+vn3enGE0Qetm9ZMWGgYkJkNLSobOT0xxkWu9E4PRRrgkJEGLTxKW5d4Gnzum7DNyjW15GUEiyumUDmMv3G3/fLGdQZ0TPluMMGT7n99mqUFCyDSazsIXxIgUuZWDvqyLXLk08jylloq9Dkt7oiEVFA5l9Mg3hR9NRo5wYiPDU/CjY9/4UFBQcA0/zYBbjSOwVS/FD+Ys1KPBJ4KyzxsmO3T8PGlwUBeAzgwKhwbITSzY7Sq1Q2tzu1/2uE4JMXrwnNmHMDfv02oVLlASbIS351kk4f/ggw+KXH2OtDNqoD0kin1Z+JsOJr/88C3un9UPI/vFCPcgVw3/jloy+xJqNLP17xufk8MOO6yZJGaECNPLSLC01Qlyvoet3VMSHLfddhtuvfVWQaLYgykzXObqfZDLSKDQfYcECucxcsQV7B1QPH02uYwdQEaduHufFHwPpuYgPAJaUQEVs4XlMZp0nlqk8aT2hZbUC1pKb5Eu6W0w1YzvANvzkkiQz5D9M8rfJFGY1uMqooIRKCQYZEqaK7JFpg51NciySiFZ1kMkM12VXy4j0USiiO+h1DhSUFA4BEkUBQWFngk2Zv773/8KMTTnxjXncVS0NVtxhvOqiLKegyl9IpEe5VoYNjXKvWjhpN6RrdoQ89FKDms5ek03EKYGEHzOKJYpR+XZ2OYoO1PLOApOcDSUHUk+c2xsP/300yIiylco378Hm756S7gYsRFcvGvzgWXZGfjzxfsdOi7Uehl99rUibckTcJ/WlX9Bp+sORSR9gbISWL79FIZ+A6GNtdkfO0NL7QfjqefBunYF9IxdXjms1jsNhvFToCX3RnfA559/LvRJCHaCSKR4AkaHSOF9+zRJdqjaAr+5JFOkrfCWLVtEOpHUhHj++edFJBbBqBj7qBeKzp5yyilu980OHyMHnMHImlNPPdWl69q1114rUpTcgR1oDqYpHAxoMPTtDz0+UUxM69Er5DdCgxYeIaybBXnCdCXN4HOykRFadJMimSKJRT6nNJhg+j71drgO08TsI5n4nFMDkd9sRmLx2WNEFPfBZdRN5DtDLSCu4xwF9XeDUTJ8n6gVRCKRRCj/piuhjIJk/cVvhozYYqQZpQ9IwLC+8uR7oKBwqEORKAoKhwjMuhVVaIQfDAjRvBOuboCGCPiLdJ4amL20TyAM/ghx8XniSMnpp5/ucjuOKtFdQqFrwlxfC6u5EabAEBg6Ga5uMPnBPyQM/Ux+6BtlsztuD+ytkd2BlsZ+To195tJLBwc2rmmpzcY0wYb4cccdJ/R4KEDLxjkbpeedd55o1LJDyZSL1kgUNsi5HUfX7XP6XYHrOBOG+fsysGnh97DSahI66krzheAuo7nqKkqQ8ddPaLRY0WCxjTIGhEUgZeYpCNMd74d97r8z9H0Z0LdsgM9QVwt9y3pYAwJhcEeiRMeKSc/ZBz3PJvQLjgg3tNNmlAKeklSKS4A2YmyXF48nMUA9N+q2cZJgJ4nfR4eIEIp88ro0uW1wO6bgSCtke7Cz5UrfQW7HZdw3O6USdAl6/fXXhRglwQ6ZJBAJPsNyO6amtRfcjm5E7pZRXJaTz8H0QYqg8nr6qnPpHyAEWltzAOu6YCQHgOg4ICJapOnoNdW2yBQJpvHQfSY8yqfpStLthgQHiQAS2c7pgCRQmK7Df/nNZYo/U3aaz0bTxN/8vjJSgxOJF5kaRPKB2zJNht9KfttJsvCbzOXytyQR5d9S/NjeyUYSkFzOiWXncr5TnLic5eG+ZNoNyRwuY/mkoKzcH+dLkVoSiFzOtFISPyyztC9nPcO/eZ04j4MAJI6k0448nny3ZSor/5VWxjLVTp4Df8tzkNexq39PFRQ6A0WiKCgcItiNClxoWYSjtBQ8YhjvlcotDWGYZzoO31kzcad1hVfKmYIQfGQ8AqlaaBsJGQrdCZu+fgf7V/2OqTc8gqg+/Tu1r6SRk3Dco+9h45dvYM8fP8DbYCN/4uX3IH7IaASEhrtch0KE33zzTXNDmeKaTL259957cdNNNwnypL1gw/7cc88Vnda5c+ciPT3d7bqMeuHIvz3M9XWoLsoVAqzEcQNiceqQBEQFHajql+0vx7wdhbbzNBjx1KrTBCnVfO6aJsih1kb4uwoMU4+AYZyNaNGLC2H58iPP3EEI6mqceKbQZxAI8L5TiC9A0kBaHDuDnaHmSDtdh2X+t8Km13j6BSJV+Y8//mh134zmcwZHrxctWuQy3Yaj19RDaS30312aTneCNmAoTEkpsCya7xsCkZ3eE86AltLHp7a/BwV8/sIjoYWFAzF22jeMBOEyH2sL9uvXDyeccIIgskkSUOzYdnhbigonSUyQYOF3nGlq9gQiSQAaSZBspKgxo1pIDvK7TNKE5CAJDL4vJBkoTEsCgf9SQ5GRYStWrBApQQTfEaaysX7gcShYSxKe2i0kMUjGUNeHTm8UzueypUuXiggSpsHxneY2LDPrBL6T/AawTNL1isLRFCtnBNiQIUMEgULdJOo8kowniULCk+dGYpTl536ZApiamiq+Dzw3Xh/qLrHstC+XNs6rV68Wv2fPni3OW7oasZwsG4kX1odcj4MJJGTsHY8UFHoiFImi0O3Bjz4rG1aYzmClQwtG+1EGV/aJ7sDKhqr/7fW9Z8eKoc6uUktYmXOfnVV1bw3FWj02mMoQqpkRaLV5M+5CBTbrpUhAEFbohVTWbEawZsIQRMLUzhDbAM2IwYhEplaFCZqtwWSFjm16GaraEZnSGyFI0oKbSZRhWhSiNOWg0x2hWy0o279XRJ7YozRjO8r27Ubx7i0tloXGJSMo0vPOln9wqJgCQn2jeaBBQ0h8EsKTUt2Xwd9fjN5JSBc4ipLztytLSjZo+d1ho5wNZ25vT2ayQc5vEhvT/G45O8g5Ey60mU0I9Uew34GR3QCjhvI6C0pqG0UUSpJTWlJVgxk5lfWID/FHiElHQ1H2gZSfOrPYjiOv3QGio8ZJCnKyE2ofjcJOE0fD2clnpIk9cUzBUIpbxvkuFF9nSkNJETTZqfQC+Iw5O9HoJPIK88W7J6JzOJMRKAW50EuKoedkITgkDIMjDri+aDFxHlnMsmPlfDz7Zeyw9XRorKs5+cCS13YAzWatHe1ZWl1Xhk2Mt+nb5+c9l6b2vB8kENgGk+QBSRMSBs7ixFyPHX1+Z+3TfPmbRAGJARIMjNpgJIpMheFzz6iU/v37C/KEk9RfkdbKJFq4H65LQoHtPUaHcB7XY1QKj8F/SYJwe24n3Xr4m8ulpguPx0mmFEkrcdY30sJZisLKc5GRaSRXuC3rHCnKLAX5uYz1FctI8BpJS2WWnSnUXJ/7lucoI124T147rsuysp3NMv3dTkIKCgcLikRR6PZgRcfRX6r/O4Mfc44Qc2TCGawsaMtIETJ3YMVAa0WObrQHrHAvuugil64DrHTI8Puy8fmbfyGuiVwqOoNoij6m/Fk9LJin78OvlgMdJ4KkxS/G40VqTkcwW0vGdKPtGtfBgjmWn7BctwvlbQPXGIbgZsMI8ZtVbyC6lzuBwgGYG+qx9NWHULLXptcgIVJMrBYsfe3hFg2sCZfdhYFHndGtLyNddS688ELRsOTInKtvEe2ROcrIKA9qq1A/ojNOCLyKpw9NwKhExw76/F1F+HKLbRTUHU4ZEo9xyY4k1C+7i/HZZlt6UrdDkx2tAxobYf7gfyI6xXTu5bStcFzuYxtjasdYvvwQhiPmwDhphu8OVFMF82fvArSYtYfFbItI+ew9R6FlgwbjmRdD62+zDFZQ6Clg5BMJAX5fZeSJO8jOvrNOmkznYVtNRgPaC13bp8zJ/cvUFbmMdvf2dr+SHCGGDx9u05eyE6WV67A+ICHC9FDn8svycj+sQ+Qx7Pch7ZAlSIQwJU6m/bi7Bvb7IIlP8mjMmDFuz0GeP8tgf33kOSgoHApQT7pCjwBHAvjxpiYG2XIJzpMhk9TSIJtuD2mVy+2cl82fP1+QIe1RX2dFQmeN7du3i9BN53xthlyyLN5WPm/QLfhaz0CRbhuFXaLno05zXW4LdNRKZqUJ2XoN3rBuQ1DTJ2GGIRHDNdvIhCdgBAttjwk/3YAztL4YqzlGFiyx5mMjSnGS1qc56kTiMC1ORMModE+U7d+DvE22dC5rYyOqi/JhcaNPYXWRbpG7cTms7PAxkiI0An0mzhbWwm0hfshYWBobkLVyIerKvCPYGjdwJGL6DUNwdOuhyBydJAnCkTqGL8sROtoK79mzR4RlM/LEvuFNgoUjdcwbl4K0noKjiF9++aU4LpG3fQOOSI8WkSYBJtu7V1rbiHW5FcgobRkBJ5c1mK1iu+TwwObtJFpzctXzc2DN2gsU21KBfA4+Qyv/giGtP7S4hDZXF9fZ6ZnRNQMMw0bZdCwCA6H5cGSc14bXyOH41GtpbLSRKU46EHpgMNDGM9bq8bKzRNSJACMea6oBsxt9IBe2xvr2zbCU2t4ZESkzcKgaPW4DfBZZq+rbNtmutxeg9Wlyq6FNsEKn4Q3hePtvtjttKF9CRnq0hvYQFZ7sz9X5e7KNIkwUDmWoXotCt4Y9GUH2/pFHHhEMugQJECr7L1++XAjiSaLEfjuSLg899JBDtAm3owMBc1nbUwaCtqIkUv766y+HThTXu+CCC/Djjz+63M4d2gqLFKJksOAxyzqsRwk6glzU4Hbr8ua//4upGGawpUC1NyyT9se3G0e2mH8rlmKbtQy3GkZiuqFrqdkrdAzyGS7cvh7LX3+sw5cx46/5YiIieqUjefRUodPR1rOXNuVo9B4/E6VZO71GovSZcASGn3pZm+sxTJwRcNSF4KigHFmkQxRT+ZYtWybCpNuCp98BErp0A5JioicMjMOFox33n1dVjw/W56BJN9YBBdUN+HBDLo5Mj8FFoz0vl7wH1ozdsP70NQ4WhIDtvgxoJ53lEYniChpD16ceAV+ghU3w1g2wLnOtOcJOt+h428Ga2h846iSHfXnyrZXrkgSxLv6lw+W3rlrS/FtLHwhj/8HQVRh+qzBQeHjQMJhz93uPRBk6CsaJ7RfdVVBQUFD4e6FIFIVujW+//VZYNjLqg+kznorYcbSYFpEMczznnHM6JYBFwTDaPErFchI2VVVVuOeee0QH66677moezbj66qtFahEt8yje9cQTTzRHw7gCz+viiy92u5zHe0vfjt+sOciCdxp1xHv6TqyzFONu4yikwzu5/Odq/THGGIuBmm90LBQOPqqL8rDxi9dRmuUdm1mipqQAy19/FAlDx2Hg0We22bHUjCaMPOMq1JXbCMSinZuwff6nHh8vIDwKo868Wtj9EjH9XOs/uAPFBJnKw3KSRGHkmyejoRQF5Hb261Ksj+QMw6n/DoxICEOovwk/ffKOECElaSNtZw3pA6GdfI7ofOvZB1xhfAUtNR2G0ROE9XCXRHUVrH/8DL0p4qo5KsRDmIryEfb7TyKCyeIfAOOUWUK3pU3k58CyfDF0duS9BL0gz2YrPWg4tKEtCXAFOxhNMM46hi/rgQiktQcGINpEWDgM049sjooSOj4KCgoKCt0OikRR6NbYsGGDUDWnKrgr3RN3YEeH7hYMx2ekiitQCIzCXOzYMJSeAmCuOnRMz/nggw8EocFQfa5PQuXrr79GdnY2rrrqqmZhWqrB0yKVeapM+eF2XNdZZJZCYTwm57dGosg0mY/03fAmqGeyAcW4XB+EdM07JMphhjgcBju1foVuj7rKcmxZ+D0aa1sSeHxVAoyuBeastEM0u043qy237bPBqgsSpS3QLrnXWLuRXL8ArPv+Y3YNW6xroqCf07sWHBWHvlOPRWCE5+lrBM+L3we6GPBdtwcjUNyRP5zP6DfqpvC75QyGUPP74AySLdwuNCQEFgrzakBt44G0POfUnI4gJTwQyWEBeHnFUuyuXYEbb7yxmUQR0SCx8cDu7cBBIFFol2oYfRi6GpqtgyvLYd24RlgydwTG6koYd26x7ZOil4OHC1cTNIlLuj1+RTn09auaHZi8gqoK6BtWQ4+IBBSJ0qZzlzZw2IEZRiMsW9Y5rmRtekZIkPr5OW4fFmGLaPGVSK2CgoKCwkGBIlEUFFyAjVimBtHC7fbbbxedov/973+t5seeeeaZuPPOO8VEPRWCLhy0hLMfbWZKkbTdI0ji3HfffQ77YjrApZdequ6NQpdGflU9nvpzL6qrqloso2vMleN7IdDUMq+6sLoBr6/ajzo3RApxSnwBZnegTFsLqvDYH7td9jGPPPJIPPPI0w6dVKYN+buxMW4NiYmJggSho44zGF1ArRRXYNQbtU1cbWe/vXM+OsUSGT2XvXkVlr32KNZkl+LR3/eIZaH+Rlx1WO92n4NCB2CxwPLDl9CzM4H6Ou9cQqsVlp++hhYbD+Op5wHBLUk0ha4JivOaLr3eYR4dkSxffyyiqYyz5zhuQDtxf+U8p6CgoNDdoUgUhW4NjpJSQZzRIPSnJzhaS3tQjhCTBOmIXSc7WdRWYfRJRkaGEIJ0zoFnBAmjSXgMRpiwHCNGjBCK7uwAUQ+FESUkROjyQzs9pvBwu7Vr14p9yO1GjnQMoWaKT1spAUV6HTJRhSK0T6DSU7B7ux1lCNX9MAgRHtsfM6WBNq1MaXIGz4n3hiP4Ct0XdNkpz8lEYdZu7C+vgdbYiJhgxxFXi64jq7wO0YF+YpmDla9FR3ZFHQyahtgQx+24jNoeuYVFKN6zFaGxiR5FifAd5fuYU1iMOKeUHIq4clmlFoDIPgO8Ij5IQrUjDlskSNrajufCtB7n7ejYEN5QhuzIQOwpNjkIwfJ6VjVY0CcySIjIltV5bjFub3HMbUP8jOjjHwQ/g7KpbAkdKC3yvsBuWckBa2JXR6U4bHGBsEx2EWTlFehVlbY0oagYFSnhIbSgYICT/XU0+cMcmwBjXCKMtNFWdq8KCgoKPQ6KRFHo1qAOCgVgmfJyww03iHmzZs0SOilMlXnwwQdFh4QkhrdBcoZCsSRNKBZrTwww2oRpRmVlZTj++OOF+8/TTz+Nyy+/HHPnzhXlHjdunNB0cXYF8hTf6Zm4wbJE2Bb7AtzvNZY/MVTYH89BJDwbPSMBdN111wltGGfQnYSW0s6uRQrdC+b6Oiz57wNYt24dLPV1GJscjotGJzusk1NZjxeWZGJMUjguHuO4TGJ4QiguHesocppbWY8n/9yL3PXLMP+fl2L8xbdh0DFntVkmWgefeOKJmDZtGhYtWuTQcdm9e7eICOtJmNInChN62fSFKusteG5JBqKD/HD71L74ZU8xvmrD4tgVVmaX4bNN+bhkbAomD+yN6OCD70yh4AbVlTB/+o5II/IVi6KvXw3z5vUwnnEhtAHtJwgVbLCEhaP82FMREBSMSHVRFBQUFHokFImi0K3B0WBarB1xxBHN4fMkJeiQQ02Rc889VzjlkEhpDxh1QjtiRlTQeYNRJK5Gr6l/Qt0SahiQILB3WWAUi7Qx5Sgy1znqqKOEPgrJE5INcjtnkPRhOg8dh5hGRGJo4MCBDus0wopqtH+0uT2gFXKNbva4yb5kyRIhmMkIG3u3I2Lp0qXYsWOHiM5R6N4wW3Usz8jHrpxiTO4diX7RwS30TxjFUG+xotFuZN1i1bEurwLFNY2Y1DsSfaOCWmznz7/FgLwZjXU1zdbHnkRA8Z03FxUgeMcmaGIvNiQUFOCC4QMxMCoU+prlsNqPDAcEQKOgppN2QVckrrJW/IbiXZuF5oLJoMFksKX88LNDsio0wIhAk0Esc0ZEgAnTU6PgbzJg0d4SDI0PRXyIf4v7yntm1ACT1YzMJfNRkTYQvcbOENozhKFvf1gNRug7NjFkxvsnGhQsNCcMqenoarDSMSgvW0Rs+AT19bBuWA0tIUk45jhEMEgtFhd2xV6D1QI0Wt1Gwyh4CE2DzrSddtjKKigoKCh0LygSRaHbg+SGjEIhSH4cd9xxuOOOO/Daa681Wxy7A4kP53BbzuO2tDgmMcAUlM5alfIYV1xxBU4//XSsXLmy1XXpzkGr1FdeeUU4+rz99tstSJSuiE8//VRct99++61FtMmtt94qSBSF7g92tr/ZWoDSzFLcMyMdQX5Gj7f7bluhIFbum9kPwR5u1553jy4plu8+c1jOZKAnZ00Sv60/fO64cWQ0TGn9oZts1WFXDb1vqKnCmg9fQHVhbotvF6//mcMTW/0OJYYF4OIxKZi3sxDvrM3GdRP6tCBR7GGur8W6T/6LuEGjkDJqSnOH0DB2ErQhI2HOyfINiRIRBeNxp0JzQS7/3dA3r4N1+WLfHaC2GtafvxM2usZ01jld81lUUFBQUFA41KFIFIUeh6FDh4roDeqTuANJFkaukCAhUUJhV3dCkO7AKJJHH31UaKJcf/31ovPCacWKFUIPhPtktElrApKHEs4++2yh/eIJIaVw6CIy0A8XjEpGaa0Zb63JRlhBFVpLLNAtFliXLIRl00YxUr8qOw9XfbvAZfdzbFICrj5slCNRUlMNy/xvbIKPJAmGjoShC6Yy+AeHYtyFt6J41yZs+e59rMstw+rsCszuF4PUSJvTR25lHX7aWYSIQD9cNjYFaU3zOwJTQBBGnH4FolIHChtpktMff/yxcBubMNL9t1VBQUFBQUFBoadDkSgK3R4kLpiuwzQRptAkJyeLVBgSGCQzZCqNfToO001IsjAqhEQKI1k8JVHsj0etE5ImdPKRqTtcRvHYn376Sawr01f4m+uwTEw9aA3cpra2VqxHrRWeQ/MyXUctzKjXD07ItRU6qtCIIN2IABg9GqlnmlNlZWULcmvYsGEt7JwVuhcsDfUw19XA3wCRNsL0D/lImAwGkQrSYNHF1BGE+BuF3sfSrDJ8tjkPp5VUorG2BsaAABia0lccxDYb6qFv3wx9ywaR6rC/uh6fb97hQKLQUrmm0YzyugZcRRLFfifcftPaA/uMjIbOVBKTHzQvCNB6C6aAQPSdegwCwiKw5YcPhGjv4sxSDIsPFU5IREF1A/7MLMUx/WMxI611MV5GA9WZLS0ihSSMfv5InXQUIlLSmp3GmCZJhyOSKJqfvy1lwexFkpjXnN86FYDRDBFZxOecqTw+EpRtAXMj9IZ6wK91u2UFBQUFBYVDFYpEUegRjcy7774bW7duFdbBdOwhKCz73//+F//4xz/wwAMPNM/3BihYS/KEaTbDhw8Xo7SSGLnnnnuwbNkysYxEAkduJf7v//5PCKtmZma2cOSxB51EmPozadIkESlDpyCJHSjDFZbF2Ke3dL/xBegAdLx5Pk409MEjhvEeC8u6cuAhGfTqq68KRyKF7vmubfzqLWQs+wVnJluxPyAeLy7LQqPF9uyfNDgeIxPC8Paa/cgsq0N9KxbGnmLrDx9gQcFaTL7mX4hOc0xpY2qFdeMagI4lTZiV1gePHjXNIRVif3kFLv/aZjveFqyrl0DfsRmGOadDS+natsHsU3++OQ8/7LA5xdAy2lPuisKz83ceuG5EZb2HehsBgcKKtzl1ykPdmlbh5w/jSWdDS0xujgpSEFZYsM7/BtasPSLdx+cg8f/rD9DWLIPxlHOBMJt4sYKCgoKCgsIBKBLFx2AqB60qOTJfUVHhsIz6EG1FJHQX0KmGVsCuQKFXany4GtHiNaHtb2tISEhAYqIt399dx47uG7QNXr9+PQoKCsR8OodwHokMXudt27Y1bxMfHy/2SzBqhMvsLXm5TzrruAPPdcOGDSKyhGTB6NGjm7fjb+6LUTEUuiSKiorE+iwPLY8pusqIGY7uktzp1auXw/75vPBcGDEzduxYx/Ntig45WIOS8nicPN7GLgJHIicnR9xvV9bHCt0I1OGAjqTQAFgabLoVUoajpLYR+yvqRHRKR59QEjL5VQ2oNVvQOyIQoX5G6CLqysX+KsqB/ByHWZFBARidGO/wvYkJDsTIhDhEBgZgY34hksNCERfiaEvajMoK6HxvORLfhREeYELv8ECH60+RXs6LCHJPQoT7t9xOItTfhNAAk0uNG4pd83tENzIRoROXIIRIKYKqSxKlvAyoq/X8JGgNG27rpDOyRUtKhhYTj64GnedUVgq95iCQGER9HZCfCz00HAgOtkWjtKG55VXI4x3EQyooKCgoKHQnKBLFxyCBwogIConSBteVm0RPwJ9//onzzz/fJSlE/ZGPPvoIRhdK9XRsOeecc1p1bLnrrruEvkhbKC4uxhlnnNGctsOICDY+GRlCBx973HLLLSI6hSgtLRV6Hc7uO0ynYYehI1EqhYWFOPnkkwVRxnJ88cUX+OGHH8Q+SbrQ/phpPyeccIK4bs8++6zH+x+ECCwwHoe3rTtwk3UpfI00hOJH07GIg63j5Ylj0ssvv4yJEyc6zL/33nvx+uuv+6iUCgcDJCaGn3Y5Bh59Bn7+v2uR0LADt0+1pXsQczfl4Yfthbh+Uh/hjvP0X60TpK5QVNOIZ5dkYEhcCO6dkY5Jl16HYceeDaO/Z8+fK/QKD8NX552CH3fswey35+KBw6fghkmO5GR3w5TekZiQ4jpKwJU7j8TE3hHCkro10CHJGWeeeaawkHZIx4tLhPGia5r/tHw7F/qW9Z4/TxRQPfaUAzP8uqalsr5nJyzffgI0mg/O8bL2wvz2f2GYeTQMk2fCeOzJQGkJzO+9KqyOfQpNg3H2CTaLY/+ueT8UFBQUFBT+bigSxcegne3gwYNFGoOzFgQJlnnz5qEngNEcjDJgmoZzmkpMTIxIsxk3bpwYyXS1HbeR0RwS2dnZIk1Gao201rFjnr7UNMnNzcWCBQtEmg2P6QpcRtAauTWiJCwsTETSOGPmzJkimoUWxIx8of7JoEGDBHEgLY9JmPBf6q7YE0iMUElJSRGCtIySaa/9cmmx7blZk9YA2AxHfAoazobBD0Ga558LnrfzdZs2bZq4JqtXrxbX7Pjjjxfvh0L3gsk/AHpQiIhGMDQ5w0ikR9uiO6IC/UQkiTPYtx+dFCbSRlbuLxeOMQNjgh2iRqhfQq0Oav/QrjcgIBB+QSEO+9FLi6Fn7oZelOdRmVnOsAB/+BkNqKxvQENbNtu6FfqubbDWVkMbMLTT9sd67n7o+bk229qmyIuOIjgqDv1nnYTivdtQsmdru7enbo2pDamXhGHjEdVngBCztSdHOdlDRKQEyKgWHRodZZw73kUF0PdnQuvTF4iOdVhkSO0HrWn7Lo3wCOFIpGdnAYX5vj9eaDi0vv2hxTZFVFF/htf1YMmT+Pl1SXckBQUFBQWFrgJFovgY7GTPmTPH5TKmdyxcuBA9CSQMGPlhD2qA0Gb44YcfbkGiSHD5P//5T4d58+fPF1a5bYERJDfddFPz37/++quYGOVB9xx3YOOUrjptwTkNiX9fe+21zb8pTEvdk2uuuaZF9AXTdmj560wWcDuSKB0B9VR4/OpzxgKTLkR3AaN9eJ9JeOXl5WHGjBmKROlhmNYnUkx8vveVt0zrIIlx8uB4ZFfU49Hfd2NMcrggUdoLdmYt33zqpVK7OoAuHH+E/XGfdNGp7Ays2zbBuvgXGM+7otMkSkSvdEy+9kFs/PLNDpEonmDQMWcjbcrR7RIV5bq0PwYnO1hXLREkirBGHuma1O7q0FL6wJjSx6ZNchBIFC0pBcaTz1YWxwoKCgoKCl0UikQ5COjJ6vbU+vj3v/8tzvGVV17BhAkTWj1f3WrB1h8/Rs6enUIM0S84VIi/HnbYYZ26Tq62ZbQGU3zswWiRG2+8sTm9p6PHdLUdCZ+rr75a/Gb0DImCqKioNo9D4Vi5nQTTgZgG1JPQU98DChq/+OKLLlPSnJ83ezDV64UXXhDRWO5AwolpFJ5iz549IjWsNVttRlGdd9558AZKahowb2eRsNKd0kSeUNPkp52FqKg348zhiUgOC/Dac8B36sknn8Rgaz0uiQzweF8F1TV4+s+VIgrjpROOxMRe3hOZtodutcK64k+gyLGjbc3ZbyNmli+Gvm2jwzJGuhgGDety71FHjuNqG0ab4PgzoPVK7bbfgL+r3N31eikoKCgoKPR0KBJFoVNgKg71PRiB8cQTTzjoilAM0kIiwNwIf6MGzWpGY10t9q1chM0r/sRHi/di4szZ+L8H/wWjwQhzfS0Mfv7NNqZMgWHqCxuS1I5hNIcrXRV32LRpk+io2mPq1Km47LLLxH6dQ9M7Cp4z90dxW072aC1dRZ4fRWpdifK6Cp+3P57uz86pCfWwwOIjBcBAGBEEk0MUOckddvwDAgLadT+4HQVzeU5MeeopHQSmnUmtF+f71drzRqFdbsc0COdlJGRIxDEtqj0kSn5+Pt58801xf9w937z23iBRjP4BqIVJ2OzWNFowXuhz6EJUdmV2OeiWe9rQBJcipRJWq7RCPvD8NlpskrT8DpgCgmAwHqimKPbM1MDZSXG45AzHCD8+T0F+Jhg1TdgZ2yO/qhrvr9uMGWm98ciR00R6jzeJE2FBa/sD+o4t0PfudL3urm0t3lRDUDD0vgOaTsJm8+sJDCaT0ImxmhtsZfACNKMRRpM/DO14r9vcZ3wijPHuhcEVPL2QtrQe8H3whhuSK7D+JuHbhay9FRQUFBQUuiIUiaLgM9SWFuOv//4LFfsycNe0vojbsRALHtyKipxMRASacP3EPgj1L8DPD14heg/Mrz/s0jsRP8iW8sOoFqblUJB39uzZYoR9ypQpHh//ggsuEFa79iCpQqFbirl6ksrjCaivQg0W4aDgBHaCSTa4ArVymLLUmkOT1Hmxx8CBA0WUjZX6E8ZY/J91Db7Ts+BtBMCIV4zTME6LRSgOdOz+85//4OuvvxZWxVJbxhMw4mju3LkiMmPYsGEi1a0nobXnjaTFDTfc4HI7CivzmtiDzlK05u4oTjvtNNx+++0ul1HLp7MwBQRi6rUPImT9OhgXX4z1eZV44o89Yhl9efKq6hEf0ramwqaCqubtJBqsVmGNnDRyMo59+AmExHkWNdI7IgxfnXsKVmTn4qh35jqQFfVmC8rb0FbqKPT9GbAu+K7Z0US3s1v2BNZ1q4RwqUBwiC2Nw9Q2wZs+/XgkDB2H1e89i/wtq+ENpE05BkNPuABhCV3b2vmQREgYTGddDOveXbbnzQfEOdOtDOOnQotx1K5RUFBQUFBQcIQiURQ6BY52M2WBaSu0640M8hM2mURtSQGKd2+GpbIMfaOCgJoSFO8usT14BgP6RFJotwHFu7eIeZpmQGnmjmYRSb/AYIwfP14QBqtWrRI2yp6AxMXQoUOF/grThOxBe10KmzKlwVug2w7L2ZHt3AnftnV+cjsSN3E5dUCJo81rM5IjgChHUc5m5JQBpTVuj2MwmDCkXwhGhES30GThNXRnVcwyMa3EWViWxMCaNWuEnbOz+HB3BFNmaM/NlLa2njfqv0gwSoTXhylbQ4YMcbkdxYY7E6nD9CFnIWtGw9Bq3NmFqiPQDEZE9umPuLJqpEQEo7rSggbLATIwLtgf8SH+YvDcZfmMGpLCAgRZYr+dBO2TE+NjEdN/mMN18DcaMSg2Gr0iDgieSgSaTBidFI/86poWkSjEwBhuF9Y+bU6LBXpRgW3kP9yWriShM32LAre0os3Z13EL2qoK6FUVtt/BIdAL8kSHuS0ER8chKDIGUakDUV9ps2NnpF91oZtvgQuQuA5N6AVjU/RLdNogxPb3nBg95EDL4dgEoKxERFh6HYzCjIqGFkGxcyctLkaIJKZAo603F/kg+FALC4chRRFoCt0PjN6kcD0jXhnFyfqZA1Ss7ziQxQEpfr9bTTdv+oZzO9br3Af3y32wTpURpdyfN+pRd2D5GX0to35ZLppTcADEMdpbF+1irsNyMvKZ7a6eEuXL85PnZn+enM8pOjpanDOvjSfnzEhoTmxfcV/cjtHU3AcnOeDJ+8/2GY/BdhTnO7enOgueh4w45vHYH2hPZLdC14AiURQ6haSkJHz77bciEoPExImDYnFM/6boCd2Kxjr3nXRnMP1n1TtPQ2sK308aOREzb32q3WUioUGdEXcRID0OT84DPnjP9bJnzwYudBO988x84L0l7vfLSuP7o4FxKe0qDit+Ct86VwjtdSHq6qDeDoWU+/TpIyKmSG55AmmpnZCQgJ9//lk4QHkbn3/+ubDUtgeJN4o8syHoLSSEBuCOqWlorG35nrNNE+DCKpcgwXL7tL6tdgQHDGkZMdMnMhzfnn8qTPXun6XD+/bGosspytkSfk2pgh6jqgKWT94UuiXG085vscz8yVsAO7UdJVCcUVMNy6fvwJLcB5h9QtvraxrGXnAzdIutQ5+/dS0WPnkLdA/TPfxDwjDz1icRltBL/M10SgX3MEycDsPow2D55C2bU4+3ERYO07mXi38VFBQ8B50O165dKwYotm3bJvSzOIjB+pXRuzfffLPoKLvSJ7MHO87saFPjj+L/7LxzH7GxsZg8ebIwCxgwYIDXO9XOA1WLFy8WgzR0MmRnm4NPd999t8NxSQSwDcHUYJZzxIgROOUUO8v4HtLOIqH1xRdfNP+W5Nbll18uopp5bdq6rwQHemkEsXHjRtEOY/+F95X7YGS4jKzmc8PIaR6DrqFc5u2BP5JkdGilBABlERht78oJVKFrQ5EoCp0CO8pMy0iMCMHQcCBKa0BjTWWH90ddFInK3EzsWfwDeoUFiHSI5ORkj/ZBdpm2xaVZO5Gzd7vDsurtWzCpVziqsvfggw8+wKDYEEQH2UZhOaqbNGKizbazO6G2EaiuB44aBkQ5dZBzy4FPV9iWRTt18msbgKp64MihQIzTspUZwP4KwNwySoBRE6wAWPm4AkdKqAXiarkcTekJ4OgBKz+OJPAd4Ll5AjbS2ODjNnxOXWmX8BrxmSfhweeU9tCMInG1r7/++qtZU2fnzp2i4mcjg2QW74Pcrld8DLKWLkBMn34i2oCNCTbS3IHnc/TRRzeLI7sCbYw35lehrsZ1VJIzqEUyPCGUyXvYVFAJC4VT3MC/rCVRYgwMQtTYCdAL86BnOZa9or4eC3ZliNQdd+gTEY5pqe0gBU1+0NIHQUt2MTpP4oRkTqOXBaAb6j3eJ0ff/ALZqLY1rEmGpE+fIwS8JSyNDche+5dIwXL+vjHqLzg6Hv4hqvHm0fX284POAU9f1RGCeQyEJvSu3KwSFgFtxFjoedkAo5a8gdAwaH0HQEtoH2GuoOAMWtRXolFotZXB9h3jKxMBf6GxxtRgb2pS2ddXjDZh/cd2KTvJkoBgx5tEQ0xMjJhaA8kIdtY58Tfrd3bS2cFmp5sdXV9HDDAqITU1VUTWsC4nIcTfzinjQgcsKEisz/ZIaxp83RUyuoZEBkkt3hdeE14P/s1zT0xMbJVE4TPA9hC3zcrKEs8G72vv3r3FtikpKQ4EBtuwJM64Hdtgnrbt2gOWh88XCTM+n2zjKXQ/KBJFwStIjQzCleN7e03gkCjN3Im/XrwfY868Gpfe/G67t9+38nes/eg/LeZfNjoJP6z9Axd98Bmun5SKccm2j2fCsPFIGDoexu5GohCBfsBDpwCjbCPKzbjuA+DxH4Ffb29JohABJuDBk4CxqY7zb/wIeG+Fy0NdeOGFYnIHVji0q26Pfo2CIzhy9tZbb+G5557DRRddhE8++cQliUK8/PLL+Pjjj10uY0SQFJEt2rUJ8/91OfoffrIgUWi9TVFod2CjgqNhrZEoxTWNeHvNflS6Se1yRoBRw90z0uFnMOCdNdmodUHSSVQNLMZlzjNDw2A4/nTom9fB4kSi5FVW4/rvf0VJrfsolVOHDMDU1BTPU3pCQmGcc5r4tzuESNP+eOr1/+cwr66iFPPuuUCQJVxm8FC4VqGLIjEZxlPOhXXhT7B6iUQR4r8nn6MEZRU6DYrc56EGBXodNqNUfGtJmg9DFOK1QCFUb2hfUqVHYGeXEQVMrSWhwA42J3a22Xlev369SD1vi0ThNuzYMkqAESncLwmU1to83gbJGk6se1neP/74w+V6rJM4uMgysqwkBHoSeH4cbOJEwoNOiLw/TLUhCcK/GTXCaJHWCCRG7JCw4LaMUuLfJF84SEQCRWoP8ngkqkjIsA3G31zuC/0+Ppc8jw0bNmDfvn1CG0+h+0GRKApeha86Gp7slx/JZ555Bv4N1ZidHo2SvVs92NcBZr8iNxMr3/43hQLEgOCA2achuu9gr5RfHEnX8a6+E5v1UtxqGIEkrXNpFYxAYOc5PT0dLz7zPJA6BjDatCKW6gX4SN8lj+y44fI9wEfLgF7RwFNnAb2jkaSFiDJxpIiYqy3Eqg7eC1ZQFAF27thT7PSII45ATwEr1ocfflg44txyyy3N1+bKK68UhAefRVaQrqyP24KD9kZT/q87cBkbUbfeeqtIESLyN69CxtKf8ce3c7F6xTKRYhdQXw6ruRH5W1dj+RuPo2jnRvgZNBwzIBYpvXoLQVHZwWb0CxsonoAlmzRpkhBr5j1fsWwpju4fI0Yb5+8sQu+IQEzpYyNijBoQE+yPijpbugm1kqb2iULa1GOQMGSsmMdRNz4/rV2X1pJnqItyyehhtlF9J/SLiuhQ893hftDGeOVf0Glb3EpaUWdgLCtB6JLf4D90BDB8TIfKKUFtqVFnXwtTQLBw3+kOZFCXhsEIw+SZwlHJuvR370QiaRoMh021RTy1kYYq7582cCgMoU2pgHW1sC5Z1K7n0TB+MhBn63Rp4ZGCQFHPhkJHIPzVdB1L9XzsRRUWWnNQinqUwCbmzSc2GgGIQgBmG1KQqodikhZv0yjx0iVvrhua6kpGeDLFlhEF7GBTk41RGyRaDC6edbkdCZQtW7aIaFB2tBm1YL//gwFPj8X1GCXDsrLd5WlKcXeCq2vBKGdOjOhlFC7JCK7He+1qfUYMU5uOKeUkR3iP3R1HRHf6+TWn73Cf3kyBVuhZUCSKQqfAiofh4rTZ9BUo4Giur4OR4lFNmgYyPI+MMSd2DivLSvHR++8hqLYYsRP6wN9ogNGgtQg1NTelEPgZNYew0tqSQmyfP7f577hBoxGe0td2XM3Q7uvCcFbncfafrPvwk74f5xr6IUJ3TOPwhwGmdhyH+Z3M23zjjTdEbqg9wix++NK6B426Bgs04bQDGFDPEm3LBV5ZBL//XgTTlTaB3WQtGFcaBiNCs5VpV0ACNgcFibBJVjzUl/G0Yue9oR6Hs/Ba3759RU4xGzc9QUCLDZaLL74YCxcuxCOPPCIaMbxGs2bNEgTLp59+KtJlWnNfcgf5fEthM1ehqjweRzNkSt25Z5+FgQNsVrnb54djZf5qvLb0d2zIq0TszH5ICbeN1BRn7ETB3h2ozMkW9sOTe0dixKh+OOqyS4SlMLFq5YpWSRTxfNfXizKyfBTHpZsQSaPVy5diTFK4sBr+ZXex0E2ZkRYl/ubryPevVAcCg4KQFheOY4YkY8LJczDw6DPEvtmA5XPdUfSNjMAlY4c7NM55XwK8RSCQ1Nq+2a2NsTdgrK5E0Nb1MIiUOM9JFFdgGk+/mSd6rWyHOpgOpQ0ZCT0hGda1Kw7o4TCFqh3vus5nkfWZZhNq1oaMgCGtv8fbG3qlApy4r4oyWNetFELIdkew/c3yie+H3bPPzuug4TD0994ggcKhC9GughXr9RKs0gvxmb4HVWipyxQKE4xWDWO1WOH6Z9INol7wBdgRJnkiCQZqT1DPhG0aKSjqXKexrmYKECMDGJ3AznNZmU202x3kIIcUPLWHFLK1J22cyR4eUx6b/9qv11rbQR6PKcFyf7LNJfctRWnlfrncviz25Zbby8n+mtgPBNlfN7lclpfLnPctf8trYb9OR+tjGZ1CYoRECqOG2A5x1peT14Hp59u321L7qWHHe+xKo0+WmefECBT7+yf3JcVu5d9yuavr4e6ay2tq/8xwn2xP2e/Tft8KXROKRFHoFGpLC7HklYdQmdcJd4o2sHvRd8jfsgrjLrqt2f6Ybj233XabSHW48oorsPajF7F/wwpcMjAYmcUWPLskQ3QOj0h3DN3MKqvDRxtyhBbKndPSkRjmXkhx/aevYM/v32HyNQ8gJLZ9YZIVaMTVlsXIhGOawy69HFVoxGXm3xGkOb5+/zKMxXGad5wRDm+Iw9zKSXip4ScshhEvG6fBaEzDNZY/ISVAbzEMxynG48XvYM2EELvPAS13Tz31VLz44oui0mPqh6cCqCRJaINMkTN7fPPNNzj22GPxwgsviPDLnoKxY8c2W1xzevvtt8X1evrpp8WIBwXt2gsKn910002CdKJoLYXsnPHll1+KlB9hrXzVFcj65n/IqLKNmtWWubfZXZtbgXk7izCpd4R4P2IZGZKTiV8f/UezXkb22qWtlo+hw0wV4r+0rWaorWwkNFh0vLs2R3TZ6i1WbMqvxL8X78GcgXEYkRCG99blwBidhM++/BoJ0eHCCjnMi1oMv2fswzHvfu4wr1d4KF458ShEBvW8nHGFvwlhETCefUkzcWJdvlikmXmKxoQUVE+YhpCQUAQFB0OL7YRWVHAoTGdcaHOMkmBjfcG30EtLYDzxTJGS1gw28GOaBOAVFDqJHSgTEbZf6nuxUS9BDVxHX3L+N3om9qASSXowBmkRGAQbCeALkCxhWjFTPnbs2CGiFlauXCn0NWQKhwR1KUiesP3C6F6iLTcfgpEqubm5os6m7ookGdgW4EALU3I4yMA6kvt27kwzQoZiuOzks2NPMoCptCR/uNy+w26PTZs2iUEa6qDx/LjtmDFjhGg9t+HfbHNlZ2eLSA1GqTK6gudOIkFqv9D9kiQEz596d4zUYbQGCSiSDRxMoXmEJFl4PUnckFySwqhcl+WePn26OA6XM3WGBg88DkkMzmf0yHHHHSfakp0R5mX5WU6ZssWobLaRmALlHMXLKBSWk+fCe8AoYab0uDM6YFtu165d4ppx8Ir75P2bMGGC2A8npkFLco3EHNO9eBxJ1pAM4TXhwCHTy7iOTCMj6cPUMl43+cxwMIzRvzKSiNeKmjhMP+spGoI9FYpEUegUGIVCi+K68mKfXcmaknzUlhWiobrJBhQQH7Bly5bh8MMPFyNu5dl7UZ6xFb1DTaio8cPukhqkhAUit9IWTiqxv6IOu0pqMCAmBP1jWg/RY3pPfVW5OEdPUKLXowA2YdxyvQEr9ELshWuR3fUoaZGTsEEvQV/dRlQwraYPQlsVYGNFxY8sP8CsFAhGjLCC8S+vR8SOYiHOyfzjEVo0QrQ4DNEikY1gMJM+XQvHZIMt/cMZbEQwv5aNDn70WSl7An7wWUmzMmaFbo/PPvtM3DPuryeBIyJMZyHY6Pnwww8FuUCiiJWicyOMjSxeXzaU2LDjNXOuKHmNeK3oqEMixRXYcOM6V1xwDgYkxeCP/btQVZDdZnnL683i/TiibzTSo4ObBZ2pmSIbHgH1lYgLNmF/VqYoJ58p+xERniejTgiW0YFg42hTVIKtAVqVBS0wBKa4JFRqungf95bWICrMgHHjxzePotmDDU02iHjt2CBhg6KFLktAIBATD1RXilQGezRaLCh10kUJNBmxs6QUyWFhSA5reU9cgpbGUTFKJ0LBrcisltKn+W89c7dN7NVZJLiyQlhXI8ixvtHjEmCOT4Y1PByGTjp0Cfvj5N4O0VdCnyw+SSzTevWBRntmBQUfoEivw3a9DPv0ahTAfUqZFTryUYsIvQo79XLEIACDfJglw7qW9YeM5mQnl8Ki7Ew7C9+TiCDhwDYU62N2/lmPuz0Xq1V0ltmpZjuJnXRuI6N2WY9yuSQQWAbuVwrJy2U8JskQkhgyCoJ1LTvh9ha/zuA8EgHcjkQOO/1SE0UO6HA5O/ckBdhOJCHAzrlcR9pCcx8kSxh9wWsjiRt5jmyPyOvBfZCAkjoj3D8nlpnXlpE+nHhd5DJuz8hV/stjEZ0hUbgt7x/bDzwOU4DZTuFxeZ8lkcXys6/AeyttitmuaC0SWt4XkjM8J14j52vG5VJ8mJAitNyW58vrzmOzLPK+s6zcH+dL4X9OMgKJ90G2S7i9tOhW6NpQJIpCj8VfWaVYmV3uMM/CisE3ATOYa92N+6yrmhsLjEZpD/7PugZPWteL36O1GHxnPAbBrbyiJ510krBFu/fee/HAAw+IeWTEmUrzyy+/4IYbbhCVnlQW749wLDDOwUfGItwA34BRF4xQ8IVtb3cAK8EnnnhCNDBYqXOUyBkkBBi9sXTpUhx55JG4+uqr8dBDD3X4mOs+fQXBy+eisaYa3jqHEwfH44gGC26/9gok9B+K77//3uN8azYaGI3DBsTxxx+POXPm4KWXXsK9d96Bf7//HurMFriXqrWlfc2fP1+MotFd6PHHH8dVV13lWMa+A2C67HpYf/sR1tXLHJYdnt4Hr510tEOHMrO8AufN/QFT+iTj9VOOaTsP32CAcc6p0FL72QgbBYW2HpkJ02EYayNTJfQdW2D55hMYJkwTmif2MDfSVc19J63TIJl5zEnMtQACW9dZUVDoDLaiDF/pmchvjnNtHRxs+lrPQLjmj6nwnRgqO60kBdgp7d+/v2gPMbKTgxjUErHvTDMKZdGiRTjxxBPFulxP6qG4AvfJaIIVK1aINtfJJ58sBvW4XxIl7FQz4oAWxEz55YAHI6elbhmPxzYAoxGoq3bZZZeJsrLDzXKyg856kLbNbE84DyQw0peDaCQ0SOL89NNPzcvY5mP9S50yRjo8+eSTLepvDv6wncY0XArXOqfvyigM7p/1MNssLA8HfkiEsP0ZHR0tyAxeA54rheh53hxI47nwfAmWn5EWHPj57bffxPVlVHJHwbKRZGKECMvA68vj8jqSrJBOOyRu/vzzT0FS8N5Icqs1MFKGTjkcDOP9t1+fx+L+2V7jwCWjjbnO8uXLxf4ZcUKLaRIpjMLhfeF143aMRGF6GMvG/ZOY4bPC+0bC5pJLLhF/y+eWz6Ynts0Kfy/UHVLoliDjzrDF3pHB2PvXfNSUFDYviwgwYUKviFbJEopdegJqrexf/Qei+gxA4vDDXNofcxRmoZ4jxFylkFpHUA2zmIi9eqXIKx6mR2G8wXXYNSsRsuuM+OCIgKwYv/76azEiMGPGDFGxSeafeisUd7NP23EHpksxCoCpKqx8XdnwugLXddfZZjlPP/10EcHA8pJA8IYlH9l6VlisQJ3BSnPmzJkuVeu5HSt9VuytEQIsZ2sEAkdB2AhxNWrAa3/GGWeI60eHHVaerChZEXPfHEVZs2aNWGYPVtDuRiG4DUkNjmLwHagp2IHF2/aJZaEBRgyJC0VBVQMyymqFew41SDbkV6K0tlEs8wSBJlsOcGVFBYIqKlo0PFi5H3PMMWKUh2SHrOzZWGAaGJ8dNiTYeOIzyvm0C65pbFtkl40HNhjZEOS5siHkcuSdk/GA00xYgD9OHtIfw+NjER0U6BBtQsee8vp6VDV4SmxqgH8gNGEffAB6fg70/FzojIA5CNAL82HdtA5an77Qwr3vEKDgPWj8Rjp9J/XYeGjDRkNLTIHGaBR71Nb6lEQRz78iABV8CFkr1Ohm0Q5qaKEC5xqNsIr1a/T2DTR1BKxP2HklccL0WkaMMGqD/8qUHnaESYqwPSLbMG1pUbBeYgQJ6yjWcazTSShQjFbo9Fmtoh4jEUHChOsxEoOdaLYH2AZiGg/Xk0Kp7Gjz2NyedS7X5f5YlzqD9SPfce7LPk3IPg2JbQxOzkK69nodPBbL7wypX8KJy+UxeI1YJpaX58fzJvHDKBaSBiSAeA5si0rih+fIc2NECK81z8de/6W9kOWX6TssI4/L+8F0HZJDMqWJx+M1YBuQ67i6lvb75blyWxnRIqOw7a8Zz5/PFH/zPvA32zh8nmTbhSQJiTAek5ErnFgO7lPeM07y3sgoGYXuBUWiKHRLMLeTzPaGz/+Hxc/f7bAsJTwAV4/3jrZIY201Vr79JOKHjMXRQ8bAaGhJJuzQy3GRZRHq3OQBdwRMA7rE8juuMQzBeLjPXefHl5EMnAjm15I0YAQArW/vvPNO0cltLxhJ8M4774hRA+aCegPU7jjzzDNx1FFHCeJhyZIlXiFROALx6KOPipEjZ7Ai/PHHH92SKIwasR/BcQbtAzla1FrlxtxknhvDL51BkVnu//nnnxdWw59//nnzaIMECRFOnoINL+qlMDrjo48+wgXnn4+3Fq4Vy/pFB+Ou6SHYWFCJD9cfIIc+3ZiH9Kggscwb4H3jtZPPm0zRohbMfffdJ86b5NDBRGJoCF498SifOimQ0LD+2fI58xX0bZtg2b4ZxrMvVSRKNwTTfYynX/B3F0NBwaeohFnYGpMc8QQU3c9FDSrbGa3bUZCMYDQFO8Ssl1iHsuPLNFy2HxhdwU6uHOCQHeTWwDqPbRiZ7sFt7dsZ3J7kAgeiSC4waoUDPbLDzd/UZ2HaLyMYuK200mX9yonRHByIYfm6Aliv8pyY3stzlik5LCfbWoy24TVmNCnXkefDthbncXumFrUW4dOesjDtl9ftq6++EgQN7wfn89iSMOF15jqMfmHqVGskSkdAwkZqrci0H14L3le2c2XaEwkVPlsquqRnQZEohyAq9+/G9p8+Q/9pxyB0zJQO7cPKimfBZyjes0UQDb6GbtWx4+fPhS3rkOMvQEAr+d2+6UC1EtaSUQT9pc8BVw5FqTHAtYfTCqjlsqxi4JWFVOJ0v+9pJwJnTWu1ZPbny4qc6Q/8t1nos6FB2O0yEoQpPiRFnnvuORFCeNddd+H6668XlYDD2drZ6npyPdkwodgWoxAYAeOunL60CeQIANOJZCgnwXMgEcTKlctkpW6/nPO4zF6fg5U+XY9khE9bcBciygbDHXfcIUJyvQkeL3/Laqx65ykMsuTh3JFJYr7ZouPzzXlCA+TcEUlYsq8UmWW2HHW9Hftevr8ce0trMaVPJPoPiIXJyeVK3kf5vEkCiSNuTC0766yzRKoZhYklOI+jgUztaQ1seFCYmMfgc0qxOnf4ettO/P7TIpfLThrcDzPTbM91bEgQHjpiKopranHH/N/bvAZGkwnXzTkLA/o6ztcGDIEhKBjW1UuBEvfivd6Clj5QHFOL913Iu4LvoCyDFQ4FMLo1FkEoRp1Hg0l0IoxDEEJwIJLQl2B0AQdEOLFDzehTkh9MB2H7iBG7jJRgx7eF/pYbsHPMjjH/ZXQBxU1JltiDHXmpG0LyhLoXJF/YkeYybkuyhG0Pe9caCZIUbJ90JTdDaRtt356T0SzSiYZtMGkLLNdjdAYnXm9XA04dAffH8jB9iNFFbG+RrOE1Zyo17w/JE6ZQ+epbzPPmPZKRQYTUtJGp9NJ5p61UIoXuB0Wi9HBYLWZHxX4KaOVmImvRV4jrnYbkYeNa2jcaTW1/cHQr9q1ciLzNq0TKi++hY//qxSjN2IEBs09rlUQ5WBDCYbCiIbcEePk3G4licqrsxqcBF00BQgJaEil5FcDLJFHMLbdjLlKjBZbGfqg70wI/aDC6sT9mhcQGAUMDGU7IHFcp4CVFrD7++GNhicyIFaqac+JvRvMwOsSZRGkN9seTozWssF555RXBxJOksV9mvx1DYFnhepoe1BZYOXGfbGQwvPTKK68UIZ72x6QmB9NLrrjiimYSxX47Np64zD5ChOfHyBZGWriDFI7juqxIna3/uIxElSQS7FX5uUw2oFyNeMn71lrIacW+Xdj6w4dIA5DW3yaSR8HYp//ai6l9onDioDjsKa1pJlEkyIeQFGF13mixit/O7/umgiqsyi7HfTPTMap3ZAurcAn5vPEasLyMkGG0DTV5pKuTBEkVjvxRYJiNSV5/aTdpD4Y981nifaN1dGvfoj8y9uPFZbaIF9lQE2tbLMKRZ2KvJPgbjYgMDMSV40fiyy078MDcv5oJJT/R6NPImjTvk/eF9+Skiko4eyIZ+vSFntIH+q5t0A8GiZLSG8ZJrklJBQUFhb8T8stMd79YLQAVeoNHJIofDGL91jTfvAnWC6yr5MTOtXSNYT3EKBG2DehKQ4LAk84u6zzuQ6Z+sH3FdBJ7SHFW1nNMAeG/JE/Y/uFxuYx1OZe5agdwmSepRR1Fezv19ilC9vWyTGuRhAkJFOcoY14jTrxenhoVtAXuj8fj4AyvJaOCSaaQtCKhxbYEo1UYPeOc0uQt8LxlCpdzG03O4/ny3isSpedBkSg9HNt++hSZSxc4zKursFlzbZ8/F/tWOY7iJg6bgNHnXNfmfjWjEeMvvg3l+/di6f/+Dw1V3g2Ra3lADWPPvxEJQ8chMCIaXQEUjr3W8ic2W1fZcoFPGQv84wjHlfaVAGe+Apw4CrjxSNc7On4UcLMtDaEZO/KAmz7Gd9YsbLX8iHsNo13aH/OjzCgTCmtxhF9a4fJvprg4V+rewH//+1+RfkKrYpIxBEW1KKDG+UwlYvqKs8UxO9RffPGFEFAbMmSIS2eW9oIWv0xpoSgXreSkjVxbePfdd/Hee+8J4TOW09nu0BOwIUYRXTZyeN72JAorby5zpbdCHREuY0OK1oGuRpmoG3PLLbe4PC4beoz6qd38F+pWzXNYlhwWgFunpGFncQ2e/HMv8pzcqYgxieFIDgsUosvL95fhwtEpiA/pHKnFlCWm9zAS6bvvvhPPIUOm3YENHK5LooTpP95o3JAEYwpbeEkhLIvmY97OPTjpw6/w9DGzMDKx5f01GQx48piZGD2gP4zHn97snvLqq68KokdBQUFBoW0MQgRO0PrgE53mxW0PqjEK5XgtFYM139kbuwLTPEjm08aWunGsq9jZZ6QCO9oy6oODHJ6CUReMcGEErmx/SchOs3TXYTuDdZ23U0o6A+kO4ymk6GlrdTaX+4r4cQbJCg7ckbhhxDGjUXhfmcbDMlDA1tN2YUcgdWWcr4fz34pA6ZlQJEoPg8XciJrifJu9ITtze7agYKvrVALaoTpbovoFBqMyN0uQFhxmCI6Oh8m/pW6FphkQlToQpsBgGOzEHX0FfpAie/dD3IARzZasFJOlBfHBgKWhHpV5+wSBExhuC/c0W8xYnbkdOwqzgL6xwMhewDSnsetlu4Hle4BhyXY7swLZpUBRJdA3zvV2QX6A0SDyjPP0PGEL6A6MAmEoqb26OkdFqJjOSpssPXNBXYEfdqZgOKe5tJbGwlEbHs/eqlja9DIKgWroLIvzSARTfljJPfzwwxg/fjy8AXbGWZb777/fI+0WnY2jqgpkbt8mtrvnnnvcbseGEaN5GE3CRgH/tq8Y2dDiNWbDifnW9hEVTElxp/fCEQkK97LTP2XKFJdRORzp4X5ZOfP+MgRZOh7xX16/rKr92LZSR0W9GfUWHdFBfgjyMwr7borKkkgJDzAhLtgPJbUHRn4ig/wQEWjC7xkl2FVcgwZz+2z02Dhh/rGM3OH14X3gOcsRP5JHXI95wtK+mUJ+nMe/+ZuK9gy1bQ9kdI9slPJ4ch8UthPh2hEhiCsfhW/27seSrBxUBgShMTRcbJdXVS2iUNioio+JwYQRwzFh6BAYp01rFv5sjz6NgoKCwqGOGC0AgxCJBC0IhXqtIFJcdctZe4bDH/FaEAZqEYjVDq7zmdSvYIeb0QGstziYw+hVkiHOUZGtQUY+sv5mR551NLVNXHWcGX3Cep8DLqy7+LeMjCCJ4S4yQy7rbAdcEhqu9sPyuLJQdoe20rLl8oOVyshzY33OifeXUa4yrYr3lPN8LdjqrXN1dX9USmjXhiJRehiqC3Lwy6P/QEN1RTPZ0B7kblyBH++9UPw2+Plh1u3PIn7QKHQ1FO7ciD+eu+ug6LEQJRk78NM/L8WgY87CmHOvt82sqAXOfx0IrQPm3QxE2Eay20RVHXDhG0CACfjuRiDKw+1aASvliy++uDl8kKrkxN13343TTjtN2O+5AiscRoY4i12xk9zRjzc7uhQ9dW6QMHT274a+LwOWrz6Ede3yNitm2tex433uueeK6A866BwsUTDmatNukREzJGj+97//Ces8V/hqSwG2FFbhtqlpSAh1VNk/ZUg8hsWH4rkljrnanankH3vsMRFBw9EegpaQRx99tCDIqIdCkozgNaNTFNOs+Cz9+9//FhEejADi9T3hhBPafXy6KzDSSQrTkQTjcQk2nOhWNHPaVPzvpRdh2JEDLFkpokzykpJw0pw5yMkvEOtSB4hpSBGBAUL/BE4uPAoKCgoKnmEIopCuhaNEq0c6wvCVntHsNOisnXKaloYxWiyO1/oIbZSDCQq6csCIuhmMJGW0JKNTKPruqRaKBMkTEvdsa3FwQLa5XIEDBjwWnf5YBk6StGFbi4MKrtJ3ZVp2Z9JfpKMOB4JYRvt9kTxhZGxXaJt1FDJ9iEQY20oU4eUgItsX1EqR4rfdCZLYkg5BCl0XikTpIaDQK4UmS7N2oLa0sN3kSfN+zI2or7Sl+2gGI3I3LENjTZWw9zX6eUfHwhsICIkQqT1lWbtRvn+3z4/nHxyKhCFjEZZol1JD0ri0GtAsQEwoEOjhKAb1Tspq6Edr2y7YxXWNDAFOGm0jZr5cDUwYDjiJXEqMGzeuReQIO5SrV69utqKTuaj2oGo8LYfdnrO/v82a1gkUX2OH3tUydv5b2yfLwfJ4C0wnYlmoecLGAMHKlBEerEi3bNkiGigwN0LfuRW6pYFsDsNByAhAz9oL65YNtp2FhkLrbVOQ58TGFhs43K+ryBxWzscdd5yo5EgW2JNOMt+6o5ARHSQbmONrb/NLgrRwwxJUZtvSZWrNFpTXmbEhrxKRQbaGXFaTDkqQyYhQfxMMbggxi65jc0EVcqsc036KqhscjrdvxUJEpPRFdPoQcU3sG3b8zRBa2kwzakZaarNhw6gk2YjZuHGjaLjymZQidAypZoqXPUhcudODYcOC+2C6FMFrL1OxOI/Tlu078OW8+diZkWGzv16+Qow25pSVo7IpTJsjU+5SuIYPHy5IR0ZTsdHJVDWHqCI+H6npPDj0jF1MeIa3YQ0MRmNiMvyiYqGaUAoKCl0ZJs0Ao65hqBYl9E4YiVKGBqGR0hyBovkjAv6YqMWjvxaOQBjd1ku+goz+YBQl6zESJ9IVp72dbdZhjLTMyclp1t9g3WfvwMLBLbYfOF+2T6Q2CCMkSMKwrmMUJ8sj60ap2cbBgs6SKKwjuV/WhSwD9ysjHrhfHluWrTvCXoeFUddSc4URR2wLtpV69HeBz6LUDuT9kLpyvD98lnhfGNnkzfaygvehSJQeApIfaz76D4p2NHUIvQDdasG6T/4riIM5j70PYxfRIiGi0gZi5q1PCYtjltHXYAdy+i3/PnhEUnos8M7lwOu/A+e+Brw9Geg7ucVqrByor3HNNde0sCimWGprYLQIhVhbg6vKh5Erl156qctlnE99kvbus6PgCBKFcamtQRcegpEKJDUYOcKoCVZQvSPCYPn+M1jDQg9szIpr8S+w5O6ylav/YBjPvdyWyuYB2FiiBgePy+M7N3R8lQNbk78fG9/9t0gxk6i3WPHhhpb6K22hwaLj442utws02UYJq/KzsfiFezDgqNMx+ep/uVyX14A6PPbnTIKE0VESXCYV+yVIvPzxxx9evW60pKYTkNzPP//5z3ZtT7tqbk+CjJEvTPtysMjWNBhmHAWUl8L85n+AqgNpbd6COSYWFUecgNCICDjGFikoKCh0PbDWPFJLxkwtEUcgGYV6HbaglNWsWDZMixJpPGkIFUTL3wkOPDFSkp1VaTnc3nYJiQlGPjASkmm9jDQhGcNBJkmicACEzj+sCzmwwk6zJGuow3LYYYeJwR4OMMycOVOQ9Ux3ZYQwB3+oacfIis4I8bMsrL9IxrA+YzlIqLDzzkECirE6uwp1R7A9NnnyZEGeDBo0SNwHORDVFcF7ymeIJI80GyDpxvvE1HcaG7CtrUiUrg1FovgYDMejFzw/XhwVt4fzCHOn4Sv7LI7Yu1kUEBqBUWddjaKdm7B70bc+OXzSyElIGT1VEBkSB51Z1g4w3vzgfajvwrKAbBTeNhPILwQe/ObAuudOBAYk2OyL1+8TLjsCuo5JS3YgaXM2fi2vQYVT6oXj8WyaNOJ/OjDXuhu7LatwnWEokjTHjqh9/ilHRdixZ4eeOiGMNnF/iI7lrba23cHMhZXHYyVEQuiYmTNgWfEnGgMMIo0pOG8/Hpk9FW+v2YR65vy28XroRQWw/vK9uPZWXcd7azdjR0kZrrvuOjHC4VwZy3OldgltfulIQ4FVt/vnPt97T1SOjKawdwNyBhtPTOFhRfvkk0+KCB+JwOh49D/hEpTsXI+CDUtbPadl+8uwu7RG6KYYGzR8sSUPxqb7k1FaCz+DhiPSY4RGij1W7C9HXlN0CnWRmMYW03+4OF+SViNHjhT6IwQddFoT4qP+y9y5c0VaGe2Ked68Z0z7ae37R/FhZ7BR9OCDDzaHTrMRTAtpgvu88847RYP0ww8/bJ7HZ4Ph2wSXUZS3Ndi/563lKOu+/+D49AgKCgoK3oCtqWL7Xhl1A+IRhFDND+G0MG76jMUiULjxGOEblxTWCRy9Z2oNNeBIDFDAlYL3jPhg1CojENlxZRSIdMWRoqDym88OLNvr27ZtE/UL90sigwMz1N8iyUHShXUzIx0oTE/Sg5EEdPPjsbmM++V8loERBSRYpDWwrMtIopDQIHlC8p+EC8kAGTHDiFQSAjwX9heo18X0I4ro81zZ4eYx+Zvl5HrffPONKCfPmcfjvtl+YJuC50PRehI0vBYsI7VEZCoT9fFYZ7JMLB8jbXgMlovXg8egJh6jZlhO7p8Trw/nM6KF58yBEZaTRAb7QLwGJGuolSadc1hOnhvLynK4Ijt4P7g/RvWyHcH7wnPgvjif25JkYP3OcpOgImEkbZjlPlkuRpby/Eho8W+2WThAwntIQo3nS2JL3n+SYjwurwWvMdfnveZ5Mz2L15Nl4LVnu4LPE8vG43M77kf2+Ripy+1ZHpaXLpYyBYmkD68Ry8Ly8xrzmHw2fCmIq+AdKBLFx5AvP186qSFg/4HwhtUXU3mEzbCPSBTulfunXTJTfOwrQP+QMAw+9hxkRS/E7t+/80kZ4gaNwrCTD4xodwX8aN2HzwP2ovHSw4Clu4CjnwXqm+4lhWITwmF85y/oO/JE9o5m1WEwWzF69V6MWLQNyyvrUKEDRrOFCrViM6vVBVnF6+lnxAItByusW3CWIR1JaKmhIp8lVuB0zeEoOjvfrLilP71ku2WHl5VOT8i3ZMV0JlOIykpgDrZi3pr1OPv553D/zMm4ecp4/LYnCzuKbRoaEiQSaH3LyqrBYhFWt1pZCaxLfxfLLVYrPv/4G2yorheNGzYI3IEV4m233SauPwmS1t7x7779Rrw/BqMt11VWrM5aK0xpefbZZ4Vux0MPPeSwLDAyFn0OP5V+UMhZt8RGJLlplDLFx/6Z+nV3CfiU8Zmks2+wnxHT06LQKzzQocw5lfXNJEpgZAyGnHCBEJ0mqHbPSYK2xq3hnXfeESQKdVNoqy1x4403or1go+KGG25o/vvWW28VrlQEySwSWYxuofYKrzuvMTVtSN4QFD6mrXdr4Ha8L9xW2ja6Bq2RjXwA+fLCa+D+uujomYKCgkJrYF0UjQAx9YJvBT3twW82O+ns7LPTTzKFJD3b3uyosoPMbzk71+zAOkdFSnB7doDlICfJEbarqFHG7VlXU89ERo0Q/M2IFKazMrWYdTo71TwG1x0zZozoqNunDJG4YPuMHW+mcfCYjEQgAcBt2Nlmh50EDI9P8oHpsRzAYJuDZICMVCEpwLYMz1mWU54nCR2SFdICmGQH/5VirExXZVl4XjxnduK5HY9HYkGeOwd+eC04UEcSRZJJJAJYBl5zkgqsP0k6kBggkUOSgRPLSkJGasiwnmbZeC6ttUN5D3h+vL4sH49NEkaWh30s3l/W1bzmnJyjN7gNz5ntKk4sJ9s5JJRYFtkW5jNCsoWkCMssbYl5fiw7rxev07Jly8R1kJoyXI/3kufGc+I9JSnCbbg+12U5ec24LtuTfBZYVl4jngvLwv3x2eGzQhLFGw6WCr6FIlF8DH5kzjnnHBHub9/4J/gx60hHwhnb5n2MzGW/oDzb+3a2RG1JIX5/5nYkjZiI0ef8wyfH6G643zgG5+j98A/LX9jvvPCJeQh8azEujA9GXWCySJcYtWoPjnrsGyRl27QciKScUpz35Pfw87NVIN9vL8CmgirHfY1LBX68GXcMPRbHG4ejL2wOLc5gpcBniZUXf7PSY+dRds5ZubMyoH6InMcO6EknnYRuD12H9ZcfoO/bC9TWYEKvJHx/wWlIi3R0HLLHBaOGYlpqCj7esA3vrtuMF4+fjbiQzgn88j2fOHGiwzzeD0ZKSCLl5MEJGJGaiIlX3ouCihqhvXHGGWeIlKz2Yk1OBV76KwOHpYRjVpprUbxvtxUK0VkiKSwA541Mwsb8SizYVYw5A+MwMiEMca40eboJGCUkn2E2RBj+yqih+fPni4gsjna1F2+++aYgfS688EIhTOdWcJChuKdfCD1zN6y/0mraCwRyULAQwjWGRqhIFAUFBQUPwY4/IzQYPTFt2jRBqpA4sO9Ye+K+Q/FX1uNy8EkKfHJb1gXs/Nqn17CjSxKFEQhse0mwMywHSLgOt7OPtpBRtJJg4XF5LNmh5/FkhAbThuS5kGRhv4JRxjxfpgFJHRBux7KxnIyykYMAJGWo9UXCg8fgvriME8tGEoLRKlLIlAQM90NigNuRXGDnn8eQ63AZf0tnoiOOOKL5mnEez5fl4L45n+fAfUiiQGru8dq1lnIjdWKYKs7tOclrJCOK2kp34r1nmjcJGU6SHOF2nCThJO8/04K4Hq+TvY4NSSUe76KLLhLnxHWk5TPLyXORESaSMOF6vM5cRz4r8nw5jwM8vJfShYn3i9eO96w7iuIealAkio/BF9TdKDY/MN6IBKjIzULB1jXwFSyN9Sjcvh5BkbFNHYWWI7OmgECExqcIUVoK0XoDRv8ABEXGICAk3O06jIQJjU9GbVkJLA3u1dE7DM2A4Og4BEXFNZ83P3JDEYUEBInwVIkgkwEh/kYgqwjBuaUYMLEPKgyBYquokmoM3mqzGa7RgKggPxgsFsSszUCYvwmh/kas3ZiHvBybgKnZqqOszgwMTgRmDsIgYx9MM9jpMjiBH3uOwpAB5/PGvzmCID/WMvqELLycR3a+R0DXkbt7Jxp2bUdSWAhigoMwI603SmvrkFlWLhxYeoWHwcjQiyakRUWgV0QYnv5zJTYXFqO+KRrIs8PpYvSC15SVpRRnY6Ni1qxZYh3O4/0ozM9DXIg/Kmp0VDdakBIegMHxYRg7sC/W7szE4sWLMXzwQFTm70dgRAz8PHCJYcXN+7gntxDbi6pxeN9oDI4LdVnO8MASB42TgTEhKGgSjU0KDcDAWNcjhWH+RsQE+6Gy3oKyWjY40G7w+nAERgrN8l+OIPGasSHiDTCcV1ocM/yW94Ujd2xY0kHIGWyAMvSXDTmOjLHx59xQ4X54X5gON2nSJLfH1kx+0Hqn2aIAo6KbovB0vlhCyNhj8J433XctJBRan76AXwBzlTzfh4KCgsIhDHZyWQdz6ijYtiNhwMlTyI44O73tPZbsB7TlDCRTZ+3RnjpUkiXuIhtYdgfdLzvw3NqKiCAJ4QvIlCZOHBzpKEhcuLqGruDuOthDpge3Bk+fQxnNpNA9oUgUBa+ATjlzHnsPG794A1t//Mgr+4wbOBLTb3ocfsEtO4gS/Y84BamTjsKfL94nnIS8DZI0s257GuHJaTC0YW87oVcEThua0PzxD/EzCi0KZ5Bsueaw3sgqr8Mzf2VgYq9InDksAScPicecgbYwxH3ldXhhWSY87YqR/abehnQ1kbm4rBxlBAo7jhyZJ2NOtLfS76owW6245ceF2LNmJb45/1QkhNqIgddXbcDLK9biP8fPxuTeyYgOsnNY6QRIUDG6hOGXzFFmZ5wCt4yKuPfee8U6JLPoUqSV5uCOKX2waG+xiAqRbjeLnr4NWwsqRYrc3j9+wLx7t2PytQ+g9/iZbR6f4abct7T59Tb47J44OF6QM6+v3o9l5v04zWJFe+NVmAfMSBvhjgQIi2NGeXz11VcOGi/eAslDatK0NirF0GWG2T733HOYMWMGPv30U+Hk1BnQ0cl0WVOUodUKy5cfiugUT2EYPQGGqYc37UwT0ShoRWNGQUFBQUFBQUHh74UiURS8ArrWMFIlpv8w9D6saTS+vg75W9fA2tjQLuIksMkFKLrvELFPrZVQP+o0mPwDfOaaww5lQHgUAsJcsMoNZuD3rcCqXcK2OMBoQESTzTEjSRglUFjdgJGJYegVcaADL/JVA0yCTKmsN6Ou0WKzaGNaT1NqT0lto4t4HxuYg8ncWAp0UriLYHSJvQgVc2s5UkE2nCSKDOsk691TyBNCL8yHNZ8ROEXIKq/ETzszEBVkG6FZm5uPguoaBNMuuJVUndpGM37enYmY4AP3iMKyBVXV0C06rLu3w6pZofVKbR49IoHB/FyhqdLQICIgmNMs00d4jyhOFm2tRnhAFAJMdhFnui4ithoYsaAD2cXl+GvrHpT/tgjx2TarQQqSyVBSZzDKxV6UmgKx/kbX70hprXvNpcyyWgQ1PW/OSI0MFM9obaMVVQ2WNhNVeK5MXbIHo04YDSVDnJkjLW38vAXmLvM4DBVmaDCfbx6T+daMMDnxxBMd3gsZdi3zx1sTxHUF3heSQwz3lRbJGsnVUNtInG61QkvrxwOJv3kM5uQPjInCoNho8QwhxJEU1pJ7QWvaXkFBQUFBQUFBoetDkSgKXkX6jBOQPv148buqMAc/3nsh6sqKPdqWZMnIM68WTjy2Gc3/65qg8OZNHwPbt7eQQ6gzW/D++hwRjXLHtL7wN3rvPJhuwMgHap689tprOJRh3bAalj9+BvJzUVRTi6u+md+8jLfEZJfC4w4ltXW45tsFLeZze6YHWb77DNYx42A8/wpAc59+98UXX+DLL788sL2uI9pNuow91uRWYG1uBbDsoQ5Z/f60qwjzd9lSZlydgzss2F2Mn3e7fjcvG9cL45M9J9soqOvKUttXNs8SjGyhixEFZWVECSNN+G489dRTQtvEm04QdP15+umn8eOPP2L27NktV6Bo8Myjm6/8+h/n4ezb/on7ZkzEfbMmC2tkrf8g5428Vj4FBQUFBQUFBQXfQ5Eo3Rgle7chY8l8FO5Yf1COV7ZvF9Z8+CJSxkxF4rDxLtcRHZamTgvtj0eedgUa6w6IbUG3YtfCb1BXUSpsU/2CQh22jUhOazXyxPVBDeg360RE9hmAHQvmoqG6Et5A3+lzENt/uOsoFAnanDT1E3eW1ODzTXnid4PVKlJ5GF1iuyTuO0q0oJXbSZTVm2HhvlfsBe7/CjirLzBuYHPHlCPpnnRQmTohbfe4Pp1eOIouUk16iIWqARouGTMch/ft3XKZpqFftOt8Xi67aMxwTE9zbzUcynzgAMcoJ143CovRbYa5wvEh/jh9aALMlpZRH7FB/sIFZ1BMCM4YloAUOxccaqUw/cvaCtUxKrFlhALV3JlORIV4kgdMI+vdFOlUUtOI3zNKxGMpQRtjpub0iQxyIJUoSMt59thbUitInVXZ5Siq13HxVdcifcjwNoXbxo0bJ6yO7UGdGBIcFL+jeK4ErSJJdNCph5EhnYF0nHr11VdFapVMd5JRPK0J1jEq5o033sCCBY4EGu0ZWztea+/egXfqgA0yo5rQdwAMRxwHLTYemqacdxQUFBQUFBQUujMUidKNUbZvNzZ9844IIT8YoIDt5m/fEaSCOxLFWU9kyPHnO8yjBkT+1rWiEzJkznkIju68qBI7LmlTjkH8kLHIXDIfjXU1Yr64Lu0cCdeahH41aEiddKSYWgM74rJfyvQITo7L0eb21D/h5HL5+n3A+n0wDD0bGNdUxiabvdY6iBLsIH788cfiN685bXMvueQSQaL8HRBWy+J51VvYZXcUFIw9Z8Rgj9Zlh5b2xbzuRoMBZw13jgpoG7zuZ511VvPfsSH+mDMoDrrFvTht/5hgMdkjJtgfxw+ypYS4w1AXgrFMR7nyyitFihZdmManRGJiSoSwLt5dUoOl+8pQbz5AzfgZNczsG43ksAAbudJkbzwqMRyTe0eK3/I+LNxTLEiU9XmV2Fuj4eELLxGWim1hxIgRgiyhULZ8LqkZ8+6774rt77nnHnEM2vxR9JWpSBdffHGnSRQei/uVz7hEW++HLCc1UVyBpJGrZ5PbtG577FoYz9S3P4zTXESuKCgoKCgoKCgodDsoEqUbI3HEBBx5/yvY9uNH2Ldykc+PFz9oNEaddQ3Ck1I7vA92nMeef6PQSwkI864HOiNfpt7wqHATIvYunoddv33l8fZRqQMx7sKboRlNYhw5MnVAq+vT7eSysSkojHOvqxDsZ3CbUkLL2ZsmpzpEDbjD0PgDnWm6kTDCxBMV8ZtuuklETcg0oFtuuQV/J3SLGaveew4NVeWYcPndgmg7mFiVnYcHf1uC80cNwfmjhqI7YseOHbj55puFNeK8efOQtP5PBGXvxuqcbUgKs4hnipEkv+5xdHfJq6rHxxvyhEPQbVP7Yl1uBVbnlOO8kckiKqYzoKXwM888I54vWgkeLFxzzTVuj0fbSHe4/PLLhZWhO5AscUUekYCkOC2vvSeYMGECfvjhB4/U/BUUFBQUFBQUFLoHFInSjREcFSemrOW/HZTjUfA1aeTEToWjc2Q2Jn0IfAGKyyYMOdC5qcjOQO5GR8cec6OOqkodgYEaAoMdyY2IlL5IGjERBpOfZ8czaCK6IL7evXtQa6Co5xAXkQauEBl44FWlMCw7cp5g8ODBwtZVpjmkpaWJ0f+srCwhxOkrazrCajajtqzIIVKKdrAF29eirrxU2PqS+GqGpiEoIlpYW7cFnWLF1dVAfa2IbqGALHVo2sLWwmL8tjcLw+JjMC3VfRqP/T1ODA2BHy1ry8qgBwdDa7KjtVos4vyE5k8TEcayVDZY0GBxHx3Gt4cCxPaWy+7QWFsttIUCw6JgajouBVqZDjN8QH/MHj8W+ZnbUZ6ViUBTIGKDNcQGh6CwmteiRFhnRzYdq6bBgm1FVYgN9sPQuBD8lVWKbYXVImqFkTmBpgDEBIegT0QYimvqbFFclRXQKyuEcKqMvqBVMYWLSeLJNB86Qe3cuVM4FVFklqDFM1NfaKXNedyeIrN87sR1aG/angsMGjRITO3FgAEDxNQZS2VPEBsb61o7RUFBQUFBQUFBodtCkSgKPRbUSekz8QiHeVm7zZj7VjUOmx6Amcc6phKQPGEUSk8FO3/U0Pj222+FCOcTTzyBCy+80GfHqy6iyXCyAADpE0lEQVTKxW9P3Ij6qgq7uXSmKRfEyi+PXudAyPH6z7z1SeHQ1Bb0zD2wfDtXkCh0Qrpl3kL8lZXd5nb1ZotI6XlzzUbM3by9zfUTQkLw1XknIyU7C+a3X4Jh0gwYm+xo6bCz6MlbUJm3D7rVRuCQS5m7KQ+b8t3r8oT6m3Dz5FSRBtQW9v45D/vX/onJV93f7HolYd2yHuY3X8RDX3yPRTv34OOz5qBvlE0MNqN0I592nDIkAeNTwhHmb0Jmg2OqmT3CA0IwPXUUZqVpuHGSBbfPX4QFuzJh/uojWPZugfGsS5jjIkiixx9/HN99952Ihho2bJjY/oQTTsC0adPw2GOPieUEXXiYvkMR1qVLl4p5JPAohswoD2m1raCgoKCgoKCgoNCd0HN7jAqHPCqqAlGU59hRzS82w2wIQlm1H/ZlO0Y8BIdo6MV+XTfUW6XtreyoUjjWFajNkJSUJKIHcnJyRDRBZ8EogyVLljTb1lI4lZEORE1JAaqL8kQ0hSs4uzZRjyZv8ypBThC0t45OH+JafyIwCFpiMvSiAqC2FiU1dcitrPa83A2NYvIEQuDXP1Acz96KlkRQbXkx6qvKHdavbjALW+D+0cEtrIczympRXtcIi4daPWaSRJwabClqBG2rGYnk7wf8uGYdNufkYX9FJZZk5SGrrEqss7PYVqZe4ZEYGpdgK1djhdD6CfEPREp4HIJNhaIc24ur0WAxwarnwNhEapXWUqNHB2qqoNdwnwfKS/tmRpnYWxUz2okT5/HZsgejT6TNcXBQECIqShFbVgSUFUHG62jxidAibREqCgoKCgoKCgoKCl0ZikRR6LHYtLoRv3zbcvSd/dfNaxqxZa1jJzptgAkX3xAKUzc0z2AnlToZBMVGKZx5MLBv3z5ht1xaWir+pr7GUf1ixG8KnbZH2JfCrGs+fEF09AlGEc28/WmXrJaW0gfGcy6D9bd5AC2OfQwSKMazL6UiqUfr05Xp0rEpDlojvBT/XZ6FncWekz3uIopef/11vPXWWzjtwQdt7i8AbvjhV7tj2eYNjkvFzDSb6G6wXx4M2nokh8ViRtpovLs2Dw2WfHywjqRHDjRtm8P2YU6uRF6BuRGWBd/Csmm5w2zDcafBeJjNolhBQUFBQUFBQUGhK0ORKD0AvcZNR0BouLAOrinO9/r+/UPDMfDI0xGTPrRLh2nU1+lY9Wc96mptHcjM3eZW+/DOy0qLrFj4Qx2kVMOI8f6IT2rZaWYHM3PJAhTt3oz6ClvUhK9B3RtGdgyYfRpKa+pFB5opESeddJJYzuiSq666StjKPv3000Ingi4o9uCyN998U0QL0Op4/Pi2HZY8AXUvkkP9MD4lAn0jA6DrnXCLontPU9QD3afWffIKkkdPRsKQsS6ttKlvsvD3ZdhT6uP7wOMZtHa5Cdmcmw6sz/Pyhqs0y0A9kYm9knD/zEliXq3ZjLfWbESQyYSLRg/DmtwC/LRzr3hbW5RZs9FUpwwZ0ML+eXVOPn7YsQcnDe4n9p8Q4ugoxH2dfPLJQk/EXthYz90P67ZNOD7MH0mzXEdCfb9jD7YVUj+mpWuWvmMzLDLtKyQUhjETofl5pk2koKCgoKCgoKCgcDChSJQegF5jpyNx2GHIWb/UJyRKQEg4hp50sRD97IoQtrk6BHmyZGE9yks61okvK7Hi958OWA3HJxsRm0AL1ZYd0czlvyJz6YKDZi+9b9Ui5G9Zjd7jZyG3qELomTACRJIoAQEBuPrqq7Fu3TpMnz4dc+bMERoVFotFpPoQTLP497//LeyNScJ0xl6Y15zkCffPqJc+YcE4eXC8VyyLJcqz92LD568JQVVnEkVi4d59ePwPx6gGr0KHSHmhLbLRPspDWDVb7LNcHEkOb3ONulUI2Wpk+HQdmq5jQkoijmgiLJh+8/32PYgKDMBd0ycKQoUkinO5KDDLovGcThzcDycPcRRJfX3VBkGinDioHy4eM7z5GsBqFc86j89nTj53vBZ8BvScfSIiaE54AOa4IVFyKqtsJIqr09u1TUwCsfEwDB8D3Wi0na+CgoKCgoKCgoJCF4IiURS6P3SICJKMXWZUV3qP1CChsnltA+acEYzwSMde8YhTL0PqpNlY+fZTIkLE1xh64oVIGTMNofHJQJG9UKtr/PHHH7j44othMpmaU3vo6uINHRSioaEBd911FwoKCkRqCbK3ofy3j9DTUFJbhyu+no+pZfV45PwrISROdB3r5r6Cgi1rUFfuaCPMp+SkwfGobbQgws5RqbPY+NVbyFz2Kw679A4Emq0I//kbGMptKVREqL8f/nvCbPgZjS10WCQGxkRh7tknYV1uAU758GvcOnUcjkj3wK68tAiWz96FNmAojJNmOCyibfbtt9+OaWEBuCE92TskWnkZLJ+/D63fQBimHO5VYk5BQUFBQUFBQUGhs1AkSk8BLUojohEYEYO6ipJ2aVG0hoDwKARFxXbpEWGeaU6WBXt32CIuvIW8/RZUlFnR2OB4Ldmpi+47GMGxic22s75GVJ8BSB45qTl1JyUlBZGRtlSMkpKSZnIkPz9fRAcwdYcT15EWxwRTMKKiosRv6pjQPcUdeJ5xcXHNNrb2YBTKsmXLUFZSgicffgBVAbXwldN2Y00VqovzERgeJWysDybqLRYsztyPgOw8h6CT6sJclOfshdXS2OKapUUGCZ2SinqbwKwE7wutj7mf8joz/JzIDtoRuyNAKNDLyBdrYwM0iw5jaTGqK8pRUX7ABSgt0mYXTYHdsroDQrQSEYEBOLJfKnYVl2LB7gwcPSANA2Mco8vK6myRWKW19cipqEJcSBD8Gs3QC/NRExaFiv37xfMjn6m66mpsWbEM8cnxyI61OQO5Q7WHQr5obIC+d6ewVVZQUFBQUFBQUFDoalAkSg8BO5dTrn1Q6EgsfPJm0fHsLAxGEyZddR/iB49BQIjq0HQVUO/k119/RXBwsOiY01b2008/Fcuod2IfbXL33XeLtB97sAPMzj5Tez788EO3xwkKCsLcuXMxevRot+tUFWbjl/+7BoHwLoFlj20/fSKsfqff/DjiB7kvy0GDpmH8xbehqvBcLHziJpeRSNUNFry0LAsltY7EQWW9WVgy/3dFFoxOERYXj0nBqETX79mYc69Hn8NmITAyBuaGRpSfcDY+/vhjPPPmay7X98R56NHfl+H5Jatcbvf44uUiJWju2Sdi8LBhMJ15Mb7/5lvcNXmy0Nw5++yzxXr9Y6Iw/6Iz8P3GrZjx5setHo/EjIKCgoKCgoKCgkJ3hyJRegjYKQ6KjBEj1UkjJ8HcZCtbnp2B6qJcj/fDSJbotIG2fRpNiEjui+CoOHRVlBRaUFRgRXWVb7RJLGYdmbvMqK3RkdKHGg1/f2oBI0N69eolfpNEYUQJLWcnTJiAsDBbJ9xeC2XHjh047LDDEB7uGCkgt6PALG1z7bF161bs378f9fWuO75C2HTiRPSOCkFDZRE0zTuRT65AQtBSXwdLYwO6yrvGqBir2SxsmSUKqxuQV2W7XjWNFvF3eb1rcomRKM7YXVLdrKUS4mdEWlRQszBtQFgkgmNsVsUwWmEJCQUNi/dXuCZLe0eEYXxKIopqarFwbxYOS0lEqFNEEXVUSluaVzUvow5MIzV/eI7hEaiyWMUzQVtr6qPo2Vkw5eUgJTQE/kaj27LYI9ivHVVOZQX03TuAuHhoEbboKQUFBQUFBQUFBYW/G4pE6WFgisnMW59qSnKB0OzYNq/1EWJ7JAwZgxm3PNlswqMZDo5VbkexYVUDfv2+Thh++AL1dcBXH9Qgtb8Jl3Rh+2NGjbz44osYNWqU+JvRKGVlZbj33nvx+OOP47fffsPYsS3FWSlI+8ILL2DcuHEO82+44Qa8++67rRI5zzzzjBB/XfDPS9FQ3bZOS0/Hiv1l+GLLAWFnazt5pe+2FULTCsXvATEhuH1qGgzGjpF2JwxMx9PHHo4rvv4Jj/2xHL9dehaGxNmsp72CxgZY5n0F5GV7LXXQGXrGLlgy98Bw7MkwTpjmk2MoKCgoKCgoKCgotBeKROlh4Ci5/eh4ypip8HdKxWHKT9byX0XEStzAkQ7LInv3F9t3FzFHYZRi/XuOYfIPxKBjzkZJxnbs+f07nzj1RKcPEe5LUam26CB7rFmzBj/88IOISrnzzjuRnJyMoqIiQX5Q66Surg4bN24UhArFX7ncHtRHoTgst6cArT3auv9cbi9aeyiDESfL9pVha1F1u4kTe3BTyUcUVTfg++2FGBATjOEJrafSnTy4P4bGOxIktCc2GTSxT0aUuOI56MAzPCHW5T5/2L4HGWXlDvNIwt1///0H0rusVuRXVuH9dVuwbH9Oi31QT+WiUcPgb7I9I3QL2l5kE+ItqK7B++s2o958QDPGGcPiY4XVsqckTXFxMd5++23U1roJrwEwZMgQ4U7VXb5vCgoKCgoKCgoKXQ+KROnh6DVuhpjskbFkPrJWLBSdc7q+KHQMpoBADD3hAhRsWyc0O3Sr99NNYvsPF3oYrrBq1Sr861//whtvvIHLL79czKPF8SOPPCJSLphyQwFY4rXXXjtgz9uEV199VdgiuwK35SQtbPnbvuMpbX7ZkT5osNJW2Co0ScSfghzwXRqRM+yvg7R4poBsflU9vtqa3ykCxRnFtY34ZlsBjhkQixFJEfKUXeL0YQNxzojBLea3dW1OHToAF4wa6nK73MoqZJVXiPOT+2HaFyexDkO0KL5cWY3H/lgmtFRk6pFEUmgo7pw+QQjacllhdc0BEqWqRlhTV9Q3tNhO5386xDkJEsVDkEBk1BWFlnmfnMH7RQLltNNOUySKgoKCQg+Ec73XVj1o366Rv+23kb/lMkXAKygoSCgS5RBEZPowjL7qAcQNHPF3F0XBR5g+fbogVjgyv3z5ctG5ZNQII09aG6mXILly5JFH4n//+x/ee+89PPnkkwgNDW1eTj2QNR++gOI9W9BY5x3b5NZgtVqw9uMXEdG7H8ZfdBvWbtoiBHWp3XIwQHKKne9zzz1XCPWSqFr2158o2LYWZZWdi0BpDb0POxyH3/IPxKQPwcHEPyaOwXED0/HC0jWIyivHvy+8BkH+AW7Xn53eB9dPdEwXK6mtxdXfLMDU1BTcOKllKhkxK603bprsmEq2r6IC9yxY3OGyT5s2TURm2Td2c3JycMcdd3R4nwoKCgoKXR9ygGP79u3CrXD37t1oaGhoQX6QaJduhYMHDxaC+7KNw30wHZqacd999x369esndOViY2Md2kEKCgqHNhSJcggiICIGccMnIshJaLQ7wdyoC7HX+rqDE4lgseiorLAiKNiAwKADkRAc/S4tL0dQRIzQBWlsEvTtLOjgUtVgRm2j+0gPuvMkJSUJRx52EonCwkLRAIiOjsbIkSPFvyRPSKow/cY5bccdRowYIRoOJF8qKyvFMRygW4UeClPDaL3rc+g6ynMyYW5sRF5ONvbu3YvVq1ejvNwx5cRXqKioEOlTM2fOFNd3xYoVmLfgZ58f1xAaBWPyAGhBLVN62Ojj/a+HJiJHCD+jETFBgahpNKOivh61je13TWJjc1RivLBM/r+FS+FvDITFjiXS62qhV1ehqKoKZfX1iA8JxvD4WMwZ2NehoboxvxC3zFsIo8GAs4ZXw89gREJoCMrrGuBvNIvthsXHtNhuS0Gxo/1zfR30ygo+8ELsui0wbe2EE05w2OfOnTtdWnUrKCgoKHgPrB/ZJtBF5OiB+offbpFubvBtujjbKkxlZpsoKysLGRkZYp59dCLbbiwD2zbx8fFISUkRbSN7goTbsH2xefNmsWzo0KGIjIz0WbkVFBS6HxSJotAtsT/DjC/eq0Ft9cEhUXL3W/DGM1UYP80fh88JEvNYwdLqNSIsFG+98hoyF/+ADZ+95p3jVdbj5eVZOK9/IY5ws87JJ58syBFaFZPssLc4/vnnn0W6D0dTfAEDLbWvewjltNR+6havWGq3Bur0TLryXtSHxuG0c87H4CFD8Oeffwq73Zdffhm+Bp2P3nnnHcTEeFGc1QPQxnj+/Pl46aWXBDFgj7POOkukpzx8z934vzds4tFjkhLw/hlz8MWWHXh44RLhzkPnHK+O8i3+BZVrVuLStz9CQ0Mjvj7vFMSFBLttGFMLZWV2Lm6ZMh7XTRwtiJVGiwWfn3My4kOD2zymdenvsG5YDdPpFwBJNlcqBQUFBYWuBxIo1YW5qK8sR0Vupm2mpiE8KRWBdJmLTfCIDO8odu3aJQZYGIHCqFtGjzKChINOEhz8oobWRx99hOzsbBGRkpaW1ly/sy7jIAUJFkagpKeniwEpCvErKCgoSCgSxcegRSxDAjmSzSgBe+zZs0foLCi0H37+GqJjDSiBFXW1vidS/Pw0RMcZEBziOJrB0Y76mBgExyQiOnUgEodPsC2zmFG8ewssDTbtCE8Q0SsdQZFNQp9V9Rih9YHmHyScdSiIyagDe9DOmCMnffv2Rf/+/cU8jqwUFBSI+WwUsEFBfZT2gqGwHMEZOHAg/Pz8XArPBkfFiugbTfO9ZZEGDYGRMdCDo5Gdk4NevXsjNTW1hTWzrxAYGCiOx+vA+04XJBJUbKxx1MtX4P3kRKFgZ9CymlP6sOHIyM2Dnrsfof5+WJyxH/lVNUiPjkSd2YKGdn5jSJRsKypBZkUVho0Zg8i0dEcB4ZBQ6JFRyKuth95Qj5TwMIQFuI/yCAvwE2VJiwxHr/AwlNTUod5iRkp4qNBLcUaIvx+mpfZCTHAQFu3dJ57BXlExQBtRVGwkz5gxA8OGDWvX+SooKCgodAKMPgFQW1qI+qoKlO7dhrrKMlQV5jS3F+orShEQFonohsHC7CAoKs5mAunlqBS2d/bv3w+z2SxcC0mMkERhHS71zPgv6zTWn1L3TerHScjIFEbkJiQkiO2VkL6CgoI9FIniY5SWluLTTz8VuhTff/+9wzJ+vP+fvfOAj6s61vjsqlmSe+8N9wZuGDCYYjBgSqihBwghCSSBQOojISEF0iCQRgkkhBo6wTTTwXQb44p7t3Hvtrq0+37/I498db272pV2V8XzveyT2b3ltHvume98M1Nenrjc3iDStWeGfO27zeW9V4vl7ZdTZ8QqOnYNyqXXNJesGB4BPcdNlB5jj3P/ZiEx9eYrZPf6fTsxcWDoV66QQyac5v7NguTicFjuv/8BOeWUU1zw2K997WsHnMNi4IYbbpDrr7/e/ffcuXPl+OOPl+OOO87FMfnpT3/qfHoTBcoHYqFMnTrVBRON1w3oYABt/qtf/coRaCiBkAzXJ+jjH1/3PSl/8B8yfe5cOePR5+Tyw4bKS5eeI19/fqq8vmxVwte86+OZ8sKKdfLmW2/JsOHDq/qfugePOFYyhowUuechkU0HZuXxY2LfXnLfVyZJZiAoRXHMdz1btZAnv3q6PDV/sZz+6HNy5513yrUXfh0n9pjnkWXqqaeessB/BoPBkG6EQrLu8/fd5tGqD6dKWRGx0jwbXIGAZDXLl74TTpN2fQbLIcedUeOcXhugMpk/f77LIqcbLRAgXhAHBdKdtQ2bILh6+gkSVCeQJ6eeeuq+4ltGN4PBUB1mGaUYSALHjRvnVATsqHqBYuCxxx5LdRGaJCp3EkTSIIKovJ9U3i8Y3P8i5cX8zW9+0xFlGHr6kj3zzDOlR9cu8t6qHfLlys3uu9GjR8tJJ50ka2e8K1tXL5OP1uyUFu06uiClmVmVj2Hb3gMlmJlVdX1e6VwTFx3/LokXXoKDeBA33nij2z3he/yAOR9XFCSr3/nOd6qizRN07Y477nBl8Ktc2JlRP2KUKMkCsTU+XbdTSspDclTPNpKTmVgH4pP8ve99T3r06FFvixpN79wQiCUtSzg3VzIOP0p6de8j3+/UV0YHyyUrWH5A5hswsktH+dHRY2X1zl3yl49nysUjBkuHTp0kOHyUSLByIRn6ZJ6UL1sjGZmZB/R/IBiUnOwsuWLkMNm0PEfunj67ckdRRE7u31sGd2gn/527SOZu3OxSGFOGLF92p5rqRGwXzisjA5IvbXvM83xlhaR+4oknHNH1jW98w6lUbDFsMBgMyUPhzq1StG2zbF06X7avWizlxLGKECutvKRIti37QkLlZdK27yCnvM1ts099m0Qwx6P+hlDhHaDqE/0N8N4cOHCg+511OmsLjoNU4QMRg6oFJShKFuKmsE5CvQJ0HYUidePGjc49CMUo1+UerNlQsuAGBBmj53EMm12Uj3Mhb3hvoW5lvbVo0SKnYCcYLmpjykY8Fq7FcVr+WbNmOTU75ecaHTp0cMdCGqF+J0sdZaQ8lBtFDupkbxuwxkMhr0F0XcyafWUHXJd24TxUPebOZDBUR/1bAU0cTIKoAiJhzpw58swzz6S9TIbkgBfWD37wA/noo49cJhtevLyAeOHgSzt16VZZvHiTO7bz8X1l1CXXS+G2TbJh5TJ5bdlW6Z7VTX53wbXVfHWrBWfzpNaLZfjpsRwDiYJKghc15A7gZfyPf/zDBZp977333MucY8nA8+ijj7pgqX4SJRa899PyRTvO/fV8VxEOyzsrt8uu4nIZ3bWVZGV40gvq30jXow0k4BYkP/vZzySd8Le/1j+d6ZU140CktnELnoxMpxDpEwjIb869SCo+fV/KX32+quze88b16CqH9+jqVCovLlomEw/pJR1btpbgcSdLIDunsm8fY16aHrUskCJk8JnTLCATH3xK9pRUpvdum9dM+rZpLfdMnyWzNmyu1veJ1JXz+NREu9TUDywSyTDFIvfDDz90C814zovnuYu3XHW5jsFgMDR0sK7ZunSebF4828VJiwbIky1L50ppcYG06zdM2kGkJJlEcWrJYNARA7qJxDsSQsA750Mu+F0/+Z04Kqyd3nrrLRcvhQ/u1OPHj3dEgpIhejxEDaQI5AcbUxxDGdiIYl3Vv39/p3TBFtBgtu+8845zOcLdmt9YS3IeJMn//vc/R7BwHMQNm1+8t/jNu0mAuh2lMOVlQ2/YsGFu3cn6k3h4uGRTb9aXbOJRB5Q53ncRbaPBdwmWTxvRZpTdveezstyGHHWGhNHg7PY+MxgqYSSKwVBHsJvBbrfGt5k2bZo88sgj7uXrx+DTLpXWQ4+QvHmV7jfRQFC0n//85+6l9+yzz7qXYCTwooMggci59dZbXXwUQNBV1DFElmf3gN/6d+skM//5a+kydLQMOvWiWtcX16I333xTfvOb30ifHt3k6OtulQ3zPpUFLz5S7bidxeXy9PyNUly+X0UTkrCs31Mi5RVheWDmOsn0KHtIyHLW4E7SrWV16W3fY8+QXkecKK17VsZ9SSeQ/RK4l50gje5PmxPIlzb2xzlKFf785z/LK6+84u6rRICW5a677nK7UvyGSwt4delKuf/JF2XCBRfJxaPGSK9e3SS4d7eE3nlVAn36S8aoIyTw+VKR5Wsk4+SzJDhiuIhHBRUNOt4+fOdt+XX/ri6Dz0PnnOqySYFP1q2Xq194Tb419lDZU1omN7/5QcJ1Xbd7r/z8zfdd0NmnLjhTDutfOaYj4V//+pe8/PLLUX+nzy655BIXGNC7+MVVjcVqNLCY/OUvf+myVNUG7EqSTpzn8aabbrJFp8FgaLLYs3GtfDn7Ixf3JB6U7N4p6+d8JFm5edKu75CkloWNpCOOOMIpSZYsWSIPPvigU5IQNw4iAKIBtQakRSSg+IAsIGkAWQBR8UZS40Jy8N7lGNZZrNEmTZpUtSkGuYFShLUZ/4bI533CmuK8885z5MWCBQvcB/IFQgXFCoFwNUEAGQHXrl0rM2bMkJ49e8qRRx5ZVZaTTz7ZXY+YeaxDULZDDKHSxc0Y5TMuxyhSIFXY5GM9Sf0pg26w0UaoWXBtou1oK97zqGEgYqgnAe5xEyfILu9GI1EMhkoYiWJo1AiGiyUjtEMqAvkigRSkMA2HJBjeI8Ew165Mf8cLhp0CXkC8jHgx48KjvxED59VXX3W/8VFFCC+e9v2GSmb7btK5ew/3oublxzFeAw+wi0IsE+KgnH322TGLyIt8ypQpzl1BX+DLFi+Sj9990/27TV6+HD12lPRsky9vv/h39xLsfdTJkhUqk5Y5GVJesFsKdmyVgjJ2HyqvyUs/Gth14X7EYnFBP0dPkNJ92XmKyyqkpKLyIlsLS2X2xj1SWBY5sOncTXuq/XdGICBH9mgjzbMrpyVUKrmZQWnd4xDpefjxUh+gj1gcYQzrwoE+/vjjj90uULrAYoYxR7+wwMJIpxyMGxZYjLdvf/vbVQusuWvWyZRFy+Sr/QfK6To2N6yT0IwPJdCpiwQGDZNAq9YSDgRkR6u2soUUyh5CKFawXMbbSy+/LD+49grp3bmjnNYsx6VSRo3y/MKlLhvP1aNHSGYwKBnBgIuDsrmg0CmJCsvKpDwUcqTLFvcdgWezqy3KuA4k0CmD+8tXRh8mGR33k0Z+zJs3z5EhPENad8pOW2n/ff/733eLSi9YYHMeUmV/6mMk3LQxrm+JgPM0ADCLV0ivUaNGpVWxZDAYDGnDvrmNTDx7Nq5x7jrxgID7HF+yJ/nZAyFIeF+zEQVxsXDhwipXHQgBDSLLHM/c73VZ5j3Ed3xQbkBK+OOl6HzOewbig7meNR7kBGoQXYOpGhhyAyKE+7DhxruKv5A4EBWQKbjSQJpQLlXH8K6nDpAcbMg5t13Pu4Q6smnC2oC1KGSJ1gk1CioW7sX1yfAHUcN6E0WMkijcj/tSZsgXNhs4T8vPO437QxKxkeRPFW0wHOwwEsXQqNGy+FXpvuMR2dzih1KUPSrp1w+G90qXXb+UjnvaS0BII1xpcKESYYfh6aefdi+eA8rVsqVTp5AG+dJLL632Gy8xUuthABK0jF2JX//613UqJy9CCBf1WR3UMiA/P+6QyjoEgrL8od/KmmDALXLWzZwmW5fNl+E7t0ifcd1kxcO3ysxSkbunr6lSjSBRrQ1wU/pg9c4q152iKARKJHD8w7O/dK4iYFin5vK1w7pKfYJ2gMTC5enf//53vcVB+e1vfytnnHGG2ymCxCKODR/UEoDF4YUXXlhFCDDuDkCHzpJ5+TVEzKv6ioUS49NPJLDwi7lYysqSjLMukozOHaXimUfk5S+WyM/efF+2FhQ5QuWq/73mki4UlJY5UmXm+kq3tlA4LBv2FLjF4KmPPCtnD+4vf5g0IeItgocMlIyrvieBvPyYbUPZ77vvPkdYAMiL6667LuY5lVXIcumxSV/tBQGZ2b1MFLgNodIB7OylS6VkMBgM9YnSwj1SsHWTVJSWxHU8xxVs3SilBYlnDqwJEAsQGnwgOFBhQDC8/vrr7p0GIYJbMGs0FCu8U3l3JEIOQCZwzXfffdepR4466ih3X9xydEMARQvfofDAXYYPxymBUdUW+1xniJ2I6wwkENegfPw373I+EELRYuNpPDAIEMIH8E5krcImF2Vio49jIHO8SlbWopMnT3bncj/vOgAXIYLzQuZQV0gYXJCoUyQXdIPhYISRKIZGiZK9u2TH6qVSuHGRZFWsd4qU1CAkmaHNEtqzVzYtmCnNO3WXFp26OyOTlyIvU15wxLfRFxy/8W92F2DyeUGyk8AL1wt2CJB7JkpYYDDPnj3bLRJ4SfI55ujxsn3lIinbXUlg5Oe1kA557fcHENu5Rcr2nV9eXCh7iwsFp5lmeVnut6KCUsnctUmyKirrMLBXT2nTpccBChmAjy87+97fdpeUy6ItBbJ2V7FsKayMj1Eb4AKk+HJ3sSzaWiB9irTkB4LdGNLaQiyg3kkm2FViIYTygr6sT6ivM2DXibGjCid2iFgMUk6/gohdOP+4U7CY8ys0FOxKsfji44cbb8dMkBZdu0tBdqbMXLteZq7fKCt37Cdu1u/ZK/lZWXJkj65OkeJFr1YtpaCsTGZv2CzzN2+VaavXVft9zc7dTq0i2TkSaFO5+POShdST504XehBcmgKc31gM8x27eDyLXkBssKvGopFxw3ksVL1g17I2YPFLuwF2GFn0GgwGQ1NHIBCUYEaGVMQb+4m4JRmZEvC48yYLzO0QCMQSgRRgXQAJwAaTBo3lA9HN+ot/8+6AUGAOjwfM77yLWN+xRuC9q4FZvYB44F3FPdiw4J6QJl7CRmNmsZ7io+4y/OX9BmHBubz3o6kaOZ76cbyXyNHvaAe+oxzqdq7ncX3KqEF4dR3LvZQs4hzqTD1jJTkwGA42GIliaJQgjd7bv79eQuW1N9gTwc61y+St274rg0+7REZfdkO13/BpPf30091LBuiLCPcaTWP9wgsvHBC7QV9SiWLp0qXyla98xfns3nPPPS647Xe+/U15/ZffcJHxAZlNEvFbbZ+XJdcd2bPKnWfcVT+VAZPOj+gLfO2117qgtN7fIFBu/3Cly76TLCzdVih3fLhK2p2+S46NcsyVV17pFBmoNAjWliywyEH9QcR8jO2GDFIcX3311Y44QHrrBfFc/vSnP0U8D/UGqotYOCAzTyDgxhsuMvw2b+5cOfe/L8iufe4zXvRu01KeufBMaeFRvigWbNkqJ/3naXl7xRqZtmpttd8Yg2TliQR20lBusbDT+qHioixIq/mNnThcrYhJcu+991Y7nzg2+JxzDs9jMjNPXX755VWqM3bsGvq4MRgMhmQgK6+55LXtKHu3bJDyClIbx0ZGVrY7nvNSBVQZqEzYZIAE0LgkbECw6cXGFmsGyBPIEDZNUIPUBNZ2vH/4QGxAnnBtyHm/opO1H8dAXkCKsEbk443HwvecBxnDxwu+V5JD15eRAGmEuoa6+KFECccoeeRdg1I+NgRxUaZObNJ5SR51jeX+6g5lMBgqYSSKoVEiv30XGXTqhbJ50WzZvHiO5Je8L5mhLbIn50QJBWPL/+NCOCz5pR9JTvlSyQjtlbw2HaTXkZOk0+BKlwFIE/VvJT4FLyI+XvDiY4fjq1/9apU/65efvy97Nn8pfY4+VXbsLZKnnnrKvdBvv/32audihEUjWPTFpy+zTfM+lW0rFkj53p2SRXTW2qbK9ZAuWxfOFBLn9B5/squ7F970vtSdoGOffPJJVXDRZIGrcU1cQKJB0wnSxurOgQIB0irRWBQoPXDd0QUEcTPwN8ZNBrVCQwmmhnwY0gRpsMp42cH6+te/npALCYvG2qQs9PY/LVxaUeFcsfzYVlgs98+cJ6O6dJRJ/XpXa78sTaXMWN4XQyce6NjXZ0137IhDhDqLBR/qm7///e/uv3lGcKsjkwHAhY7FoO7cRQLqHM5jUQkxA0kXSZETq138i2mDwWBoctg3p5Nhp22fQVJSsNspXWtCVm6+tOk98IC1RTLAukljgzAf8z7XdzpBU3lfMPejvOA9ohlqIFwSga4vUK+gzuV8v4oRwoV3CcQFZYDo8LsEazahSFncvN/VtJ7RzDqRoNepypi4L9sf5BFZ61DrUEaUvdRBy8NxrKfYvLDYXgbDgTASxZBW+Cfi2hqmrbr1ljFfu1HmPH2fbFk8W1oVvyLlpZ9IQfbhEgp7/DUTuX61soWlRfFUaVEyzf1X804jZfRl33c7KOCyyy6rOhJDK1o9evfqJb+77TZp5nYewvL+X25yRMqpP/+pLF6/Tf73/PMutgqfROB9sa766DVZ9nb0TCO1wZpP35IvZ30gHQYeGnOhg7vEL37xiyrXklTBmy420uKBoKp6zEsvveQC3yb60h80aJBTZrDIYeFDsGAMcYxpIuNrOep7MYHLyP/93/9VM+zZaUJ5kS54F2PRxv7GvQXyy7c/lMsOHeJIFO95PAsEmq0N/PdjEfy3v/3N9ROAlOSjIO5JIoAgJcsC2Q9Wr17tVE7xkCgGg8FwMCK/XWe3VsCluGh7zUR+dn4L6TjwMLcZlmxAjEAOQG5oQFhIAYgTPhApkB6440CeoEiBKPC7dcb7HiLeCIpV4ododjxFpLWC//2lJE+stXA8a45o14hGxECi4IqOapONGDaR2FghkL66FHEM2SaJJ9NQ1j8GQ0OCkSiGtIIUt7eFZst6KZRbg2OlrSS+Ex4NwdBe6bjnLgkFKq+5N2eC7G12YtznZ1eskrYFpOmtlDvmli2I6zxiRDz66KPVfEXLigtl1uN/k9xAsXz0t5uqXuZbl86T8uIimfHg7bKnuES+MbKzlJdXKkoGT75QOg0ZU+3akYLW8h0pWjX+QlPHY4895siMn/3sZ+4lHw3sLHEM7lV+v10WTqR5Jh0hLiDnn3++nHPOOS4tMLss/EZU/JqCy5FuGmUDqQcPZiALhjxjBwu3oGq7a/h9vztV1qxaJbe8XZ0cLKmokF+/87FsKyySv51+QpUiJThqnAQOGVilwrr55psj3pfdPtIaqxKFGCikMMaNCdUXLlioTUj7DCgX1yL2CUAxRbpog8FgMCQHxInLzmsuezevd6qUzQtnS0XZge4nGdk50mnwaGnbZ6B0HjpGspvHF4MkESxatMgZ/qTkZa0EAe7NrqPQOCQQCTWRGP7zUGvwgXzQeCKRMtrxnsLVh402NppwF4oUZ64+QL0pEy46xI/hHalKHW0LzWRkMBgiw0gUQ8qAxH+XlIh3Ci6XkLwVXi/LwrvkO8EhB7hqtJQsyQ4c+MKLB0EplfzST/bfK9hBCrPH+o7KkFAgXwJSIoFw9Zd8VsWX0rzkPQnsI1HiBS+ec889V8pLix1BAkoLdkuzT552afzWTX/7gHPWz6k0Lkd13u8DO27cSOl9VCXpQ9A1/IUjvdhxIcLthAj3pAisKEtdXJiygj1Ssne3ZOdTlv0EA7sR+hJO9UsWo5iF0Te/+c2Iv2vKaXyT33//fefSwu4QO00sYLKzWkibVl1l4gmny/x58yU/918yZPBoOfXkc+SBBx6ULVu2ygnHT5aePXvUKFxCmUCgVvUTTjUICoefdG3cbvyoqAhLSVFYMrMCkp1TN9ckpL9vvPGG+zekhNcXO4yrWelOmZvfTG5971OYjMoMO+77MhcHpSQUkj+edaq0alZZr4yTJklwZGWWHFyoyHKDHJvFKfVXH3IWoMQDUkCisGBWH3jikLCw5ZlkN5KxyWJaA+hGkkz7QRA/+hd1D8+apXQ0GAyG6Mhp3tKtEdr07CehinLZ9eUqKSsqkHDIE8Q0mLnPjWeAtOnZX5p36CqBFKTL5f3PmgFlKe8B3h06h6uLirqz8L2mMY438x7X4JqQM/zVtRBuov6gsZAo/IbahSCzI0eOlIYAjccH8UMZKTOkEOsNr2qFOtUmbp/BcLDASBRDyrBBCuWrFW/KVk/mHCiT9VIgpRKSM8tfl0yPpD9DAnJfxjEyIZAciWfL4teqkSqgOHOIbGr5E2lR/Lq0KXyy2m+VpEpiBIoXqz58TeY+e7/7dzgUksKtiWXnwDVpwUuPun+zGDnm+7+XzGxy6ETGmhnvyKz//l2Kd26TVKCitFQ+vPsWV5YJN/7R7TQpeLkSl2PGjBluJ6M+wcKFlLZIcklNi98xuPPOO+W+++6XSeN/J316jJfnHsyRkpJhctlXXpGyre3k/jv2yNqV5VKwJyyP3Vsgh44qlLMuyYtJpFxxxRVy2mmnyTXXXBM1600yQTwWXHdQWdQVWzZUyNP/KZShh2XJCafvD2yXdLj0xxdKRt8hIg/8VwL9B0vmVddJxTtTRWbNcIeQdSfzsm9Jpu7K5e8fW8iKX3vtNXnrrbdk/PjxTknidZ/zggC39AlgoUqwZWTV+HmjMiKVeKLA/YdxRPBZpM06ngwGg8EQBYGg9Bh7vHQZcYR0Hz1BSnbvkN0b1uz7LSAtO/eQZi3bSKvufSWzWR7+JyltSlIb807AHRMy3BtEnACqxHODbIFI4J2RiLKXa/FegKBHOck6CNULmzd8IGQgaQjY+t577zmyhY2GhkLIqwqHdoE4YeOAwLgQKWxGADagZs6c6VQ0BoMhMoxEMSQVq8J7ZF24wP17oxTK4vAu2S6Ro4qvlOrGd1ACMiO8RYKhSiu2TSBHhkjrmDvH+e3xxT1Mdq1b4dQfXmSE90hGRfV7hAK5kls2T3LKlkp2RfXUqpEQyMiQNr3YORkQtRylhXtl55plsm3FQtmji4ZaADJECRFUHwTNbd6xm1t8REJZ4d463a9mhKVw20bJys1zpFC1X8Jh5waDMqO+oSmkedmz26PR51Gi0GMt8rtIy/xesssldMmVtq0OEakQ2ba5XMpK2ZEplQULP5NyWScdeuc6EoUFUKQ4LyyQWGikK0YGixzcxRLF7l0h2bGlep9t3lghWzdVyIYvg7J6WXWyMDtHpFM3AtPFp1BB8svCk8XX9OnTq5Qy/fr1kw4dOsi8latlzopVUl5RIYGcZiJt20ugS3cJbNlM1FWnThHSF0dIJ8y18E/H9YZMVLFSV5P6mQ9gMUjQXRaB+LzTdn6wMwkxw+4acYhw4fKntUT9wliirwm0ZzAYDIYYQOG3L9YJBEmrUEhKW7V1m0BsnPFOZS2Tnd9SmrVq65S2qQLvZt4DvMN5d0BkQJposG/WC7zbUYjwHQRHr169HCmi2RT5oGjRAP+sJSBdWF/wfuJY3je8H9jE4XuuibswKkYlUfieDSfeibx71P2HcnF9Plyb+3EvfqfsqEPYnOKelFNTJHN9rsP1uJ/WQ9Mn89+sy3j30Q5kI2JtBCHCfSkb90S1C4mC2hLyiHrTRpxLvbScHM+5AGUn9dEAvJzfUEghg6G+YCSKIan4d2ix/DE01/07LGGnOEkkXsr/hWY4MgVMCnST5zJOqqZW8aPvhNOk95GT5N3bf+ACodaEnPJl0nXnjyQQZ7my81rI0d+7VVp26SmBKC/+XWuXy5u3XivlJZUvm2Rg94bVLqXygBPPlXHf+L+kXbcpgxc8SgSFN5VfLBQWb5Xn3/iGBN8KyB337P+eRQS+wo0RC2eXyqvPVB+PeM6R0GnRnDJZOr+6RLdLzwy58roWjkyJByw8iYUyd+5cmTx5cpUaCRUHmZJQ6hA3xpuxKnjEBMkYNlICDzzuXHuSDYL6PffcczEXdrj14IZEPJdTTjnFBSG2VMQGg8GQHOCik9euk0th3Kr7/mCtbhMqDRnuUDIyt+MCTOB71IgQHRD/3sCoEAUoDXlvHHHEEVXuPLzLICPIOgixwX+zWaQkCscTdB6iAiUKBAyEO1nhCG4OMaHvIL6HpCBzIIQLZeDaqFghd8gAqK5A3I9rkWVv/fr1bnMC11YlQSA/eOcefvjhctFFF7l7qVIEIkYDxVJngqKPGDHCvQ/ZiOAatD/lpz7EEDvrrLMcGcOaiWNQzFBPrkO5caNlM0OzQNKekDKQKQTaZzMiGW7GBkNjhpEohqRgeXi3vBxaIx+HN0sJ2/y1RJmH3Fga3i1/C30hRwY6yhHBThGPZ0fDxTmIkxEPuKwgifl4kpFHs/JEAi9l4pKE971skgJ8dstKnX+xoVIZQlBXFh4Y6V4lCKqdgX1Ol93Dq0fXX7dxhmzaWknoRQLnDeg9Wdq17hf1mPYdWkt21n5Xk4aK8rKwzJtZKkWFlQvEVcvYTYt8LGtI/2+7d4Tk0/dKRHnCfoOzpGOX6LGJNEUwbkZXXnmlWwQCFn8PPPCAIyuQNz/zzDP7zyFgXWZWjQtpFqtPP/20+4ubFpkPooGFHwtRYgSxQ8YuGgvEV1991cVL8YNFrC6m2d1LNJ4P6hUWrsRl0YxNBoPBYNg3z+v8vk+dkm7gNgNxAUkCYYCaQuOfeDPL8B6AcFFXHy037xDUiRAsKCtRjUCw8L6DdECJquQB10CVglqU+0JieK/Fd/zOPTS4rSot+Y5NGt5DEBVcl2PZoEBtMmTIEPeXa2qKZNQflBlAuHAfyBk2K6gbBA4ECOXkeALxcw/+ciz14B7ci2P5b97hmh5ZA8myvqKcqvTkvrQLH97r3voYDAczjEQxJAXzw9vl+6GPnXQzWVgkO+XG0Cdyc3CkHCGRSZSUI660c+G0pvetrxRzsdLZphq83Ak2yoLh1FNPPYBEGT30KmmTWZ0ZeHf6b2skUUYP/XrM+7ZoFZBmOQdG009nO8RK76y/l5aG5b2pxbJ1U+2C/O7aEZbXnt+vXDn7soB06Lw/GF80sCtHWmgFwX/ZUWOnjcUkSo9ExxS7ZcSBQeFC1qtY92enjd05XIs0bgzkCbFSgEq4aypDrP/2gvr86U9/cpkMjEQxGAyGhgXNnBMps2E8gFzgwzojHkB08OEdFA9Yu6BMiQXIF3+6ZD8gRmJlKwTHHXdcjeXB/ZVPrKC3J510Uo3XMRgORhiJYmgCCMjgDr2lc7fNMm/jcimpSE408YHte0rHDt2lWWZkQ6y8uFBmP3m37Fi9VEJxuo4kig1zP5H37/qpDDj5q9J5yGj3HWkE5zx9r3MjSgcKt22Wj++5RToPGysDT7nQGbUYpwTexJ3jlltucT658SAzGJSfHnO4y8pCqts9cbp1sOvx05/+1ElZ/TEs0g12bH74wx+6RdYvf/lLF0Mj2UAdc9TIGyW7dJg8/WCBHHlcM+nR98DpGoMfBcmKJeWyZ1fysiTNeL9EVi8vlxNOy5XWbeMnjL7xjW+4BRdkF1JoP9jdIg0xsmFUJsiocf2pCymF2xVjkIUsWLNmTdzE3G9+8xtHwngxZ86cWpfFYDAYDAaDwdD0YSSKoU7AEEEyubdil0hFYXVVBkEqW+RW/vUDGf3u4krfgqijM0OkeY4US4VsD5dIC8mSLE+aXS865reW5i07yrJt61wsFle2UEgqwvEblohPM3E52PffnZq3le6tOkpmMLJssaK8TNbNnCa71+8PrurSwlWEpCIUSy0SkNysoATjMBz3bFzrPl0PO0pkH4lSVrTXkSsle3dJOgBZtGHep5LdvFU1UmPSpElONnvbbbdFJFGoX4uc7GqS3hzO69dbOjbPk3tnzJGMwuptsLe0VMojtB3ExcSJE50Pshf4AhcWFkthUYEUFVcnz8rLi91IKC3bK0XFlUFiM4JZkpWVL+UVxe73qAiIZGc2l3A4W4qLQlJSTFrg/Slyjz32WBe89A9/+IOkAnnN2suQfmdLZkWOzJ1RJoMPzZZouQPWLC+XBbOSm4Zw3aoK2bKxQo46AdlydFc5ZMY8/6reQP7MByCj1jSJGqSXtjvxxBOd//hPfvITJ0MmA5EXyJejqUGYb7guKhdVIyE/fvPNN6OWkfIRNA9A/nnPe/vtA9OPA28mBy+QWqv8W+e+SC5BSMA1jSR1Vx95dhh5dlRiHg2xfuOaqcqIhVybXdiaQPkog/rLxwLEmbfNazqP9kE+HolY84+3ZELHRk2EHvemDPHEXPJe038ezwXjhLbQNKIq2Y8U1yfWeKsrGM/EQIin7sz13lhH0YCrAONd617TeZoxJJKbQCLjLVHEGm9+UAd1XYwFb+yNeM7j3rRVrDS78fQ/Ywv3EL2mupbUdF68/a/gWjXNYYle02AwGBobjEQx1AlE+SbI1aqtGyS8LytPFbq1Fnn0apH2LQ48cdNukUvvF9kcwxgY30/kH5fKg4HF8kpordydMT5m+uOczCw5ptehEtpHnCzb/qUs3hp/9po2uS1kXPch+8iNgORl1S5o1vMLNsvcTdHrlZsZlG+N7SGdmtfu+q269pZJv/ynS6mMEibVaN6xq0u3TCakRNCjVQt55NzJ0rrZ/nqyoOJ7FClTLjnbEV2K0oqQfGvK6zJz/aa474GK4J///Kfs2h46IFZpYdFWCYcr5I2PbpKszEojrmfXo+SUY/4ksxc+IjO/+HdMVx+Oy8oaL4/fVyC9+2fWmP74YAQB6Ug/HIlEw2jge+KTEIROSYiHH3646hjvbwrNTBAJKFguvvhid87tt99eY/kwTq+99lp3XwDxd9ddd0lt8a1vfUvOP/98Rx4SZI+5j4B/fmh2B2KoEB9GjbV77rnHkW+cx/nRgD8+5GS01J24TcUbODkRkC4acqsm0D/0w4oVK2o8lroSyBcwHhgvjJtowFXqkUceiZgBK9Z4qytOP/30aq5p0cD41MDJNcE73hiL3/3ud1061KpYWhUVjjBR0gQJP+5wqqryItZ4qyuOOuooN5fGMuK1zIyPaOSjF2PGjJF//etfVS51P//5z13q8mjABYMgoJEyYiUy3hJFrPHmB6Q58ZpqAnEr/vKXv1TNO3/+859jpluHaPzPf/4T0yWEzCm0QaSscV4osQGJ8e9//9u5OTJuiDEVDWxO/P3vf4+b8MDlkmvyNxqYo++9994ax5TBYDA0VtjsZqgTWFCysN1Uskekfye3g1+F7EyR2WtFerbd95vnx7IKkWWbRQpLRQZ0rn5eabnIF+tFerVzSpWtUiI7pFQK5ECjIbx7l4R37RApLpJgICgtcvbvorZp1kLa5VaPZ1EWqpDdJQWSm5lzAEnSNreltGqW765ThVCFhDetr0xr0qFTXIuMHcVlsmlviXRr2UyyfCqczQWlsqs4HFFtES8ysnOkVbc+ktvmwIV2KhDMypaWXXtLTvMDY4P40bNVS+ncvLIPerRqKYM7tHOuO5HQv131FLRlFRUyqmsnydjXxtuLimXZ9urpbdll++KLL9wOF8HcMCiIGt+u9QDJzMiRLTsWSVZmnnOHKSmtTHnNf+tvrVv2cmKpwuJtsm3nEmnXur/kZFev156CDbK3cKOUlRU4wdT2LSFp0y50QOibjIws6dx+hBTsbuaulQwEA5nSvu0gad9moFNGxcKe3SHZva1CCgtSEyOHum/8kp3fgHTsgqEXiEiUkEGAiP3RwGIeF6wdW0OypzhHKiq4VuWOMruZfBKdbzS4HuCZxBDiPowNdpUhKiBcWORjHOlvpDT2xpgZNGiQO94L3IGiuWh5UyprKmQyJzAWyYDAh2vqDjz35fp8jxGsqSipA202cODAanMK9aOcBAaMBq7BmKcckDlqoHOe7nZjOGnMFv9vBBokKKHfSEUdFMso8gLjH4OWcgDScmqfUL8FCxZUpcb0kkWcR5pODEL6zKs64DfOw/CMtsOt441jNOaBnocqDUBAELgRcB1+U9LF+5uCctI+BEWOB4wfxpbWnUCNjDe9H98rCajjTfuYsUX9+Z6601Ya1JHzqF80cozvveNNFR60B+otwHOmYyrWb/7xBnkTr7oHNz2tO2Ob8a7XJKizGvmMYe81NQ09dUfx5AXPA1lFoilVdLxxb8aNkk5cT8kBnnOCcepvy5cvr3qO+a02480PxrLWnfO0HwH9Sh0A1/OqZniu6AvKx7vLC4Kl00f6vEQDbUP70qbe+c079zHvML5pJ9qFZ0LnTOYBxo0XjDfO43qJqLt0DuO5ijamLGaUwWBo6jASxZAcHHWIyGPfrO66s2a7yGl/ERndS+Txb4pkRDAKx/UVeeJb+Fns/+7LnSIn1rzLDEJzP5PQe69Xkhw+9G7TWXq2rh6QdnPBDnlv5Wzp1bqzjOhcfTGN0XqA4Urk9Ocel0DPPpJx8TfQKMdVrmaZGXL16O7SuYWHQAiLPPD5OpkfQ6XS2HHtuMPkmrGH7s/gkkAEd9Qpfz7lOAntW8xNWbRcvvbsK9W4Cxax5557rouN8sQTT1QRDyce+Wtp06qPPPLCGY7YOGfSg/LBzD/JJ3P+IROP/LW0bXWIPDrljGr3CwQy5IQjbpE+3asHX/vo8zvlw1l/rrG8uTlt5eyTHpDZc9+Vp6deKqFw3ZUBOTkt5SsT73XlDQYju5QocOH56M09kqoETmWlIs8/UihdE0x/7AfpFlELvfRkkcz7rFTatWonO/YsTlo52en+29/+5rISnHDCCS6YHjvLxNBhd50dYYx8vysYO6R33nlnlVJEwY45u7Lx4sgjj5SnnnrKxXpBHYOaAcOC+w0fPtxlKEJV4lc5MIbJOOU17FD2xRMMELAr/atf/cr9G+ON8zCsAC5SlAdgSPIbRh4gu9Xvfve7atdCMXPaaadJbUG6THbbAS4quN6psRkJGHOokLyuQxAPuHrFA+IRoeoBGHIoPmbPnl1tvAGMSP5bVSMcd//991e7FuVk3NQWOt7UgKQdac9ogOAiIDIGL4QDRARKBNKmxhPPR8ebZtMgM9Vbb73lfhs3bpwbb4wpfmOuJKV3MsZbJKCcmDJlijPiMcIZk/x3NEDkoERTlz8F6iKCUdcECIOpU6dWkTBXXXVV1XuAZ+6VV16pGlNXX311lfqjruMtEiDxCDRNP4Lrr7/eZSaLBvqY4Ohjx46t9v0PfvADp0KJF7iSMt5uuukmp/Twzm+MDcpAvDL/OD/66KOdyslLeDDe6tL/3vGmgIysyzUNBoOhscBIFEOtwAKNBcSclUuk8LzDRAa3F8nNrk6i5GSKlJRVKksU7Pi8Mk9k5VaRc0dXqlDycqqf14w0qHEWhOtF2blDUeLfPG+enSv923V3MVSixTo5sLLllZ99YLG4fs7HsmPVYikt2E+IrNlVJEu3FkqHvGyZ0LuNtGqWKdkecojzIoWHiQcb5k136Y57jpsozVq0lvoGO1EvvPCCC8LJbla/tq1lYt9eMqpLJ8mNEk+iJjjSxUNSDerQVr4FIdO9l2R26+kiyLPDhxqFXT2MqI3rAjJyyOVOZbJ91woZcshZ0q7NAMnKzJVgMNMNo4xgtmRmsOgOyO49a+XzBf92ZNmoIVdKm5Z93LFecF4s0I9LviiXjevKpaIsR1q37COjhl4poXCFU04tX/uW7NoTvxtZp3bDpVvnyoV1dla+5Od2dMoZL5YtKJPSkrAMOSyrKg1xqCIs5ckNhRJ56Ee4B8bi//73P7fjefnll7sd3Xfeecct8AcNHCIL5pRJwd7K3d1WOUfIvBlB2bUt2z2TX8wql8Li5jKs36VSVFy5+9qnX6Z07Fr5PGJYYmRGk/x//etfdwQI/Y8BSjBbjGQW8hhxGHbsEquMHOMFo4vxxe405/H7t7/9bec64I8BEi0eioIxyNzHzvh5553nrvXQQw+5+3BNdoJVxk+ZtCyMG85j7GLcsvvLvb0GiJYzEiALaBcMX9x5MIq4NsYhO/IQGRAl3IM6aL24JgY3xjuGOn3kr7Om7KwJ1IH4Mzz39BNqGNI9Y8DpNZkP/HXgPFxAGCcEHuY8jE/vfTWNZyT4xxsBiam7priGBMFQfv75511b85uqMbgmcWzOOeccR5jpb/G0uR8ffPCBS3FNH0AIcE3cFvSaqirxA1KFrFEY0BMmTKiKq8Ncxv1ph2gpQ/3jDSKBtsYtCNcuMn2Q3puxwb11vGl7osJgvHHvRMabHzxjH3/8sVNOcA/qjssO1+d+lDNSHSC3qD/ECc8bSijv+KOPorl86HiD6DrllFNcPVFy8Ay9//777noQKd66c23OoywQrJBMzAmJjDc/UGkxvzF+KSvPGtdk/tFnPVIdUI4wXuhvXAFRZ/ifvZrcXSgnxJS6MtLezDeMP66JAkzVTtSHPtX+4B2N6uyCCy5wqhnuXduxD7jmyy+/XDUWeeYoj7cd/c+XwWAwNFUYiZJi1Fc62nSQKPh6v7tqnsj7PxXpFGfGlIqwyD/eFlmyqfK8rnEQArQhC+I40r3WhJY5+TKm2yCpK5a99Zys+uj1at8t3FIg/527Qa4Z20PG9Wid1JTBK957UdZOf1s69B9ejUSpa3vEU8ZIQBpMqtdPP/3U/ffovj3kr6edkNRyHNq5o/z1tIkSPPE0yRhfuVOsPvFkBSK+wHGH/1xOGn+bPPHy+Y5EueLs16VFfvTYLZAtr33wE5kw5qdyyjF/TKj+Ov74avp7JbJ4fiW70L5Nfzn56MoAs+FwSJ557bKESJQ+3Y91aplYmPlRqSMmeh2SKS2re0HFDW9d6tpPGMoaswNj5qmnnnZGBov8yy+/Wv51xx5Zv3a/OuzFJ/ZL1d9/HbeS1nLc2N9UfXfGhbly+IScKoOF3WZvubW8GGCMO3af8clnDvrZz37mjGjk6xhrKFKiAYOOcYMqhN3amhDp+WLu++tf/+rk7BiVGJcQCWQIUgUL7ipecD4GCDvRkIGffPJJ1BSW0foGtydUMpAvECcY4VwTtQ3PIXXH0OK3SMCIZdc6Wtpnfwr1aOUgzoLu/rMTTR/EE4wWww9jkPGCQqcmePvdP9509x+lAR/IFNrDO268wPhGJYThGU/w1GjHsOtOGwL6gbEYa7wpIHc47/XXX6/apY/lvuEtg3+8URcAsYKiCKMWNxFVo0QiHlElMd4i1cv7Xay6U3ZSjwOUDzw/sdLI6nUgQX70ox859QzxhGo63l8GxhuxVD788ENHIAH6+3vf+55TZPz4xz92z1MkYNAzP5AKti79zrP1ne98x/0b0gCVG3GLasL06dNdFjKUcmQCqwmRnj1IFFReqM0oB/MsajLGns5hkWIM6RqNPuI8+iye+8dqJ+Yb5jjIJNqcuSwS4h1TBoPB0JhhJEqKga8riz52CtmJ8oKdvJr8YA9KtMkTueMCkbU7RL75sMgZh0ro7FFyR2iuvBZYK78IjpJ2Ut2nOt0g1W+noWNl7tP3SdHO+FPcntCnnQzp0FzeXL7NKVVOH9jBubHUhP4nnitdhh8uee32EwSLthTI/TPXybG928rA9jUHxUsU5eyALt4iebvzZWJFSCLtVbO7ffPNN8uQcKnIlviJg9oCP3sWpCyoMSziRW6zNjJp/O/ky00z5NO5lW4A0TCgz2Rp1aKnrPzyPVmx9m05esyPZfP6dvLcw4VOCcLnqBNzpN+QTHnn5WJfTJKAjB3+bRnYp7rr0LI1r8vC5f+TMcO+KV06VA8e2KFtzaTeuGNzpHe/TGnekrFSuwwVO/eslo8+/7P06HKkjBh4kSQTPbseKWccf7dsW324vPBogezYllgGkVmflMralZX1Ckkb+etf7pYNG9c61QFSf9QLdQEGBAQGc3FNrjoYKBilKB8wVAmKWte02uyGs2uOMaSZgiKBHWuOYbefNNqcB1mUDLB7z6497ib+a7KjTBBQlCy0OQYjBEldgPGG0Y3xxzV5ZmMBgxdjHxcDDE+UNpQ3GUDBgkoIxQwqHq9RBymBOon7Jmu8obRh3PB+J1gvaoRYQDlAwFbaH6IMo582iFcpEQusM2644QbXnzfeeGM1tYiON0g/FF1nnHGGUxjUBRBc1B1SC6UESqGawHjD1Qr3Ogxz2iIa2ZcIcOeCRBk5cqRzf/EqUSKNN1RudTH4KTP3IfYOBAfKt5rAeIOQgQxkzuF96o+bkihQHuHeBHEXKwA15eQ9ShtQd85DrVYXMKboR67J8wvBjGrJYDAYmhrq/oY2xAQ7aOwSsCPBLpz3gw9wKjIspAvsyLTIby6BvaUiuworP6SZZTeloERkTw0pjKNeOEfknNEigzqL/PdTkbmkLRb5JLxZXg99KUVSIeGKCgnjCpBqfwav21BJsYTLytwiq/PQMdJ7/MmSlRc/ecF5A9rny+iurWTx1gKZs3GPVMRpa3YcdJj0OfrUasFdt5eG5YtdYdlRGl8bhyUoFYE8iUyHHAjKRhlnrd8dMRAuC73u3brJhWefJccccUTcHlgJo7zc9XU4VOEW6OxmYuRg2OLaQgDZUGg/sVARKpPikt1SXrE/pSRuMoMP+Yr07jahxkVyp3bDZFj/82XbzmWycMUUKSsrlIK9YVk0t9Sl/eX8QwZmybBR2ZKdU/1a/Na72zEyYuCF1T7dOx0uOdmtXPwV/29+UiUSyA40fEy2NMtF0SBSWhKQ8vLo9SivKJXikl3VPqhj5i99RtZs+PiA30gDHU11RNcXF4WlzDfO6Iv8/OZSUhyWFrl9XF0KtveSuZ+VSVFhOOGUyrM/LXWf9avy5IzTviodO3R1O82RYmtosFp2RiGqvUEccf0gLoc3pSiye8gRXFlq6n8MGkgG1E4oCCIR3cx9jH+Cw3ozxWgqV03vrED6f+mll1apCKIBRQeGzIgRI9y9vQaopr/FEKTO1JG/vEM0BWysrDWQGY899lhEgx6S6ZJLLnH3p80hcWKVUdPwaspp2oj6YrRq6lMMNJRJKCG4Zk2ZVehTjHjiOqD4QHXhH2/cm+tTdz70NfelH/hEG8O005NPPhmRyKF8xJDBeI823ryGt6bh1TSv1Jn70gY6FnW84Wrx6KOPup37WKAtIRGY1yDuUBtEG29adx3fkcabF5SPWCgoVfzH6HjD1QMj3r/R4wXjjnqpqwjjTducslB3FIq4iODuAnFBDI6aCCSeR1ycOId6o6TyBnqljPQ99dC6axpfHW/RUh9TnhdffNGpdfxrrZrGm58cYb7R2C/UW1Nt63zDX9pm8uTJbp6hHpqJKRaIVYO7Da5ZuN9ESoVM/9MO3FMDKAN/WRS0PdfUINjRwJjifYqqinE6b948qSt0TEFEM99orCKDwWBoajAlSopB5H52GnipsEPh95dl56sxgsUEOxhLVi2XS6+6QbaRIQd8d6LI5UeJ3PCEyIfLRLYnJxVlUAJye3CcHB/sKh0lV8LrV0vFy8+J7I0/s0ddQIae8ofuluChYyVjfPUAlfUFdoww+Fa/8E/ZNuu9Go8vy+gmm1reJLmln0m7gn/VifRgQY0bQcW2LZL34pNSkcJ+CM34SEKL5knG6edLoFtlxhFiG6AqeOCfj8sjj57hCILcZm3db+s2TpfXP/ipy7CTLHTrlSFnXpQnLVrVjnce1v886d19grRqHtmFIxFs3xyQFx7JEU84ngOwaMUU+WjWndW+KysvcsTS4pUvy/rN1Q2b9m0GyRnH//2A+DBg66YKefAve2T46Gw54fTcqoXygw8+6Eilpx4Iyd7dlUZNMoCK5aG/75XP50W/JoFL6X+CVOLKg9Gv7jHE3sB9gLgVqQCGEjJ57slOK7v4avRhzLHbj7tBslPR8i7B2MN9iICY3AvDiR1fDHiMdoxGPqkEbkvsWvNeIwsHfQFZwvuN3Xc2CGibQw+tDDCdDOh4g+DA2FYjmowv/Jt+wBhPRepjL1AsoNQgaCl1x2BG2YNrBQo5xiNqkprIsrqMNwx2QGYWxgCBSZmPU5H62AtIQPr6+9//vnv2GG/Eg+E9gLGsipZ44+skMt5ob8aXZlDSjDy4yNA2tHk8LmJ1SX8NEUogZ8hN+gGik/6GnEI9FG92p0QBgYNSClULRCeqKgXPOioeCCAdFwaDwWBID4xESQPZEC1dJQvvZMh16wMsWJ0/dE6WZOY3EyneF4xx026Rz9dUBpQlsGxtQCDaxRtFNu8RGdlTpGsrZ/D3DrSQQYHKeCChQFACBGtMV/uxe43soQ73w+DZWlgm24vKpEN+tjTPzqh1oFk1qpDOhhYNlfDOTbLry5VSUVq5i1URaCllGV2qHV+W0V1KMvtIRmiHlGQOrPZbIFwi2RVrJCCVxuC2wlLZUVwhffsPlDY9+x0QMJBxSwDNcMvmUv7OSy7FdMoAW1BUiMSg6it2RJG8d+rUxQVhDQSCToGyedsXjjzJyMiWgCdAbEVFqWzducTFTfGnKvZjT8FG2VOwXvJz20vHdqSwzHKKk05dMyQYKcNUHMjLbe8+SYEbigTM3Pcfbi4pl607l0pFeaVxuWnrXNmyfWHE04tLdriPFyh5NmyZLVkuAK9Iq5Y9Ja9Zu6qhn5kVEG8cZsYDMTbyc8rljWf2yL5hl7Rgtls2hiQj2NqRhJF2U1EP8EFBgdHGfIQxza4ncUHYDfeOWX7DAEcNUVOcKowUjHMMYXbA/YFmuReuOdxD0ycDjCgIDggNDB+v4oXrcd2a0jmzm005IYAY38SAUXAfJPrs+HNv3VnXd4i6P0RT2mha8EixWNjJhtTn/gQLZW6JBK5NWmXqTbtzb/7iMoLigPppf0BoaHvQjxi60RQDgN+oO/2HgepNw6zjjWNQg2gfah/729sP2otUvPSbH5SP+9Ku0cab132ROVcDdFJX2g4VAW5a2iaMN4Lv8h3XhFyI5cbFWgDFKm3EDr43e41/vKkySgOSMi5i1Z/fqTtqA/8xOt7IekaA2mgxLgDrGOK/aDwa7olqgj7mfA1gzLhEQUU5UUTo2I8G+lLTF1Nvnmktp443VCDM+UqeaN35q+MtEhgfPDPetMjxjDc/6HM++lxQd85HuQOJqYGB6UdiOlFe7knd/fGR/OB8jqOetL8/0CzlZq3F94w7nW9oL9qePvC3gaZb11Tb0cC5tAEZvOh/xnddoWMKkq+mMWUwGAyNGUaiGOqGzq1Enr5WJLxPYvr7V0Qm3yXy+NUiPdqKnHRH4tfcskfkgnsrM/dMvaEyW48Pga49JONr10jow7clNK0yhWMqEejYVTIuvkokq25+2lMWbZZ5m/bIDUf1li4tciSzLizKvkXmsLO+LgNOOk/e+PW3ZMfqygBzBTlHyuYWN/iODkpYsqUge5wUZo+q9kt2+SrptvNGydjXj68t2yqfbiyWKS+/LGPGjK3KQNDQcNjgr8klZ5zhgrmuXv+hPPP616Rv9+PlkjP+Jx/MvF2mz73bHVdQtEWefe1y2V2wXsL7iKJomLv4v07FceYJ90rf7sdJZmb9xt/xo12HsJx5SanMm5EhH79VaRiUlO2VKW99W7bvqvTBD4USUyNs37lMnniZWAiV4/HUCXfI8AEXVN6vY4Zc/t3m0iwvvcEBTzzxJPnrxadKTk70Z47gkldeeaVTA+AyiToLH3zcAojHoaluMSj4noV9TSBtKHFTcP/QbC6RgLFHVhDSqiKdJ6YILhHsyhOHwZtSGRUFQUAxWrzEiB8YiezwQ3TgChGJgMco1yCiGG24HuE2QLBXDDLqGQkoQ1CJYIj7gesSrg20JW6m8aoJMBRxW6CsBEy9++67Xd1RymBMkl5Yr0ksEtoqGiBdNAYKbg2QZH5gZHsD5xIk+Omnn3b9jHEZLZYJJARuMrgY+Q1uFB4oDVBZJFJ3+oj2JGMPfY1KgXTCtCPKAPqB66KMIs4FbRMNqmCCRMH1BGPWX04db0ogocIgWC4qGEgSfwpvBWMIBROZYfxEgo43jHQCx8Y7z0MmMN4w5OljYp/wzKFWoU1QJh111FGur1BRMCZigbbjfPoIos8fDwXihsDEWnfULyhwUICQtSdavzPWefZQqWha5FjjLZ54KLQR403TUpNum3GDQoc5gLagDqQtpu+JbRQLKHopI31LBqVofcB4o5woYVCB0a60CX1LH3vTdFMOxhtkHi5l0QD5RbwS5gbKmgwVEYSMugjxPDTUtYPBYDDUFUaiGOoG1mR5LHj27TCO7i1ywViRnu32pSr2LUogDU4ZLjKgk8gLs0T6dhA5aWj1FMesk4pKCexQee3MA9MmBlgMstCKkhYy6aB8WdlO/aLIyMqW3kedLDtWLZF1n0+T7i2bybG928jWwlL5cPUOGdmlpeRlVy9fWSgkpRUhR5540x9HQ6vufaXjoJHSsmv0XTLKkZHTQvY2O052NatUmBRlDZcwwXcjLgozJex79MuD7WVPs1OdIgUUBl6T0oqFkpPTLK7MG/UF0hdnZzWX/r1Okfy8jrJkFf705ZKVRSrP/eQbi2/cWVCX9O1+goQlLLMWPiyH9JgoLZtX3ymDgCgrL5SMYKa7TjTAp40YkyUb11e4lMc1KVxqg05dg9Kjb6a0bb9/rASCKENI4UmmoLCsXv/+PgXOJlfu2gBiifZRrPpymkvZPKDXqRIMtHdKnMxMT4aa8rAsmlcmG9ZViCccTVKxe0dAFs7OlJ59g9IpineE7vwTgBUjEQMOg9SrEFGygVgCGKcY+OySY2hgAPldL5DIcyyGXKyxz335HYOJoJwQGZARml7Ya5CxO8s9MTgxWDGG+Mt/ew1bLSfHe3edvWDHW4kQjqcO1B0jFCPcG0/CHxMFYgh1ACmCveAcjErGUySSJVK7Yyix0028DVQcGM7s+mvdtS785Zq0Ozv0GGsEWodg8NePNqJ+XCOSQeetO8Bw5DiUIKhhorky4eqAsYniALLHnz2Ecuq4qcmQpgwQJRAIGP20AXXn2pru1X9NgpZSN9Q6GK5+oovjMXj5YHT6DX7veFMQywO3KhQs7PxHC1JPOQhYCpHAePPWT/uIdos23vwgdgvqAsYbpCAEInE9qKcqgyiLjmGUTbjjoDbB/YW6+wM1cx3KQb0jGd2U2Vt3xjDXZEzTr/RvpHFLvSDuIFFrM978gFSlHxhvlAnXMq27Xlv7kbqgKqKclI8sQ5TBr3TSuscz33AfCDOuSXYcgkVznj+tMG1PGZgbIBB5RiEgIZsijX3UQ/7015HAuVwTgoQxFWkO02vS9pr+2mAwGJoibHYzJAf70hDLWSMrP/z36krpbTVAHFx/osiabSLH/F7k0B4iJw6p2gGP71apTesbbxkyc3Jl5EXflc2LZsuXcz6SoR2by5AO+XLPjLXyypKt0rdt3gEkSqLoNGS0HPmtmyPeX9vApd0NZMv2/Mtlc8vaWbQVGR1kS4vrqv67MJsd+4UNLm13pDS9uPKMO/Ra2bVnraxZvy9wZJQidmg7RE6d8Gd5f+Yf5dVpP5ALTn3iABIlnjJw72a5QZl0dp4sX1QmyxbsdQFYk41DBmfJ5PNik1izFj4iC5Y9m9T7osZZtOIl6dKeuBbtD6g/niTvvFIsG9eliEHZF2x23apCOe2ruc6Vynt/79jXzCYYFNHSvHpVHOxic/w111zjdt8TiV/hn3v4b4xTronaABJF4Z+fMDSuv/5656YDicFfjJpEXDr9zx7nEhMBw5ydf0iUaMDYvvbaa90Ovp9Eife+WieMI9QDpFaGyMCYZ3ee4yLFZuA8jmHXG0MUgxVjPB6j3V8G7zXZkYdAI5Anrg3RgHsUSgGO1xTDta07ZSatLu0JkQE5pCmfMV4jgTgqqBaoM+4dqEZwT0m0DArKAhmBAosP4zga6A/GO8Zubceb1p1zGUMouhhvuMCQfhhDPhp5pwFzUbxAvDD2Esl2FanutB/9SH+i/AKR3EYgSRinPPe1HW/e5xiljY43SAJiw1CXaO9E6opSBsUcKbohVWoK9hqrDPw3deFZQ+HCnBcNECIcg5sQfcWHsZrIusl/f67Jc8QYpm4Qh4mOKYPBYGgqMBLFUDds3Svy26dE+uSLXHN8pWKDtC53vSGyaqvIzWdUqk3q4LZyRqCnnB3sLcMCbdxu46233uoMHwyS+gALCyT/yNUJdpfu5QM+3H/4wx9cysqvfe1r8vnHpbJySbns2p5YWtlYGN7/q9K7+xhp3fJABQzS/WnvvCM/GD9G+uTliJRFNhySinBIQh+9I1s/+UD+8P6n0nfwEGc8Ll75orwy7WU5fMQ1kp1ZSTagynj5veuldYueMvnYv7gUwt7sPYmAbDjHntrMGfEoQMj0gIqARXEyA2cmAtwPSM2ZFxgv7XLPT/vYR6b+4QczpF3mtZIVTK+/O8YwbjEYI8jmGYsEcSWQrAJFCDJ9dmAhN9g1rSk2QLxAcj916lSXMhZjCMMIQ5LxADAkSe/JvXFhIG5Qsshe1B7MfRoXgqCmBCz3AiUIbiHs1CcLqEZwGcFwRHEBUK3QD8T9UOKAsXH//fe7XXoMbYidP/7xj0kpA7vqv//976viS6DsIHWwt20xonHhSmaAUf94434Yz7jRoCrxBrJF5fPmm286ooi+YWwkA6hZGFO8bwCGK+PNa7gSr4PxRt2TZdDqeMNVhPGuWXlIFY67EoFsNY4IbjsoQiCVyLSTrLozpiAMcNUDKB941r3uPqgw6Hfm42QFtWW88Y6lvlxblUEaSJZ3sJKvZHxCZULZcKFJ1pgHkHO4CkGGQLrRrihRSNcNUJDwXOCywzuBv8mab3DL8c5vRpQYDAZDdRh9bKgbSGP85HSR17+o/Def3UUir8wVmTpf5MzDKpUm0V7sEC56nn5Ij+zZ2Dks0E6uDA6UHoHmTibKYpXdL7dLgvw0O6fSxyFVwG/Dt4PFwoYdMBaaIaTY5RVS5slXTPFLykNSVFZR9SkuD8Wd0livGSm1MIsbFnOarnP18nKXGjbRtLKx0L3z4TJiwIWS3+zAYKgsoB/6z39k0/SPJLxsEat8STlQ26xaLrtnTZfHH3nEGSuAYKhzFz0uO3atlNKySneE3QVfytzFjzt3lEF9z3DuPmXlBc6Fx4+yiiIpKd1T7UMQWm/Xk5VmwNAstzglcCn+695ggRA0pAj2plSuK7hmSeleqYhwTfr/qaeekhmfferum2j8k/gRltLyQuci5N1pJQYEqWC3xQiUmSrwvPHc8fwBlBDEBYBYUncU1Bj0EUYfJAOqCf3ND+YTCBbvJ5qaAGA4QyIRRJZrYuRgQBJQVdPtMjdBtqHQwKjkuEjXxADy3ztaObWszH0YbHx4Dr3nYfBB7FBnDC39jRSoXpUAZfHf15s21Q9cJmhj2trrgoCLAO4sGPl6TZ5LxiYELzFGokn5OcdfBn85vYC4wH1A646iQVO78pfrEdNCU+t6f/Nek+sk0ub+8aZlJ24J9acd9Jr6XEC44PIQzaCnPJqS2fvxp+D1Hg9xp3XX8ablV1cMXEV0vGndvdeszXijL7m3tw3pY8hLbXeuA3HJMwexgOKGIMaRoCnA/eWIlVGKtte6MwZQ1njrDqGCygZ1CsqTSNeszXiDLOd+3uvwznVz37ZtVf1IWmDKxjwDgRYtKLO6uSRSd53fUP7oWER1pPMUZcBdiT5CaYNrEWWKdM1I/R+rDXR+I65JtDFCu+qz5r1mfapVDQaDIV0wJYohOfhwqcjEP+3/7xVbRNpFXkhVwycrRE68vfp3ZRWVwWXjACmHg30HSMXUFyS8ZoUkHc1yJeOsiyTQvmPU+CvrdhfLH99fKaM75sop/StJBwiQ+2aslSxPNpfwvqw38WDDnhL59+fr5KuHbJVjpAEiI0MyTjtPMvr2looX/otVldr7BYOScepZklkelsB/nq72UyhcLm98dJPL0lNUvN+wJ+bJ0lWVQSjJ3FNUVN29LByukLc+/oXkZFUfp3sLNydUNIicR6dcI0P7XShjh39TkgHUNK9Mu0Hyul4kZ1ywX2XhxcIVU+TLTTOcG1MqAHny4jvfkS93jpJv/OBByZGGGRsHYwLXHAx2b/YbDQ6rx/jdTDAqSFnrN/gSTY0MmYFrAcoLL/GAQaXuA97fFOyu+4OBYvxgMEXKIuPHIx4ykbpQbow7yBvvbjS/ERNCgWE0bdq0AwymuqRGJtgl9WGHHiMKNwuMM01F7AduCBh9/ngwqF4IVlsTIDHUdUrPw3CDvIh0TQUEF0oJLygjZa4tIHS4JsQabUiwW/o9WspZjsMVB9cI+oa/9BcxQ6Jl8os03hScRx284837WzzjDdKtNiA7DeMNVQrtT6BXyATGW6QsUBo7x08wMW7iUTosWLCgWlwPAiljuKPI9MeR4bdkjbdIIOUw4406gTvuuMORKVwTFxo/INxQkPjjnnifzUTHm4L4PMTpUbVQpDkM1yPUZF4wL8bKGlUTiMvid49jTDH/DR06tNbXNRgMhsYAI1EMdQKLIV6WnfdJzDdIoWwOF1W68HRtHTEorEN2psiQrpHJkqwMkcFdpEXfrtI32E66eIw3FoncT42MQPMWEs7LpyCp6clg0BEogXbVF7dIXJFOU/+inFxp02uAtOmcJ237dJABBa2luM0u2b1htYQ8ri4s+9rnZUuzzGA1ckWR376zZDev9BUv2l0sbbc3l/x2nQ44jkUYku52bbq5mBRFBanZ9WEzaevmCsnJDUi7jkEJ7nPJYnE84tBDpXnP3pXkUipVQFUIiLRpLznZuTJ0+Iiq/idQqLrVIIjJyhoUMdBpRjDLufW0adnbXap5Xifp1G5YxDs1z+soLfI7S+euraRjl4xq3BkZMrifN55BTrOAdO6eIV16ZLi/IFQRlm2bQwmJdFq3Czr3IVfbZlwvU1q0OnCcIF9nt5uF8saN8yVVCIdDLmvP9l0t3b8VxJDp2HaIZKUpa9HunSHZuK5c2nbIcM8bsUTUjQAXDp4FBb9FArvV/KZyd3bMved5wZgiUGuk3XQdb5r6mLkIAxKQdSda5h2+p6ze8yJlCuI3+jaSG5D+huuGHxhP0YzBWL8pMHxpj0jxYZhvqLM35gSGP4a33xj2p4nlml5jWlPORgpgiYHLbwTqjZRSnd8igd84J9HfFBjf3jHlhX+8AfqFIJ1+4oW287afd7x5z1NyxR/fiT6njSOl1OY3FGiRgBtJNMT6Ld7xRv95f2Pu9bsyooDyxvpgvPlTKtMW0Z5P2hclUST1DudFc53kOY0Gfov1e6zxxn/zPYSEl3ihLfxl0fTHCs6jPt5r+ucpL/iNekcKKqvnaUpx2k/Hj3+8RZrD9Dzmm0hkCfOirqci9T+/MYai/QZZ4oeOm5rGnsFgMDR2BMKmu6s34E9OkD12kMgUwcs6HcFSkbwSWwRDMJrsNl5odH8dRr+qmCl3hOZV/khdyK4TKR4KbiqF1d12/JiY1UOebn6q5Emm5AQyqt2PttKI9OFQSCqe+LeEl0YOhFon5OVL5te/V41E0UwKSFlZ+KhMNyMQcOQI2XeK9uyS13/1Tdm9fvUBl6RZyMwT9PX1kd/+hfQ5+tTKeobDUloRdgsS/w4b9+V+8z4LyZsvhKS8jHaRlAB3FoiEK65rLrl5lYtJ6q7ZHILbt0r5v/8mUhw5M0TSEMyQjEu/KdKrb2VbZ2S4dmEnTV0ldm4PyYN37ZE9u6M3RjCYKZkZzaQiVFrNbefA4wJyybfaycDhuS4JlD6X7CZyP8aeuiqwm+yyPASzJCOj0gjYu4ey7HVlihfnXZEngw+t9PXHFam8vChi/3Mvdh6ReROzINUYNWqUizvCXMFYf/o/O+SzDwokMytXgvuey1QiI7OSqPrad5pLlx6BqowatIu6U8QL+ize87x9rPD2P3OQd+6LB/Gep2OKNlfCzj/XpgKx5hvvbzrnRXMFiHbNeM7TLDSRsojEc7/aQseG977U3TveNJgx3/FbItf0n8c8ynsYYk3fw5qFxp/tJN771RbUz5/hJeK7dt+7L5rrUbRrxnNetLrHe7/aItZ4A97f9N1XE/SZof6QQ/HMN5Gy4+j9Ep03AGXGtYjnr6bz4u1//2+JXtNgMBiaEkyJchAB2Sk+7OyaJCsoJi9YLxFzZKiXfD1U+dLcI2XyUniNFGn6YyVP3viiMm7KaSNECEy6D5x1UqCbdJfKVIXDAm2lpWQ7ciLa/SpPDEjgkIFOjRJevCBpgU4DvftJoFMXLDjf7QIHpGFkIaxgHzE7M0MGTThFinZU3z3EGF27dp2cfvpkad26+o5y6x79JCt3f5rGnBiLk8od7RIpLaldStt4QVOWllRfKGEUVBlFkl74+59dNt29zAiEZMz4LCkuqizV+tUVsvHLyIYHrj98vGjZOiD9BpOWu5Lo6tg5W3Jyqi8AvferulZmZrX+B+FwUIaPyZKCvZ4WCousWFwue3eHZOCILEcMKPhXh84Znu+Ymqtf05/m1RtcMZ04ZGC+BAM5snheWVLj8ERD130Kn9z8gKu7t/+9YzEWcPMhTgmKENwP4j3PD3//10RCEzsHl5vDDjusWrDXms7DePKnrI0498UBrsO8j5FGppCa0phGm2/8c2BNqZBR6BCvAUUCmUHiPS8SanseRiVl4C9ZbBINPOofb1qWmtK++8dbpPOYNzCQub6/fRO9XyRg6BLPAqIGV49E2y/SeIv07otnvMVzXiTU9jyMe1zWcOkhVkwk9VZN943UXvHOG6iGcHFDjUEb1Ha+8Z9X0/PPePISv7R9beeNWOfV9pqpBOQ2Y511Lm6NmmaZ9yTtoO9Ll81wH/nDc8c4RWHK78kKTFyXOqBQxEUN5RDkG88x7w7IdAixupJSKJlQ0aEi4lnl31yTcYMiDbVVTRu62n6McwJe087MsTwzjFeuQbvSvgc7iUZb0Yfqckvbtm/f3vVlItnCDA0TRqIcRMAvnxgA48ePl3vuuScl9zgn0FvOyejt/r1K9sr75RulSDzGgGbuWbJJZHz/aiRKUAJyQ3C4nBzYL/+OZwLmmODhR4sMOVTK164W2ZUcEiU4drwEBg+v1Usgq1mejLyoMmOHF3d/dKm8smiufO+Bb8ngIYmldjbERl7zoJx67v4F95tTiqOSKJFABp6zLslLincSbjmTzjpw8f/ffxbI6mVh91vb9o0vrjfPwqgjs2XYqGzZ+OUeKSpMfVDhEWOz5Yjjcuq0GGNhSmpOYgIQFyJdCzvidnzjG9+QX/7yl0nNmJMIWJCTYQTpPylOEyVRagvicRCrhiw6SqKkGxghv/nNb5yxAJmRLiOpvsabF5opav78+S6bUW1IqMY03vxA3TtlyhRHYCZKoiRjrUW2JAgcSBRD6sEzTpwajHpi9RAzBoIAJRCGvSr6MGoxaHkmIblwfUIRTqrq+iZRqAOBipk7UapDUkBQ3HLLLY6Mhuio61zC2CT4OrGV+DfxiHRjhhTeEL/xkDW0IwHdec5oZ0gr3M+I60R2Mto1Fjl8MEEVYoxL2nrs2LGOhDQSpfHDSJQmCoLIMbl5AUNPAEEW9j/5yU8c864PMf7MfFfX3QXvxBsg/fHvnxXZta26EmXRBpGdRSI3PVvp7qMIZoh8b7gEhvWo1X3DOc0kY+JkCe8LckrmmPDiBGJGtG0vwSMmVMb4QI3QpVutX1i0M6kO/QEl6RdeNrf86tfSpk3raiTKlVdeKUcccYQ0KjRvIRknf0VCa1ZIeFZlGspkIzBouAT7DZJA+5qDLnr7q3nJB9Jx9/6sGqAks6/syj1L8ks/lvySj6v91qqwv4h8TQJJYFFKC/fK/P/9W0p27w8uyd5NxcIyabUrLHMfw8XBM7YCARlw0nnSrm/NQQ5ZuJDWksVWOsBuLuQrRiiLrMo2Tq8GKZHnkBS7DzzwQDWpOcoAFnqff/65M+y9YNH34x//uFqcm9qAbB6oHvxtRzkw5vwBJIkpQJruZBqZBND8y1/+Us31g8UbqhDmJIKeet0lmO+Z973xLGoDgl0SsNYLdjrZWUV9R3pgL4gZ8YMf/CCpRgsubqQe9ip4WLxiJPCXNL1e9Rb/Jh10PEF8UzHekrmAZtealLzeYLaU54svvnDf/fSnP61GojAGSENd13TQtRlv1J2d/2SB9ykpuL2BVjXoKWX59a9/fUDGnMsvvzxpxB7GKBm7vEARwb1532s6YgXGJW1QG3VRY0AId+YtRVK6p1QKNuxLAR4Qye+SL9ktsyW3Xa4EM5K/gYBiCVIEwgzCgZTbBPkldhPEAGNd3yPqBsyczLqYuYtzNS5UXd8FdakDcW9QKlCPjz76yM1fyQRtwdhr166dqz9uwSgfeY5QTjJnENcnli0AscM6hLJBmjLXcE1IU+ZT4vE01fFdG/D+YT4kuyNEGLGYIimYDY0PRqI0EajvsPqMMxH+85//jHgsE59/YkbGd/XVV1e9ZLwESyLgxaS+v4Wbd0j40Y/Zlot88OP7U2Y6ZGRI8akbpKBP5YsX44JFdrwGVDgzU4oPGVS1mK3YsU1CpdX9kIlD0iwzQ8pCoWopiUEgu5lkDBwmAYIw7JPuJ/KAUG+Nz8GiljSQS5cujXjs009XzzADxowZU7WoZeHp989XhEJhFwelojw9hizNiVtPVlbYxaeoRpTl5kngsLGu7ypSRaJ07ynB0TWTSwQ/rSgtqer/rOJ50qr4xWrHFGSPld3NTpZmZV8c8Fte8RFSXnKeBNyiPyAZWdkSTMDADZWXSQUdA1mzZ6esmPaKFGypvrAHmDJr3j/w/E6DR0nLrpUBLAPEgMnKjtj/jC1Sb9Ylo0gi4H5kuWFRBInS0Oc+Mnjcd999EY9lB84/LxK48qqrrqoiM5j34nGV0uwzOt4wpqLNuaRG5uMFC06MOZXfu/kmSkrgaODeqC3UiGUHE4M+UvwFDHt+84KFNGVQA5v7x0NsaJwOrTs7bNHqTn/w8QJVDgodvW9t3zfUXeNlYBCQHYVFfST4DV0MlvPOO6+KQIr3fZOs8YahpnEzagPvuxbSgmxN0TJLkRrXC94vjD8N/plI3esy3iAzyKSjBlq84y3WuxaSiPkJBUIkYEz7wfhTl+ZY79p4+h8yO9rY5/3vXwNg1LPW0mentmO/QSHM/8ISLg9LeUm5FGwskMIthbJ9YWUw20AwIBUlFZLbMVey8rIkMydTApkB4f+SJcalHSEIeJ4hUUiNzfhEHcH6FtKMcU67M3Z49iB/IVFIJc37lGdSYxQxHtKtIKMOGtSc52LRokVJJ1FQ5qC6oV0gM1mnatwh5hHmLA1KDPyxggDHQlqjuKMt9Z3J+tWyMh0I5kvaibalnRh7RqA0DRiJ0kTAwoYdL6S7ING0dUyIZ555ZtUiHilybQym+++/Xx588EH3byYNfFMTmWi8O8JHHnmk3HXXXXHv1HKvr3/96/sXknt3S9iT8hSM7tpJ7pp8gjwxb5Hc/ens6hdgEfnPRytjrAQCbrd/4sSJcZcfYuTPf/5z1UvGm2IxHtx2221Vi3GyG7Awi7TAJuvL/x4tlF07Uhdk0QuCoz78j70yaHiWTDwjPRlZaoOindvkw7/fXKX+KNx+YOaAZmULpPvO70tm6MBxuXXpPHntl1e5hR1EypgrfiSdBsfvgrF82suy+NXK3fhQRbkU7ajM2hIvZj3xD1nw4iPu3237DJJx3/yZZGQeuLhmF4OFDz730Yy3ZIJdKcZipLSdDQHMMyg6NOUtu8CJgB3ss88+u2ru+973vueIhZrAAhL1mGZN8e+E1wR2qTUdMYYccwduF4mARS1uA6g9AARCIkE4MSAuueSSKkOWf6PYqAncByKARSGIlKWjJgUDbg6qUvjFL37h3j+JAuUJzwGA1GG3L15gOKASUGOB8uD6UxM0jTFy+7qMN+rOO+/66693761EgdJU1aY8A9Gy90QCBADqlN/97nfuv8eNG+cUJTWReMkabxrn46KLLnKKpERBn6P0BLShjsN4gWpHCR7mU9Yt8e6cM86++c1vOgMXJLLGAezg4+aj65of/ehHcsEFF0ijR0hk2YvLZNuCbbJ8ynIp2V0iFUX7FEoBkczcTKdE6X92f2k3uJ0ccvoh+HDXCzD6MWK9qemZw1CkMMbpGwjmRk9u1QDmIM3gBLnCHAL5hBqG/4629oYEYNOA+RbihGcgGnltMDRlGInSBMCijA/S4dpK/CFhdFEIkJ3hS4w0Lx5fanadIA04z7/jmgi8uzYstKgP8tdY8l9eerD1LKS4d7TdOECioC82b5U5G7fI5xsiKGRW7Sc+MMqQdrJbF2u3jBcJCyPary515xp8dKEGIcb9valFAZsB5eVhqahInxKlIsr9KspKZc+mdRLavE4qivdKbma25GQmKeApbd6yjQTyYruY0f97N693KaW3rVgoJbujGzUZ4QLJKF8S8beyogLZvmLfbmYgIDtWL5ZmLVtLi07dJRiBzKg6r7jQ3X/HqsWybUX1HfdEsHfTOlFtCbt6O9csldw2HSSvTXU3Jp5HFi7snqUDGBfs3HrlvWxOtesQdEGHd2wNuTGSbBBXpmWbgOTlR19pM+/xvDP3eeevRIAB6j2Xf/PsoRiIJGlWX3DmKp73RIxX/5xJuXUxy3yDjDve1KAs+jEAUIHUdt7BAFbiHZCalDmXnUh2KyPVHcKduZ57Jmq8ehfhlNvb5qT/5X0TjzID4oJy1KXu1EUNYcA7RudcDKhIYKwx5rivt/x1GW/0e6zxlqp3La4OCoxFyhDrXcsuNfWvS5tDeKCSVbBZEGu8RRo3jLlkvmt5f1MGgmH637V+oHbiw3MbTfkSD3lH3yn4N0YrY7+xukCUFZVJWUGZbF+8XTbP3ixbv9gq5YUHkmuZeZnSuk9rRxx3G9+tUpWSl14zRBUmzLkooyAUcS/kuWI+ZV5lTodEUBJFlU+sy/i3qjNUmaGBiFkneuOJcDzX5VzmWu4JUcl9WXMz9ngm+PAbKoWaXN0YP6hmVInGeXoua2ZV0cQLzTzGvMecSt3V9T9SYFjqxHOoKkye21gECvWmflyP8vozrHENDZRP+/mzcwHOoR05n/tqH9KW2qbcRzM38tEYN0oEqXpS+5D/9taNY3n3aCBibWvGA/fneFWL8pc6edXAfMe5bAJrHTiGcrGpzfyp/w3ppPfmelpezuN3xoZmv/K6ifJv7sE8wd9ElauG5MNSHDeBFMc//OEP3U6KTsjJAJMqEyg7PgSirQkvv/yyU64wQTEBJANMEEwW+OzfdNNNUY+jzhdffLG8+uqrblKLmXaPl112lpRUVEhJeey24t7IQ19//XUnB40GjFl2UZnkmXSTAQ30xW6vqlu87jylJSKff1wirzyd4tTCItK+U1Cu+F5zyWsRFNYU3jG668tV8sZvviWlqD/KyuSwLv2kf7vkKBYCA4ZIxlkXuTzLgRgvC1Qf7/7pRtkwb7qUlxRVsj5JQEZOM8lv11km/fKfkt++c9TjNs6fIe/efqOUFRdJKFmZoVgY5OTJoFMvlFGXXFftN911ZieVgKXpTHGscJLoEpEN68rl4b/vdf9ONoaNynKBfjOzWSxFnheZG+69996kz33U9bnnnnPzsx8swHADQQpe03yTCJhvUPuQUYW4GSy8vCmO/bjjjjtcvAcWW8lKAcvCjIUkakLUEn5QV9xwcJGg7slKOcw9MSymTp3qDMqagOsKiiHNwJEMYPzQB6gU/DFcFARMvfvuu5M63lh808/PPvusC0RbE2gj3nfUPdnvWtYSN998c8RjCFJLgMt0jjc/ZsyY4TINYeQl612rmWZwM/rrX/8acw2Gagi3sGSOfeYbDCjiJh1++OF1upYambHStKcCmz7fJJtmbpLZ98yWrfO3SqgsRgrz7KC0H9peRt8wWjqM6CAdD61bPCY/6Bc+KHtR+zFeWL8R4DmSsoKxDAnA+pH4IGwYQGQzx2ssHcgVSDfIM4gGbVPO5Zr8NypCVJua6QdAOHJd3Ip4ZytZwVjjO96rzPPMJ5wDkco7nXU08UmYZ7mGBpZlTQ55z7uHv5CajF2eXcoMKYmbXjxuebQRhPCvfvUr996hncgoRiyhc889190PNbjXtZVzIBwhBCg/402VYLTRz3/+8wPceSC8cbmjzJRXU4crYUBZsDEoAyS+935aTp43Mn7R9pC9SrjQ1qyT2XyAmEAdA/lFv5111lmOmFdCnLkSwpo+1HKoGx/3oO2IiUMfKKGLqyaKdCVeuJ66i7Hep/+0DpQdIpZ21POpO4pVMvQtWbLEtRn15jjqwIeyU0bsQOrC8Sg1ibWlKc45h3vwb/qZNRl/OddQv2iSNBaDjQdb2T8lJ/ief/PwsTD1BxvjIWMi4K+X7eRFxAeD2suSNhRQVh7oZF+TiSXehSITCQubZBkUes14iQleQvHICSvCYdldEp+hyyTL/WtaLNFG1D1ZC1q9Jvf2pzkFwWBAmuXCLaTHX5f3cU5uQLIj3I84JGWFBVIGecFuZcFOySRAMJNLMFO6tmgvGXE+M4ydjXu3SXF5Zf80L+omXZrl1kwsoswpLpLy4uSme64oKXbqlJrGdChU4QLJhpNkVIEwMXuK9roYLw0R9AmZv/0poJOJYEbAjbtY/Z+quU93jOo63yQC5hsN0hcPmG+SXXcNuKjxJmLNi8mE7tjG+76hfMy5yQQLVK4Zq+5azmRC05jGS0zouzZZRny879r6Gm+R3ovJIlC8u9yR3rXp6H+tS7JIufpA4eZC2TJ/ixRvL45JoIBQaUiKdxQ7siW/U3oyRsUCa3rW9xARfOhjDHJvfzDfQzhAmEBw84E4YezovM3v/BsyRVNLY9ATAwdgsGO8QyhABnAuvzGeuD6ZhXgOapr/NX4R18Po5hrcB0KhtgHCuR51wpiHAMAOwsAni4zXpYmyUU8IIUgPyh1L+Q1oT8gE6uYNqsp7nbHPh2syp0EwQRR5YxTxG3YcanOuAVmhfUUZaUfUYdh7zOHUASKev6ogp41RjkFMQchAYqhyhH6m/+g7iAu+4966gUEbcH36jGO07pxPXCW+ox24ByQJyhXaiT7hWtQHpZOqOKk7qjOur/fgL8cyDzM+uB71QhmnyiItp6rXNP05Y7e+MqAZmiiJwuDjhY9c9cMPP6ySZzEImRBg72AS/SQKDxcPERMoDy3gPCSuGrCqIZIoBkNDwaqdG90HtMjOk475rSUjGJ97TygclvmbVzoiBvTs2lm6uCwwlgbaYDAYDIaGiF0rd8mat9dI0bb4lLGQLWvfWSutetfswpWWDYF9ajBsAgxYSAQvqYlhi5JA1R4oAdTNHdc61BkokiEUMPL5DVsBVQMfVOcY2ASE5/qoKTjuq1/9alWQ23/84x9xGcMYztgjnAfhcf755zsbRc+tjZodQgJiAXIAwx1CB+IDVYXXxQbbChdIfiOeDMRFTSQKhj/tSbmwvVC5qNsa18HeIrYb5AMqFurGB0A80FbYcrgBQj4QhwyCAvKBe/NBEcJ9IBRGjx7t2sQL1B0oS7H/OIZ6oRqiXvQHBM1bb73l+ofrchztTFsQ/wp1Dr9DwmgwXdqK2EbYipAsxEREucL9IXPoG8YBH65JPZWkOemkkxzpRb95AZGkKhnaCCWsknDYtPz2/vvvu3tpEGSIJyNR6g9NkkThYUKyBWPIQGQQwrLyQDJI+Y0HBKaSDw8VA5wBysPKwJ40aZK7FhMpElIGMIwoA5cHuCEAqeLDDz8s06ZNS8n1qTuBXd9++20X/C1SNGnaGFk5MrlkqlC8QA7JSwyJtV8qyG/I/Lx+/ckExBpyRyZGJlMvK8/kS915QSZL3uwHEyb3xVWqIaU/JhPNgpcfk+0rF0l5SeRdQRQlszcsleA+ZYpmRxrQrodkZWTKoi2rpSxUUT22yT5FC9i+arF8+sDvpOfhJ0jXQ4+MeI+1M96VL2d9ILvWV/q3JxtlhXtl9hN/l3aHDJNBp1ywL3NPJVCffPHCQy52CsqRVGDD/Ony6QO3Sb8TzpJ2fYdU+21wh+Zy6aFd5YPVO2QVKcOTjKxgQE7u314OG9BBMgkm5AG7R8j7lyxeKwtmlUmX9mNlaP/zkpLNYG/hJvl0zt3y2ZISmfZ5lpNVs2DzgngIuADwfKQCEO5I+wmyx9ynLjVI7nGnQG6bCjDP4U6BrJgFdiSwiMWlhPdSqkDb8p4kBbD66NMWyMvrEosiFhhTBDolFheBzTX4qBfs5DHuvDElkg0WqBg8pPXW9Mc63j744IOUjbe//e1v7l3uHW9eYLAQSDeV79rXXnvN7agSOFUzxTHWGW+sN9I53rzgXYtbK+/aeFUriYJ0sriI4SrlT3+MmwAZjtiUSwUwulhLsLNNG8QTh65BYN8wLNtbJkWbi6SiND41DcehXiGOSn1D31mq8EA54c2+BLAJcDmBBGAd7M1khT2AugK3G2wPbAkIGWwOdcPwPufMa2RixECnn1VNQGBrrskaM5LSinJh7GO0Y4ugbuAe3F9Jjrq+f4lNxFoXwgCCA+KIukMYUC8+2FSUkTrGE8gbG4tyQYzQxt6YMVyLfyt5BRlBXThW1XkQOrguUV9NYa0KE4gK2pR5GhJGE2ro9fmN7zVuJAQY7xfaTI/hWrpRTv9SBtQi/Lc/S5/Gj4EA4xzOVcULfyFYeIfTdur5EGuu9vcX18H1jLEBkUL/6jG0m9qstIHGxuKY2mQ4MyQHTZJEYfAh3WLwMeB5wDRYH4OOCYKJCHZUJzEGPYQA33E8k5xOXMpyqmtQQyFRmOBgr1MFJjFiorBou/baayOSKDzILICYPFIF2FteUKeeeuoBJAq/scBLFXiZsXji5UUbRPqNfkgVYN/5MB79JEooVC5l5UWSEcySYDAzNW5xoVKpqAiKhFsc4MKy+uM3XEabaCgLlcvyHdUzlkCidGvRXppl5cjy7V9KSUVZzECri6c+Kfntu0QlUbYsmSOLX3tKUgVirCx/90Up3L5FBp58vgQ86QRwIVr+3hQp2BJ7J6YuIFgtn46DRx9AovRo1Uwm9m0rS7cVpIREyQgGZFz3VnJo91bu3/5FP2lFNUDm8AF7ZWDf06t+z8xgkRm/aq+iokxC4Uoicm/BRpm18CEpKd0tr71dmT3DT6KwqEr13MeuFPUj65katexI3XPPPSl9d0GMswPl303zEgmUIVXErRrTkDRkjVGjlrZIZZvrmGI+JdtSJBKFdzSZolKZ3htijrpDYimJko7x9sILL7h3rXe8ecEahHgcNe381gWQRbxr2SlVEkXHW7Jiz8Q73rxgE+vxxx+vFgg42WDNyAcjy0+isMOcyv7H2CMmDptBrDMaDYmyD6Q1JhsPKY7jAcdxfHlx6uawRMHaHkNVA6B6gZGvLjQY2JomGWgwWM5n/majlvkJ4zbSc87xqCCUDNBQA7iNgEiqAs7DFmGTl+tjr6CGgXRLZipm6sG9IMwhA7CXqC8kCv8NwQDhw/xEW8STvUiPVTLB23bqSqV2GPO7xl5TEgXyg/sSLwrigt+VNOI8juN7DeHgbze+47oQQBp3hnb3vj+5JvYNpAzHcl6k+Y770j8QOuo6pZmeOJc60Pe1fT9RPuqisWC4tpc05voQT0pgQRClch1gOEhJFAYdZAiDnI+XpWNQ8h0GMItCJkcGJC9JHjbcfFRKBnhgYAaZQDgeVQuyN4OhvrFs9evy6JRbZfyoH8iA3qck/foVFSUy9f0fSZsOpXLVjQ9IrkQOcJkIcNn5bP1iR6aUVtjk31SwfM0b8uiUyhS1WZm5cuoxd0i7Nv3jPn/6vHtk0YoX3b/Ly4ultCz+VLUGg8FgqD/ktMyRFt1byN71eyNm5fEjo1mGtOjWQnJaNZwddIxRiApIAwx7LzGBgQ6Rh1oKox5bgeO9WXogf/mLccsnkgJBM7uwEasqDIVuUvoJEe4NwYiBjVoKcgYlhL+MyQBKDIgJyGM2DlFeQQhA1kDg4LJ0wgknOKVEIumfaQvaDqMfQsRr+PMbajdsMggiDTyrsbc0CxAKDK+CxEtsQEhBMkdqO2xBiBHvfSAj/GQVx3BPDXYdqf8ghPg9UlgHze6D/VnX+Ii4DUEY017+2Gt8x4Y+44DyNOZYSk0BTZJEAcruetlPLxjkmiaM3zSYDw+jN6gRf5ncNNVVPPI1gyEdKCjaIus3z5TC4tqlWK0JYQnJlh0LpTRYJKFw8ibq3SX2DCUTbXKzpFPzbNlaWCYVoeTI/Fs1y5S2zbIkK84YUIXF29wHZGbkyuYdC9348aJ5XifJyW4pu/aslfKK6nLljVvnurFsMBgMhkaCfTZrVossye+S72KixEWi5GS447NbxBcvLZXQXX9NLavuNV5XDA2gygejXO0GNaY1mQXQlMWRoEoGCAivEa/peqOVD3KBcygfH8geTXGsQVqTASUIMNAhMDDmNeUzNhI2E/YQhEa88SEhJjgX8gnFugZPVwWNth1/NR2y9gl11P+m/pHaiGtES/fLebSXqjm8/ewvP9dgg11DNkSqH/fQwLN+aGplzQ5VG5dLTYdMO6EAZNx5y8p9dexp8PtUuXYaDmIShQkQ9x0GIMwj6hKC7zDoeKBJxwVUKsUgZMLgN2RrXhmx5n/ndyR0RqIYDIaGhLMGd5IT+raTOz5YKZsKkhMv4IyBHeXIHq0lNyvxQNrlFUXy0jvfPcDF7MQjfytDDjlLXnr3Otm0rbobWFlZcjMrGQwGgyE9aDeonfQ7q58UbSmSkh0178Lndchzx7cbUpl+tj6hrjIY+hrcFHcN7AM17InB9N///te5WqDWwNUPIgGjWTdriaFF7Bzv5q0fmrUnUXAeG7wERMV+IS6XZnfBtonk+lhbUD5SbUMo4N6Gixkp5TU1L/WGSImXuKHtaBeIAdQaV111lSMp1GWN9ickACmka4ohUlfgonjmmWe6OvjbTO+r5E6kOCNKgkWru3/zPlFAVuHSCpGC+xFp31EBqQsT18elmDAL2LmG+keTJFF4OCBRmBBhjpE+6cDn3wxIP4OnzGEk/0L9Ll52EQaRB4DgdLFS8SGXg0lmUnziiSfcBI17EcGdYk2KMLkEoGNiSge4Hw8tsQmYXAHtgLQQN6hkphuMBu6Hnyb3mjBhgisTkwlR0dMBxg2TG+5cpE9DXglBl+w0p9GAjJKXDrESaAv12wfrN82UnKwW0rv7sZKbk5x4Pes3z5KtOxZJYfF2Cewuc/7a9D9Bx/asXSZ71q+Skj2VWXRSDWKCrPxgqrTpP0KyW1TWr2TXNtm5fL7sXLs8LWUo2rnVlaFFt77SvGtv2blsnuxev8rFRUkHNi+a5YLaths0SkqLi2TT5x/I7rVLK+M+ZTJfZcrILi1lR3GlH++mvaUJxUnJz8qQIR2bi4Y+6d4yR/KzK3fKSvfuktUfvS7Nu/SWlr0GuJgJjH0WndFQWnagT/DajZ+4v7v2rJHikp0JxWng2SN1JAtb5j7mnnSAnTfmPo2DRXyidM03xMgYOXKk830H7EgRn4vnPh27T2wwELQbGTbQv6kGC0gC2DLfEJ8C8L5mziNmSDp8wNlweeONN9zCHqTrXavjjffMuHHj3Hf0NffnXRtPGt66gvvxjOmGEWM+memUaxpvtDlBPNXYJO4Z802yUwtHAwF02Y3mXcv8yrhLZVBdL6gjWUQY+xqXLxHQT4xdyp3OTJJ5HfOk/dD20nZwW6koq5A9q/dIqPzAMRPIDEirPq0ceQLxAplS32BeZS3OvEP7QZKwmcq7xpvCmPcdbi6oNCARNAOPqgJSlSGFexCrBLKEuBuUF1cg7BueTb6jrGpkJwOQDMw11JM2wKYhrAHkkqp04oVm56GMPFf60Xgw0dpO3ao0EC3loe5qpyn4b/3ND8pJPynhoAoX1CSaIUjBNehrVa1oYOBUQgkXVTVhD9JWlJE2om/5623zaEoYQ/2gSZIoDLojjzzS+fAxKHkBY2yrmw7+fJrXO9kTHw8Di36MXthVHoiawIKFD8HcMFJhuSMFV1Pge/mNb3wjbYsKJutvf/vbLrArQf30Yb/lllvSZswwqfzxj3908WpefPFFF+jvsssuS5s/IGPo8ssvd1kLfvGLX7hI+pQjXbj33ntdEFsW2LQ9ad7Ud5QgnF8se1Yu+8rLSSNR5i5+TGZ+8W/37527Ra6++mrHipNBYvHUp2TttCmSLqz84FVZ9fEbMuraW6XtgEPdd5vnTpc5D/yaBy4tZdi5Zpl88NebpM/JF8khky+T2c/cL1u/SM/CGix65XFZ/t5LMvaGP0tZwW6Z/8jtEirfrzrJyQjIBcP3x3J6c/m2hEiUDvnZctXobpKTceCiYe/m9fLhP34h3Y46VYZcdL38/e9/d6Rvopiz6FH3SRQPPfSQI1Geeuopt6hgLMYicJJNZvgDSqcD+EOTHYaPBkVnHiZ7CAvadBn0P/zhDyXdwKAhwOhFF13kstFoWX7yk5+kjcRijv3lL38p6YaOt5NPPlkeeOCBqnctGeJSlRko0hqG91u6oeMN8oDnXYNRko2JIM/pwv333++C2EJm0P6MxVQGMvaCTT/WGOyWEzA/UWNJ3UL4pJNEadW3lUtXvHv1bsltlyuLnlgkob0HkiiZuZnS+8Te0mlUJ+k+obsEMurfGMTIZ72uSgjIAshrDFcIWxTo6sqCYU1QWAxwb9rfVLpVcB827vr16+dIDWwWFCJs0rIOpjx8n6z+ZgxB2EBesLGLggSbgzYhuUGkoNexQNvhFsRmACSMl0Dxk3/eNtS4JZpimX6IZPNwrgbz9fcB56Go4d2pRAwb3JGC/nJ9ykl5uQ4kajQXq9og2rNMvTWILEQQZcD+w4MCMstP9njdnwz1jyZJogAePgYiDy7MIoOU7yBP2NHhAeUBU1YPtlIZTW80ZL5D/cBCBgVLTbI5rsWEB5tNFGg1dCOBAEsYpaSzvPDCC90EQ5khefwPjhdMpqSChMDAsE41eJBJOUm9dEeW9mSBT5Cpv/zlLylXZNCuGE+QTOwS0Bcs9IjqT5rjVANDhqwJ7IxiyEFisVNI3Vn4phoYFOzOMbHS9n/4wx/cDhmGJSivKJFP5vxN8pq1d//drdNoGXLIOXEvwsiIMmP+P6WsvFJVtHbDp1W/MSbpa6SQ1L3/hMnSsdchsmjqEynNTKPoPuZY6TLiCOnYb7A02/cCzxo0QrKv+JGsmzlNNsytVDikEi279pIBJ50vrfsMdm0w5NQLZPewMbLgpUeltCD1ZOYhx50p7fsPlw7dekppcaEMOOsbsm3JbNkyt5LE9PfzwPb5ctGILtW+21ZYKm8t3yZ92+bJmG6tqtcvJ1Myo+xk5bXrJINOvUha9ezvFkCQl0hMmbvwc041zjnnHJedB5k18/Vtt93mVGhksUk1UAYy92nQv5dfflnefPPNtMw3pDVnM0AXrSyyMOxRhNx3330pVwfwDrr++uurshBA9EPiphq8/yCLeC9q3TFofvzjH7vNEMZdXQP31QQWz2QI4h0OUF+lc7zxrmWeUQUs7XH88ce7902qN0+4J8QBZQAYapD46Rpv3FddJQBlIXMJdccYSjUuuOACp3pDDUJb/P73v3cEVm2I40TBs+Z91yYKdT9JJ4ECAhKQcCAsXY/sKi17tZTm3ZpL8fZiKdhY4H7jf/md8yWnbY50P6q7i4cSCPJL+kkUNUJZ50MOQEqjcGP88YxpGl1tQ+Z+TeuLWgUjl7Gh6gaMbq6BIZ9KqCIeYmPixIlOncZGMQkvuDckRyLBXmPdB1A/ngPqR71RxymJkwi4DvMaZYQkxJ7iPc51VOWDGwskBmt7Be3PPEx/0F9kCuI8ysM1scWYCyFFaH+uEc0O5NqaNpi5HBIFG0LVRowFyHsUZ9yP5zCZzxDl9gaz5f2FTamqcsoPcU5ZGHt8j31I/TiOcvKXNqSefDjOUP9osiQKwOD3R3PG4GWXTyMp66TDJMkghUTRwa1QEgWiJZ583DDZfDB6Y4HJj8UwkbZZPMQrx+PhZ7eKBWY6SBTakN0RXUx7Fxssbti5STWJQtucddZZTg0DmBiZ1Jlk0kGiwMyzkNX+Z6eI/mVhnQ4SZdKkSXLFFVdU/fd3v/tdNzEriRIKlckXS5+p+r245EIZ2Ht/yllQKfHFz5fAV9Ul8XsKN8rM+f+SkrID+5EXIASSTtrNRx4lXYaOktWfvJkWEqXjoJEy5LRLqn3XvHl/6dC7vxTv2pYWEoU0y4NPu1iCGZVTZvMjT5LCgYfJ0refTwuJ0m3UMdJn/Mnu37zwexx7putHJVH86Nk61328WLmjUD5YvUN6t86Vk/tVkm3xoFmrtjLo1Aslq1klsTt58mS3S4NRkQ4SBQKFZ0+hYzEdRq0qXzRjG0ZcOkgUFnzqO64pH/kLecv9mXNTbdSy6EN9h8Gg80c6SBTeM7zflLhSfO1rX3P+9Rj06SBReL9BYgHGen2MNwXqVEh71CnpIFF4v/EBb731Vr2MNwVxIHjXEpchHSTKiSee6J4zhabbTgeJwryG6hcSqTZgnZoO9+oDAE8SCEiH4R2k7aC2zmWnaGuRbFtQGWyc33D1we0HkiUjK/muL+oWoYFddbyqygFySb/jHYpBDYmC8cwH0pb1LHE/vHMPtgEf1n48exAB2AmaXQfDFhWLZuTx31/LoOEAlOjS7D7edb+3Dl51i/e/WY9BmKBGoa9RSVMeNhm4jhrq0WyJSPdQNY2WxbkJN2vmNg01bTNhBnRz13u+N8yBfuetE+cwrrkOhIdmwKE9UY9A0KiSRNtNXXz40B/M95BG2GAQItyP3+gPjR8SaV6kHLQXpAnkE9eBFKafVe2vLlv0KxvsEOfYVhrvRsuk7aZtxfdedy49Rvtaf1d1mAa/9bofMQ6xA/mg8uFYbSvsCuwqfZ45lrqqIkfFATrekunOZTjISRQGKJOiV5rGpMjAZ/Ax+SCBY9CiGGFgQ2RgEKDu8DJ8DE6NbUI8EEtvbGgMWL72LXnspbOqfdemZR855ZjbZc36D+TDWXceENiztNyCezZldGmeIzce1dupTgwGg8FgSDaCGUFp0aOFU5607rvfvTgzL9ORJ/yeCkBiEF8QQgNDefny5W7Nj/KAf6srIEYsZBMGKEY5RjabUhjVrO+9KnAMU4x9CApIXHWjYfOT7yE92YzlOkogkBaY+ympgrGLgg4FiyangAjGLkH1wIarblBiu7DJSz0oN3+55pQpU1zZUMqowY+RzfW5NveDYESlftRRR1WpZyKBczmWsAP8G8Oca+CmiwIKtTNtodlq1FD3biBDehC3inAFtDfGPuXiOzYAiFtIu3I+14QUJJ4XZabuEDTYWVxTMwJBXEBq0Ua0A6QWdhnqc2LR0I6oUHBzU2KLa7ARzoYqv3F+JCKBtkZBy++0LxsRfDRALvXj/qeccoq7L/XHLqR+qN2pI/2ubjfUkzKxuQkBglINAgYyh7JzHv2mcb0gZKgzfUPbE2+LcaP3xxbV9jj33HNdOVGcctw777zj2o/fGGecT/lQo2DPUh4UPKiTkul+ZIgPTbLFeSBgNZXpY/CpfE/ZSh5A2En1zeOBZxLQDD48DHwPecLHsez7AkoZDA0dhUVb3MeLouLtsn3XMtm8fYGs27jfXcdwcKBZVob0a1cZEd9gMBgMhmQDN52s3CyRXJGcljUrt5MFJUdYr7P+xyjW4KQY6RozQ5UguqbHQMXYZW3vd6FSZQcGLuSCKinU7V8VBhi3EAZ8r1l9VCmgwVA5lvtpWAENYuqN66d1UKUD5eH6XId6qYKFD+VFXcF19Jrcv6YEGFyXe3AeZWMjmTaCCOG/Nd4GbRYtfAG/cz9V6FM33ajmey0/oO34HSKDskGk8LsGjKV+tAtl4FyOVY8AgBpTiQLqCXmgfYg6k/P13tFiAVEPwiVoumUILe6lSiCuh/qPYyivElDUQY9jPKkChnZShQjlZGyp25ISQ9yL35TUoWyoeaiLKkk4j3pRf8rIh2M4F3ceCCWOURtWCTvOoY3UrqUsFiOlftAkSRSd+FCjwObBjPIA6ECHbeQ7r6sPLC8DGF9/JhOCGaqsjUmGCRLGOBk+hwZDfWD7rhXy+ItnS3koOWlwDQaDwWAwGOobGJeoHlAv4Pbtz7gZSaGAAc1HDfpowLCG0EA54iUp9Hw+xx57bDW3CrUVOBYXMXXzUMNdY354Y4xgvBPHETsEt1lv5hZVxfDfqCW4phIeek2upcqOaIDMgDBAXaNl0rpQZnWjiQWNC6juK1pPLae3DNQJuwuFhf9+3syn2q5aD1VVKDmC6sObhhhoXBVilfFbpECsei/sO8bH4MGDqxFFCq23t+6QVCRx8Jbbeyzn01+0pTe1sTfAs4K2JcaMugN56+Adg9ibKFNQ4Og9tZ2U8PGOQT3fVCj1gyZJojCYIEggRmDoYAd5gPg3DzOTCL/7HyAePiRakCiqWOEYJlBlQ1OVxqw2gLE877zzquSKyQZ1J/YBE0+0WDC8uPBZRsqWqkw9THqUwe8nrr8xOXNvpInJBi8DgufiQ+l/MfGbEnJIFVPhM85Lm0laAxz6f6P/SQGpqThjIRyukKKSHXHfm7HOwoAXtp88DAQzpMvwcZKd30I2zpsuoYrkpx3Na9tROgw8VFp1O7DuitY9+0vPI06UzQs/l+Jd25NehoysHOk8/HDpMGDEAYusjOwc6T7qGJdmedPCz1OSKahll57SpvcgyW93YLauFl16Sq8jT5ItS+dJ4daas4AlikBGhnQedri06zNIgsGMA+ZYsomxg0Lq8VSknWV+w4USibIf7MQw9omRQXC9ZIO+RpLM4si7G0fQS+YbgsGlIj4D92K+wec92qIeQp8yIE+fP3++pAIs4phbvcpLdmJpczJZsJOXbDCmkKsjf462IOQ9TJYwZPXMe6kA98cQ88al0PGGdBtXgWSDvuZdy/iKtvvL+uT0009371pcBlIBZPG8a1kjeccbwZ3TPd7871oCL1Iu3rWpyMrH2k9dByL9Rv/jAoGLRbKhRjjvWupqqF0bqjGaiv6pyVCNJ15iTVDyhU+sJBZ1qaMSAHW5hqYOTjRQbaKAKEB5AlGi98QO4JqqRgHqRsP8ECl7kJZB2zZeqF0YC/FekzLEM0ZUnWPzQONAINwENUDxVsm/SI3nvGQG7mFBxsKJBcq//vWvhAMDaXnx58RPMNngIX799dedMQEilU3L8MILL7h6pGI43XzzzS7FY6QyaFAngs7CRicbsMIsWDEg/PfXukLg4I+YimCH3/rWt+See+454N7e+xOAknTayQYvPfwxMWT999d771q3Ql792eUpCa7ac9wJctwP/8yNYwZJg8B567fXyoZ5yXdRym3TQSb/7hEXWDZaGxDY9s1br5VwChb2Q06/TMZc8cNq90a+ycIiPy9PWrZqKe/f9X8uDXSykZWbL6f89j/SpteAavf31h0Sg/khFSlAL774YhdMMtIuot6fgNxka0k2WBRNnTrVGfXAG/gPiS67hATcTDbY+SKAHj7P+KojV/YvCrXuZGj72c9+JqkAQTQJZgr8QQ8vueSSlATZxIAmAxC7sN77Rqr7v//972rBP5MJssBoIGNv3cENN9zgfk/FeCNAOgSa975eaBleeukl975LBWl/0003yW9/+9tqZdD7kqWG39M13rzQMpCVi3ctBlOywXuUALqRyqD3J8A+wX2TDQxm5hMNZFzbdaY/sCzvcNuhNjRWMMexSUO8Stb5bFgyR6oig81u3IP++Mc/unflaaed5ghPNhgNhnSgSSpRavsCamyRjbW8qSx3NBlkOssQ6/o1lS9Z9450j/puf2Xj66Ptq75L6b0rUyPWNP5SnyYxUI9tEKP+7vumO/br+/6R7p3q+Sae66frPRWp7um4Zzzvm3SXob7aPNJv6Z7v6/sdn84yRLtHfb/rDYaDFXgCQAyiPsRLAAJVnxWN64KCjg1PVKu1SQ1uMNQWTZJEOdig0jxvSrRkXBMlSrwvdfWD1KjnyYD6FcbjQqWSOg1GlQxo0LB4jBqO8wbTSmfdU9n/sXxrtZzBzEzn3hMOJU+JQSph3EniRcAdnynhJLoVUSdXtxoegco2yJIQO/VJ2x0OSDAjI6424BjaK5T0uiNRjW/sM16SKbFnPMezg1pfcx9lS8V8k6jUONl1V8l6rOc+FXVP9H2jdfenEq0L1Bc/nrone7xxzZrmWv8zp4Er0/W+qa/x5i8nZfAH5KwLIsUvaMhrLYPhYAHPBKQIxAkECi6069atq4oPAoHC80j6d8I34HYZ71xiMCQDTdKdp7Ggru48Cny0Sb+F1Bi2Nhm45ppr5MILL3Q+uvih1wTcC/CZRg772GOPJaUMxCFBQow8L5KfsoIhjK82acG+853vyKZNm5Jyf1yIkA4TkySWPyfp3ujLp556Sv7xj38k5d6k4EY2jiyRf8fC4sWLXUyc6667Lmmxcb7//e+7cYm0PpKPqaK8pEi2r1gkX87+UOY+88+kudAc8c2fSYvOPaV1j0NqfCbo/x2rl8iuL1fKp/+8VUr27qp7IQIBGXXJddJpyBgXE4T4J9FQsne3u/+KaS/J0jefq/u998V6GXvFD6V5p+7SsnOPar9VufPk57u+od57Nq6VT++/VQqSFBtl2Flfl+5jJkjbPoMkq1l0n2DceIjJhIsBktpkgAj5pFskkDc7TLH6n3gozH033nhjVQrLugLJPi4rxIbwprtXYLiSEpJUiddee61zu6krmPtvvfVWFxeBeCggmjuPgsDp1B13x2TFyDj//PNdnYgJomk3/c8a7xjmGdxI16xZk5T7/uQnP3HxPohHQp1rAvGvmPduv/32pLlxEqgR9yh2M1mQRxtvxMRgvCUrPsjVV1/txhvv2kjjzQ/8/7k3awbc3ZIBYoH84Q9/cO+baO9a+pp+T+Z4I84I7+xo480P5Pu4ED733HNJc6uiv//617+6upOlJRYYc/Q/79pkxcbBdYx24F1b1110c+cxNCXwvkGFwpqH96GXNNaAtPzlHUm8EU0ZbDCkC6ZEaQIgXgcMLIHZNC4Hxk0igQ/ZhcHfUHeiIA40Fko8QEqHATBjxgzn068vdPVljBcEjdJATgR15Jo1qTGYNDF4iCNAW2jAK9KD8UnEL5mYBCoVJBbI+PHjazyPhQ9txQJTfTGpM3VPZLfWm0Ib45G6xxOMi4Uffcc5yomy2MTQjhew+VxDWXwW1RB8NSEzJ1c6Dh7piAsMfodwWAp3bJFQWfxZgLKbt3JBakHz9l2k0+BRktOiZvIO0Fdtew+UZi1au2CrWbsr+7x07y4pLdgTdxkgSnJbt98XgyUo7fsPl44DK+MzxEJO85bSeegYF2BW2wBVTuG2zQmpc5q1aiuZ+wiL1t37OgInowZlAnXn2Lw2HaRl195OjQPKCvdKyZ6dcd8b1Ule2w5IUNx/t+s31PVBTcDgZZxs3LixauyzsGHss/CJFwTxVAMCo4ZrxmNQcKzOfRonIdVzH88IBg9zHvMNPtmARR7pE+MFz7YGyeOa7KZpTARvXINYZBN1Z57UoNq0QSIBtrkvdVcFDPU67rjjoh5PWTF4CeDHvKO79xDJGPfxgp13rqHzzZgxY1zmgnjBPM2HmF26ccB4Iy1kIjHRuIYGcCSoK3NurEW4d7whJa/LeFMjAOKI+ybyrHA8QU6VzEAZQd1r+66lT7lmLDUGgZ4hl9I53vzAWOLZhEBM5ruWa8YTKJMxTxtwjrY1O+Q6B8QD6s7Y1/mGd20iay2D4WABcyTvST7mpmNoiDAlShNQolTtxu/YUbWQeP75552aJF6wIGE3mUxGahzFG33bCxaU5FUHZHAg0FO8C0wWFY8++mhVMEcW2t401DWBRQ1toIsbdpduu+22uMuOAYOaRBd4TNqxIqT7waKaBRXAmGJnNZHMIQTIZCcYUAZ2JeOtO4tx6q7Ryv/73/86ZVK8YFE4ZcqUql1vFpg1RSX3oqK0REoLK4OLVpSVyrt/ulG2LY9fGXDo+d+WgadcUOVKAjERSFCWGQpVSOne3VUuNfOe/5csfOnRuM/vPGysHHP979z9AaRORlb8mRLKi4ukrLjSsCrevUPeuvXahJQhR137K+k+unIxjRtRdn7LiP3vVaLowoI6lxTsrgpuu/St52TW4/EHXCV47PE//YtkZleO96y85pIZQ33jB8aUZjTjOfjKV77i1BrxAsXZFVdc4f6NIcfYj1eW65/7GMeoSeIFZARqBkiRROY+5hnv7hg7+XfeeWfc92WeY75TY4q5TqP3Q6LUpETRukNgKHmOUY2CMF6Dkvmeuqv6gGc+WoaUWPMNgV4TCTqK8cw7SucY6lib7A2MOSXPIFPOPPPMqjm4JjC3UwZV/vDflCMu5VsSxhvtzHsCMiMeFUasdy0kAsGOITPjAc/Www8/7NQ3ibxrkzHeWGcoARLveIv1rmUMkCEQlUi8uOuuu1y5azPfMPbpN63zk08+6QJcxwuUpS+++GLV3J3ouzYWTIliMBgM6YMpUZoI3G78PgJEd5aI4O9fdJEekJ0sFrHeuAPsyLFDFGvBHg9Y9KscmzKxsPPuzrIAQalCWdh98S6cWcSwwEBRUhtgjKghBFgc+9uAHSOy6bCjyI6aF/w3965t6jcWQroY4i8pGdnd9IK0nLgbQZ7521rvXxvQdt6UnOyUcn9vH7P4JTUru2Dstvt3Gfm+NsRZlYpjn9FdUV4mXUaMkzxfWt6da5bKnk3rpOOgkQeoTHAbyW29v/y1AWl4m7XcL4dvf8hQ6XF4ZbYLRfHOrbJlyVxp1a2PtOxWXbaO2w5KlETJG0Vms1z3AShIuo08WoqqpV0Oy9al851CpNOQ0VWqE4Dp0qp731q3AWVGiaNAmeOvOwTT5kWfu0xDbXpXl63jMpTXun1Mt6VY0N0iJQBIf4w7jhfI8CFWURz43RZwZajt2I937iPzC/MDboJeY5H7MvfF47bon2/Y0VagpvDfF6OWjCKQlHy8YH7i3vHEPYqpRPKUG2UMRIJXkYDBS90hCVDWeY1F5iCM+kTb3j/f8D7x1x2i4YMPPnBzi2bcUTA2vCqQ2oLy6zwKmQJx7c3cAslDGWgP3jfeuR3iAGM+0bona7xBmDE314Y88r9rGUO8a72uZRAevGshGfyqRvoPVUVt6l6X8QZhUJvxFutdSxtMmjTJvfO8QKmDSoZ+979reS/X5V3r7X+u5e9/2pw2gCBjXvACJQvv2njc1gwGg8HQgEFMFEP9YPbs2eEWLVqEL7/88nB5eXk4FAol7dpcq6Kiotpn4cKF4bZt24ZPP/308Jo1a8K7du2q9nsy7x+tDCUlJeETTzwx3KNHj/DatWsP+D3VbfDWW2+Fs7Kywj/+8Y8P+C2Z9490bz4XXXRRuHXr1uF58+altO579+517btnz56q68+aNatqvKW67qFQRThUUf3z6b//EH74q6PCG7747IDfkj32qsrhu8+aGe+GHzr30PCsJ++OWIZUtkFFeXn47T9cH/7vFRPCu9avqnUb8Ax9+eWX4Z07dyZU982L54QfuXBM+OP7fhPh3qkf+1dffXU4Ly8vPH369LQ/94sXLw63b98+fM4557i5NhX3j3TfF198MRwMBsO33HJLQs9cUVGR62Pm6LqWYePGjeG+ffuGjznmGHfddNX9448/Dufm5oavueaalM43scrA/DdmzJjwkCFDwtu2bUtb3eMZb4WFha6Pd+/enZIylJaWhk8++eRwt27dwqtXr05b3dMx3moqA59LL7003LJly/CcOXPSPt/MnTs33KpVq/All1ySlrGvoM8ZT/opKytLyX0MBoPBEA6bEqWJIlK6PHZNf/GLXzjpMLsp+klnGdh5u+qqq9yOGXLWdN+fHdDf/va3Lt5Juu/NziASYu7NDlWq76/uYXofdr9uueUWtwOZynSKldetTE/sRY/Rx0pe247SomO3Wqs9Ei6Hr46oPUZecp1Tw6SyDBHbIByWvhNOl85Dx0pOizapv7+v7ihQRl74XWndq3/K7x1pbOG2qDEF0v3soQj4+c9/7lQRdXGbTPS+7I7jUujfkU8VIpWBHe8f/ehHTgWQSCaUut6Xtv71r3/t4lXVV91RexAAFzcHlAvpqns6xltNZQBXXnmlc/1DPZKuuqdjvMXzrr3ggguc4hLFU7rnG9ZYBB/WwNgW7NJgMBiaHiwmShOJiZIIkDsjtUbiapLSpgl8xnGjgqiqrYuOoWEiUkwUQ9NCvDFRDI0X+h6GbKhNXBBDwwWkHXM0Lk2JxHVLxn29Qalx4YondbPBYDAYEocl1DYYDAaDwWAwGAwGg8FgiANGohgMBoPBYDAYDAaDwWAwxAEjUQwGg8FgMBgMBoPBYDAY4oCRKAchSL+4YsUKl/LW0DRBikX6eM+ePfVdFEOSgc/7ypUrZdu2bda2TTheBn3sTVlraHpxq5ijiV1laHpxq1atWiWbN2+u76IYDAaDIUUwEuUgxPr16+WFF16Q5cuX13dRDCnCmjVrXB+zkDM0LWBYv/TSSzJv3rz6LoohRdiyZYtMmTJFFi5caG3cRLFhwwY3Ry9durS+i2JIMti8eOWVV+Tzzz+3tjUYDIYmCiNRDtIF+gcffCBffvllfRfFkCJs2rTJ9TF/DU1PZfTRRx+5XWxD0wTqhA8//FBWr15d30UxpAgoyejjdevWWRs3QZXRJ598IosXL67vohgMBoMhRbDcZylGOByu9vGioqKi6hj+HQqF0pIKDxKFF/y5554r5eXlKb+fIf3YuHGj62N2O62PmxZww/v0009lxIgR1rdNWG1EHx9zzDHWx00UpMBljj799NOtj5ugEmXGjBnSsWNH17fpSnHsXUem654Gg8FwsCIQ9lv2hqQvht944w0ny2bB5Pd7X7RokbRp00Z69+6dVgN7zpw5MnDgwLTe15A+oDKaP3++DB06VLp3725N38RUCizQ6dfBgwfXd3EMKVIpzJw5U/r06SP9+/e3Nm6CIF7GrFmzXP/27du3votjSHLcOUjQDh06OLI7XejatauMHTtWRo8eLcOGDZOcnBzJyMhI2/0NBoPhYIIpUVIMdiFQfhCjAqPWi6ysLOnRo4cjU/y/lZWVufOaNWsmbdu2TWqZuJ+SKbzskw14OYwA6s4iIhUvcYJrco8WLVpIy5Ytk76LhMsE7Z6bmyvJBjtF9C07RbRPKnaMCgoKqsiUVAQupI+pA3+pQzAYTPozk52dLe3atZNUgP6ln7k+z1gqdgSpA2O/ffv2Se1jghYyhhj//nkjWdixY4ebJ+hb5qlkI5Xzm1exw/xG+2NMNLb5TZ+xkpISSRXBz7WpQ2Zm8pcCjFPUFnl5edK6deukz2/Ma1w3Pz9fkg3anrLznCV7fvO/h3G5xP0jmWjM85uCZ5dnmE0mxlAq38PUIZl9zPxGGzFGUzVHR5rfeC7YGGP+oD4HkxqF/qTdmZeZe2h/nmNtB29b6N4xvzGGeUb03/o7cyPX0Pctn+bNm7u2rk+lD/WjnlpXykXZWQdHqqvBYEgdTImSYjAJ82JjIubFFu0Yv8vFkiVL5IILLpCJEyfK7bffntQyEfDsuuuuk5tuukm+/vWvS7JBXa688kpHHD3zzDNuEZpsEO/jqquukm9/+9tyww03JPXa999/v/zxj3+Uv/3tb3LKKadIssEC96tf/apbGD7++OMpWeQ+/fTT8n//939y6623unGUbLDAuPjii90i7qmnnpJWrVol7dqMm/POO0/GjBkj//jHP1KyIPjLX/7irv3AAw/IhAkTkn59DDDq0K1bN3nooYeSaqQSrPDSSy+Viy66SG6++WZJBX7yk5/Ia6+9Jk8++aRTrCUbqZzfFLfddps8+uij8vDDD7uxlMz5jXmToM3PPvtsSuY3YmVwj29961ty4403Jv36GAm8A1BHMkf36tUr6fdA7XjJJZc4t9Ff/epXjW5+4xnDUOVeyZzfFChUr732WvnhD3/o+jmZ+Otf/yp///vfG+X8puC6v/nNb+TOO++UM844I+nXZ13G2MHwfOKJJ5JK1BAsmHf8CSecIHfccYekAr/73e/c3PbII49UzW8Q3mz8QCzqBtDBYlBDGhKDZtmyZY64gpykj3l2IT4gQNR1nrU4fyEZO3fu7N5DkHUQUgCCYvr06S4JA4pA1mxsLFxxxRUybtw4t3lXXwofykT9ULevXbvWEYHUg3mEujKOD5Y+NxjqG6ZESTGYaKMpJZjQYZH1rxdM2kyEvAxRqyQTurvPLl6yr61GBi8tFlYssjp16pT0e6jhQtsmuw66a8oLNRXtw+4Uix3aCJeMVKhddHefhUEq6sAihPLzlz7mPskCCxieGxYDlD0VCwLGjSqBUtE+Ov4hyOjjZKo5UBdRdhZyqSg7YN7BuGCBmYp7pHJ+U9A+gLgEybwH8xv9Sv8in6eNkg1VqKViflMw7/CcdenSJSX3QOlIHTBekn39dMxvKOH0HZbM+U2hBhuGT7Lr0JjnN/97mPVKKuqA0U25eQboY8ZpMq/N/Jnq+Y0+9s5v+q6kTvVlSLOWRWXFxqFX6Uz78kwx76RC2cU1VfXGnAbBgNqO54txyne61ub5pnyQpJAtEBK41PGcq5qDvuM5op05DuJQFYL1GQWBMasKbNqULJuUWZU3BoMhfTASpZ6hLxM/q80ChYmc35O9QNF78TcVix+vnJB6pOIeqaxDqttHr0kb8e/G1j6AF7b2c7LroLuaeu1ULAb1uUvV+NTnNxXto32birkh3e3TGOuQjvlNn4FUtY/K3BtrHdI5vzXmd1hjnN/S+R5O1zssFUj181uXZ4eMUygkFixYUFVW4ndB+OBulAoSBQKFe6CcRAEE6YHb5aGHHiqHHHKIHHfccVX3RWkG0XXvvfe64PuU88QTT3RECkQPY47zULJAkqN8RuHSEAD5CrEI8UfZLYObwVB/MBKlHpGIcZiqXYV0XDfVOyKpvH46dnMac/uk4x7WPtHbIxVt49/NauzjJ9XXb8xlT9c9GnP7p+Me1j6x26ax93Eqrp3ONVZNUHUGgZIhUN5//33n/kLwZC0froMoPXAvQ70ESZHMvtXrKDnv/W/9DnKEcqoipmfPnk6ZAhkBqQLpAkGhrl16bn23rxfe+qSCjDIYDPHDSJQGioY4eScCneRTff1ULU5S3fZNIehbqtooHe2fjmersT+/6Wj/VN8jVXNQKuefdCFd7W9zRPrRFOa3plCHVKOhlF3dZD777DOXOY5YWpGSFuCGwvejRo1y2YPqw+1I1WW4+ECioEohkxIkCu4/uMgkEh9HNx1iudLEIrziOd97XjztFcvlqLGPeYOhIcFIlAYK/DgJ3MbLprGBhTNySl6SqYj3AZBYXnjhhTJ8+PCkX3vQoEEuaGeqfJnZBZk8ebJ7iTfW9IOUe9KkSS6rBPVJJljEnHPOOU6Wm6qXPeOG8YOfdCrAuCcYYqoye6QaBM+j3MnOqpLO+W3kyJEucGSyA7/q/DZkyJCUBIVOF44++mgXW0RjxyQb7Oief/75SQ3qq0B2zxyNTD+V8xty/mRmdkoXePc29vltwIABro9TEfQY4AJz6qmnptSlMJVI1fxWG+DqQlDXF198UebOnVuVecoP1gskNiBeCQQGz2+/fv2kPl2PNB5hbYl9VCwESucvsVN0LBE7i+eE+ZXnEfWNZvbxAlKJeQYiB/UObaRjUuOcMN8xn5IuO54gzvPmzZMVK1a4fiGOi5ZDU26nat40GA42GInSQMGkh9wR/9HGiP79+6csPSogqBaLCAI7JhsEwsW4S5UByQIdA4y2aYwGNqDckBzs4iQ7MwMLDV70+PymCowb+jjZ6bEVtAkLJw3w2NiA4ULgvVSRoOmY31i0HnbYYUkNGKlg4Y9vemM0vhR9+vRx4zRVJAG7ubR/KshoDAqeXw3Omor5DSOe+a0xEt2QJ7wfG/P8RvwM+jhVKdA1TkeqVbOpnN/o41TMb4mC+CMEZ8VohyCJBkgBsu8xN0A8QKanm0RRlQZl4fnmPcczrrFlEh3PBElfuXKlC6TNv3m3cQ2uywYTdWUs86wwlnWsaTk4h/bjGihhNLA+52qaZY6DmOKZizd5Af1ArBdIGdbirGe5TrLTqRsMBzOMRGmgwHf0sssua5SLdF4S7PDA8KfKCMPAJo1yKnaCUSlAAiUz5aEXGC2k/QSpSA2ZDvCS17STyVaisGNC+uRUtg2Lc4gsIvCnAox7Ulw2Rr9lFoD4rR955JEpW6CnY35DTYORkew+9s5vqZoj0gHUNOyWpqqPWbiTEjQVfQyBCzmTqvcL89uZZ57p+rgxKlGawvw2dOhQtwOfqmeM99bZZ5/t/t0Y11mHH364I6IbAokCgfK///3PZbqJBxz3/PPPu/F5xBFHSLqB+gOiAfcjAuCiioFU5pPoWKAuxHs5+eST3ZiFKNHYK7QLQWn5nZTvKPNUOQRZAjEydepUVw5IW57Z448/vorMgQhB4TJlyhRHUBH8Np71lmYt4/o6zmlr/t2Y1ZMGQ0ND47TgDgIwCcPSpwK8dFmcpOr6mtYyleAlkyqlCC+ZVL5oaJ9USegVXJ8FQap2IlNZh1SO/XT1MYZFqtoeo46+1VTlqUCqyYF09DGGXiqM7HTMb5SbPk7VLrym8EwlIEFT1ccYA8kmb9Pdx7Q/7+FUvMca8/zmnedSSWCl8h3G2ERlhwKhsc1viUDjbkBKQCagvogHHEfQ2UhxU5JdPtQdqnyhz/kOAgXXG+7PPAXhQF/Rb4kqUTSFOy7mECQ8F6peY/6G0KBtVGWibQbBwfe0A79xLApZ/iqRgxJF7xGPSgbXHZQmqFu4F2olxjh1U1eixqiMNRgaKoxEOQiBVP/SSy91UlZD0wQSWfq4Pv2NDakBCzViBaQi1oSh4bhjoMZip9nQNIHhdckll7jda0PTAsQYSh0UUwcDMNq//PJLZ7jHA8gBjue8VILyoAAhXgtqD5RlqO/IwgPhwDPIehilBmRHbQgG1tEooyFP/KSWxjEhVszSpUvdPRUoYKZPn+7agfZAPUasEq8CF9dySJWxY8e6stfkWsg1qSt/IYiIO8a7pDG6JBoMjQFGohykRpimmTM0TbArcuyxx6YssKCh/sBi7ZhjjklpzBhD/UJTgaYqqKah/kE8F/o4VQHMDfUHlA/jx49PWcyehgbIA+YsAqOqeiIWUFVwfKqVNJAHuOqw5sVdBkBGEMiVcpKRB7z11ltO+QehSbkSUWJC1EBY4HrDdVHZcA/UWhrvhA/kDb9xPPWHUOF7Yp6gGkMF43clgtShDhA1KFiiuc5RF8gTFC0ElUUByIfrKYFiChSDIfkwEuUgBOw2H0PTBbLQVATdNTSMXU78pg1NF+w+ErPE0HSBYTdx4sT6LoYhBcD9gk2Mpg41zHFNYzwrOVETMO4hmFLtUgiBgLqDD+9MjVXCB0Jj2rRpsnz5cnnppZdk9OjRzvUFt5d4SBR1y6G+kEezZs2S1atXO2IGYgTCQ4kTlC8QK/ybj5Io+j1kUiQSRetQk1qNa33xxRcuuO3MmTNdnBnI2cYac89gaCywJ8xgMBgMBoPBYDAkDNyGCaz67LPPVqk7YgECheMJ4F9f5A+EBdnDIHIgU1CFEASWTYp4FEQoSiBBIE/eeOMNR1oMGjTIKV5QlnAP4q4Q9+Tdd991WYmUeElFfSBtUJdDZnHP9957z6lrIGmojylRDIbkw0gUg8FgMBgMBoPBkDAw3HE5IQYIagiUEZEIAwx5CAaO43jNVJNOKJmAwoOAqwSZRQVCoNd169bFnQIYtQkkyfr1610qYQgM3KjJsKMBi4lNgqqFeCwKbRdID3W1gehQhYy3jHq8BuyNFlxW2xVXX+7NfcnqA5nCf6Ns1POMTDEYkgcjUQwGg8FgMBgMBkPCQIFB/CaUGbiT4B6Da48fEApnnXWWC6I6efLkBpNuF0IDUgQihb/xADeelStXOsICEoRsTNTLG+cFAgSXnkiEEgoY1Ctk50G9A/HENf0ZqSjPp59+6v5yfY2f4r8WcdKI58K/icXC9d555x2ZP3++XHPNNc7FzALMGgzJhZEoBoPBYDAYDAaDIWFg+KOSgEwBqFFQaSiRoinVCXYKEUDWIhQS0QKlpgMQHwSEhcBA6aFKjkhxSaIBUkKVHZAcXMerKIHIiBZsF0KJwP8afwUCClci1Cx6TVQxtCHtGUmloqAdaV/9cF3Spy9cuNCRPKhlcOmpD+WPwdCUYSSKwWAwGAwGg8FgqBUw5FGXnHjiie4vCguMeM0qg/sO7jPE6UBJUZ8EipIeS5YscR+y2hB8lgCuED3xALKFBA0QL4BUxYsWLXLpiAnoCkkDgfH55587gsQP2oIAsNwfNyJiq0C4nHLKKVVKE74nlgoZd7zBZ2tyyYGoIk7NnXfe6Vx6XnvtNedmNGnSpFq1lcFgiAwjUQwGg8FgMBgMBkOd4oxg6EMQoLDwuragsMClhN9T4VaC2oPgsBAWKDcgcSBKICE0RotXNYKbDcfh+gLBQEDYYcOGORKF3yEwuNbcuXPdNQBphCFIOB7lCsoOSKFDDz3UqUY4FmUL9YbsoDwcR325nxIq3Af1Dsfxb9oEFQtEDC443INzIHdQoqDwwVWH7/hvrktZKJfGcPn4449dXBaC9XIeH02pTAYi/nI+blf0Bf1j7j0GQ91gJIrBYDAYDAaDwWCoEzDMIReUYEgXIEpIMYz6Zfbs2S6wKmqQZcuWOUKEv17CBaKEsuJCM2bMGOdiRLYeiBYIB46HpICcwDUJoAjBNQbSo1u3bu4cPhAZxIJBiUIMEn5HocKHILoQKtyP7D+rVq1y30E08TuplVHBTJkyRdauXevOp1yQLBAwkB1nn322Iz4gVyBQKBuEzNKlS6tcpt5++21HtuAmBRmDAoU2oS6oXWgPrk9adVW1GIliMNQNgXCqcm4ZDAaDwWAwGAwGQwoBWYCqhA+kB0FiUX9AYEAWQEB4lSiqTIFMQH0C+QChAvgNsgJyBOUI1+YDscEHQgMignMgMcjww4fjuReuStyXe3J93HT4jXP4QMCoEkXVIpAzkDv8W1MWcy0+Xbt2dYQK14QYoY5ck5guGm9FywM5Q91VmcP1aQfKwjGQW6hauL+RKAZD3WAkisFgMBgMBoPBYDAYDAZDHKjfyE4Gg8FgMBgMBoPBYDAYDI0EFhPlIIDmqkcmqFHCkfGppLFt27ZO2ueVOxoaHugrpKPIM/lLX9Fn9C2+v/jOIh1F0untR85Dakr/e1PtqdwUKWsiaf0MqQd9Rp8i2UWSi+80cl76yivB5TgC2dGvfNQ7k2PoU8YC5xkaDuhX5NY8j/ocqx8+0OcR6TXfR+tjnl0+jA3mb0P9Q9ObMifz3NLXOhdrX/Jskm5Un2P9Hok+/atpUr19zJjQjB2G9PQjoB9xDcEVg2cQNw5cPnC18K+VOJY1FQE9NYgn1+E7nlFSz9KXmpVG38fMAbhoaLpczuHZx+VC5waDwWAwNDwYiXKQgAUAi7r//e9/bmFHlHQ1yE8//XQX1ZtgV/bCbrjQlHwEDCMKvBImECQsxkghSMq9cePGucWa9zyCnnEeAcd0YU9/s1A7/vjjHZFmaDigzzC0CUT3zDPPuD4l+Nwxxxzj+twLAukRUI/geTzP9C2LdvqUFIpE4zc0HGBsrVixwmWPWLBgQZWhTDpMns0JEya455hsEQoCGtK/BAbkfPoYw5o+Hj9+vPOxNzQM0D+Qn88995yblzUlKR/6l+f33HPPdUa1GtQYznPmzHHzM/3M88/xzM98dEwY0gf6AGLrvffec5lQPv30U7nqqqvkhBNOcCSHP56EEi0vvvii26xiDmY+5rujjz7aZWHheVUyjO8JMsqzzV/GBdeEXOHZP/nkk6uytBgMBoOh4cFIlIMALNxYBECisBBDsUDwKV70LBIwwNhtOeqoo2y3q4H3o6bkIwo7CgMNbMYCjoUYi3d+0/SCBB7jdxbn/B0xYkTVLhrf8cF44zsWfbqoN9Qv6M8vvvjCEV9qhNH/XrB7SZ8SkI7I+6Q2RJHAsTzb9C2GOoQpBreXWDOkHxjKqiJbuXKl608MK92d5tnFcKOvVD0EkaZ9zFiAKNXxQN9qH/Os+1VKhvrpY/qJOZVnmPmZPlOFAYQn/QkZhkGNsoHjdI7muR06dGiVKpT5XvtYA2DaHJ2efuSZg+hQFSDzLc9nNNCnrKWYb+l3goHSt/QdGx1kjIEM10wtjJEZM2a4Y0mRy3l8T+YVziPzSpcuXdxmh8FgMBgaHmxVfZC4BcyaNcvJTI899li3cOvXr5/b8WKhwE4LGDt2bNUC3dAw+5I+4y/qERZdkCXsfEKWvPPOO+7f7Hqx8GLhB+HCYg2jjUU4/a8G2lNPPVWVso+FuV/hYKifPgb0GzufGNb0SyQCBMMLI4s0jBhaF1xwQdVu9bRp01xqxr59+7odb5WSG+oXGGIQ1hjTzMNnnHFGlVGsykA+6l7Hc41RjnHG/H3JJZdUqcbeeOMNmT59uut7nmnmAyNR6v/5xZiG1IQA69Gjh5tzAe9h+pFnFkUh6k/GAIY6hjYkOOPjsssuc4Y7eOmll5yKUNOq0sdGoqQe9BXvTPoQIoP+4LtIySz1O/r0s88+c2pBCJQhQ4a4Z53rkI6WD4QaRBjvafqUdzbzNu9z5mied97X3BfShTnbSBSDwWBomLBVdRMHC3J2NXRXhYWbLsL5y2Kd7/lguLFAY0FuRErDAwsqpMRAlQX0E4YTC2x2o1WdwGIbYGAtX77c+eD7dzFRI/Xp08cRMyzacPswI6x+wU6kGsykItT+iBQPgV3r+fPnO/UJ/eg9Br99iFJ2QDHYcfew2Cj1D55FjGgMJgwpCGyMM/qd73iG6TftKwwqFEn8hiHnjV3E/M2xmoITg93iZtQvmI/pQ/pP04xqKlX+Mj/zPtZjASQZbl3Mz5CgXrKTeZs+5hiu1bNnT4tflQbwnoTw4BnlmUIVEg0cQ9/QR7xL6TPWWVyD93Dv3r2d4oR3MaQKpDgkGwQ5rlr8N5shHM+9IL4h4tj44lyDwWAwNEwYidLEoS94SBKMa4wrNbBZ7LFgg2hhB4QFHotxM7YaJlhkERdD4SW6NMgsH4wydf1g0cbiDgOMBZs3IB7jgF0u3Lw0IKKhfqBtjzFNf+mzyvPLvyORW3zPYlzl4xqYUJ9tSBgW6hzHdQz1C/qYZ40+4znU3Wj+8uEZpR8xmrW/mZc5nu+VBNU+xvCijyHcMNhjuRoY0gfenzx/9DfvU0gT+oz+4b+Zm3WuBmxeQKxFmqPpY+Zo+pj3tPVxekAfsMlAX/FsxloTcQxrLJ5V+lIJT/oQUkQ3rViDMRb4QHzyl2O5tpKjGnSY8cBzz9yt7wbb2DIYDIaGBSNRmjh4UWNI8XLWYGiqRuClzL/5nt1sjtNgpYbGAc3cgeJAF93qwgFYhNGvLAj1O4W6ACAjNxKl/gGJyUIc5QH9OHnyZKc0YTEd7XiMK4xrnlmvyojnmIU8i3GuacZXwwDPIv0JeYJ66Mwzz6yKifLyyy+7Z5F/4+YxfPhwR47QxxjXflcOnavZ4TYDu2GAdyrzL4YzqiPm37vvvrsqsCwfFEO4zup7lj5mXGA808deY5k5mucYhQPvcn9cJEP9AwKFZ1Sz6viDwdKfrK/UXQcChQ/n0bde9Zi61XI+12SONxgMBkPDhJEoTRy6k6KESaSUefo9hpYt0hou/P2mxAcLcNQLGFos4vjozpa6Cmj/e8F/s1jTY0yJUr+gH/mw4FZ1SazUtZo+U126/Mok+lfTrVrfNgygRNAMShhPqI00DpWmNNYgov7n169G0udXx4GhYYD+1VTy9A9EiL5jeRb987B/jo70HEeLx2Gof3ifv1hrLO1HVZ5puutI/Q1sPWYwGAwNG0aiGAyNFLogI2AdPvWkRGQHWzO0mPy3cYEAkgSJnThxotvJtvg0TQ9qPKFCQZGgzyrQuDY8zxjhpLU1NL45mWDdqI344JpFOmPdpCBdOSoEMrAQ/4TfDQaDwWAwND4YidLEwS4nrgEs7tQfm48u3NVvm8W9uvUYGsfOF/EVkP8jH2YxTnwE9cXW/tWAs/QvO6SR4uVwjAUTrj/QDzyDSP/xqYdIQcqNyweZHVCnsDuJ7B+yjBgJuAzQ7/St+uR7d6oZH3ynbnyW0aNhgGeNOdarONCgo/QVH/pOd7a987e/j/X51XFgpGnDAPMyH5SBXqURfct/02cEDqUvmbf5nf6jz5mjI/Uxx/hVC4aGAZ1jQaQ1FtD3L88+zzMf5nt/2mT6nv7mfHUNMhgMBkPDhM3QTRwa90IXaOq2oQt3fWnz8uc4XQwYGh50ca0uGhjbb7/9thx++OEufgKpGNUNQPtY+5++Z8HmjX1Cv+NnzzH4a9sCvX6gwSeVRGEnWxfPuHbgqkXcG/qJ48jQQdYGjXvCglvjJWjfakBajC+NuWGof3ifNS+R7Zf8q1slRhduXczb9LH3+VXijXHgjXVlqD/QN8Qh4pklxS1xTrzxUCC66be5c+e6PiUdvfYx30OU+vuYfucYr2rJ0HDAHKubF7xTmXt5flVJyL/1/cv6imP5EMeMvqWPtb+9czljgmfb+txgMBgaJoxEaeLgJYwR3bVrV/fSJkAdL3rcPtjhRlrM7ywEeGlbZp6GDRZc9OPHH3/sjOOjjjrKGdSoEwhaR9+yC8qOJ+4C9DuL9Tlz5rhFnDfmDelTUbKw2EdabkZY/T2jtP2xxx4ro0aNqmYsoTyhzzRF9ejRo52rD8fzl75btGiR63Ov0ogxQmBLsjmpi5ehfkGfQoDRd5999pmbd72ENn0IaUZ/8TzyPf1OHzMOUCfx/CuYv+njAQMGuOO96Y8N9QcMZA3ojRpFQR/zXPJRNQKg70inSxBpyFJvJi3ezytWrJCBAwdaHzdQ8B6mL+lHUsnTZwR7Js0xhAjvWZ553sXM4bybURJCmPNM0+eQZ8zRzOGoD/nvoUOHuve6wWAwGBomjEQ5CF7wLN50R4wXPN+xuGMxxwuenVElUGwh3rABEcLinAU3BhlycF2M872mRAWQKCzYMLymT5/uyBRVowAWcaRAxhg3EqX+oG4c3vgI6n5Hn2Js048sqHv16lW168n3LNohUXiWWXhrNgfGgZ7L4t2e64YBnjUNPKpyft2xxpii3+hnTYvKvEz/oU7iWaWPlejmWPqd8YAKzaT/9Q99LvnQVxjR9LXGRKHPNbWtqj7pP/p41qxZVc+w9qVmXuP5h1wzojs94B2pijBVl3jdcnQ+1eDO6qpFFjzeqxCirLl4RlEl8TsqJN7VmiVRFcKalY170v+sybgv73fLlGgwGAwNF4GwhXxv8uCFjOKAlzMKBn3h87LnpU26RRZo7FrbQrzhgsXbCy+84PqS4JPqzqFSfn5ncT5mzBjXlyNHjqzyqX/zzTcdgebd5eQcFoMnnXSSW/CZdLjhgEX4tGnT3K7kkiVL3GKaRTd9i8F82GGHVbl1ffTRR25MqCxcXQfo3/Hjx1cFLDUDrH6h8acwmN544w1nTGNEMefyHDIf8yxPmjTJzc/sWvM75zAW2N329rG6/6BggjC157f+Qd/wnmWuffXVV6sUYwoMavqaIOB8j9GtrrbvvvuuI8D9czRj4oQTTqhy1zT3jvSsmYhbAxFNyvnFixe7tROus6iCUIfRf5DaSoISw4q+/+STTxxZxjsVggQSjONRjKJAgURhnNDXkKOMCe6jhAnHc10CSzPn6yaJwWAwGBoWTIlyEIBFFy98/mJ08wLXYIT8ZSHHLokZWY1HOszOJf3pJb34N4sujC/d5dSghpBk/JsFm/KmGGqMB84xd4+GBxbnqkRAfaBKMQ1KqjugLNYxwuhbNcB0HPAxF72GAU1rzPOLgghjCbKM55YPzyN9hUoQMhTwPX3MHI1hRx9rIErGBs9vTamwDemFvmNR90F6eedo3sP0Mc8szyjQmEX0MaCP1e1S42dYH6cfSlIy59Jv/fv3dyoxJaT9ZBb9xPc8x/pu1ng39Le63CnJTf+jNtHYZPqscw8+XMcytBkMBkPDhSlRDsKApED98IE3KKHtcjVcaP+p1DgS1LjWv35psld4pos5y/rQ8EBfaRBo7TNVH3j/at/6x4RXjWLkaMPMrqV9659zvUa39XHjfdd6g7h7f/fPudbHDQ/6bHrfnXx0PtX51x8g2t/v/qDR/uP972U9RxVI+p3BYDAYGh6MRDEYDAaDwWAwGAwGg8FgiAPmzmMwGAwGg8FgMBgaLeIJ8WjKnuS3qbW14WCFkSgGg8FgMBgMBoOhUYIkCQTfJsDvmjVrXMwpAvsSg4o4RMSZIeD+sGHD6ruojQqa8VEDJxPDx+s6zL9pX+L/EL+NGEDE+iF2kMYAMhiaKoxEMRgMBoPBYDAYDHWCiw0jGNn6txIBCYoEghLY93/JBkGcyYpFprq5c+e6v2Q8I6gvQX/JjkQwXyNR4u9H2pQ065BTS5cudRmrIKs0uLnG9SGRAR8IF5JUEIiZ4OiaCtxgaKqwmCgGg8FgMBgMBoOhTgiFy2WXrJMi2S47ZPm+b4PSVvpKbqCttJBukpGC/VsMe5QnGPlkO7rnnnscmUJ6cFJGH3XUUU4loamkDbEBAfXaa6+5bGEQUocddphL760ZqrwB8JcsWSIrV66UOXPmuP8+7bTTXJsfeuihpkQxNGmYEsVgMBgMBoPBYDAkDDQn/K9QtkmJ7JZN4Xnu30qioEIpCeyWvHB7p07JkRaSK+34IWmqFLIZoX5AEUF6aP5qKmn+mxTTljI6jr4Mhx0JtWPHDkeMFBQUOFedNm3aOHcdlD38t5dE4RjIq1mzZrl/o0jhvw2Gpg4jUQwGg8FgMBgMBkOtADmyOPyirA9/LvPlaSmV3RLa584DTRIIZzjyZIRcLJ0Dh8mIwMUSlMo0zoaGRaIsWLDAESiffPKJDBo0SK688kpHnrRq1aqasoR/Z2ZmyuDBg6Vfv35VsVP4zmA4GGAj3WAwGAwGg8FgMCSMwvBW2SubZYPMlo0yV0pkp5RLSUSihWNQrnSXw50yJT/QvsG1OOoKyABUFQSohSwIBoNOeQHJQLBaPj169HCEgSpcysvLZf78+S6OCOfyG6oNXGBwI0INw3e4HUE4EGdkwIAB0qVLF3cc90UBwj03btxYlRmHeC5g+fLl7h6Ug+tRBuK9cNy6deuqygfZgQKHAK8ockC8AV65BjFQuB7ncn1inBA8ljbwQq+p9ceFBzUQ9eX+QOtDPBUULoDyEeSX73ft2uWUK8Rf4d4oXiBuuB9uQ/zOeZSJ9vHWg/JxHP3AsZSP37XdtB85f/v27e53PvzOcRBDlLdjx45V1yR4Lq5Mq1evdmUC9Fu3bt3cb5SV/uV87s01Onfu7PrCYsAcfDASxWAwGAwGg8FgMCSMnbJK1oWny4rwm7JZFkQ9rlyKZaW8IwXhTdJJhkmXwEjJl4ZHokBUEE8Fw/2LL75whjdGemlpqTPAMZpxbTn99NOd8awkAkb3Sy+9JCtWrHAkBL9BQIwcOdKRBhASGP6QB59++qk8+OCDctVVV7m4LZArXJ9zFy5cKNOmTXPXw1g/55xz3N/HH3/ckTMc17dvX1cGSBiOI34JmXMoH99BvHzlK1+pIlHiBecvXrzYETYEiaWu1KEmEoY2Gj58eJUbj5IotCH1efnll92/ASTJJZdc4r5ftGiRi7kCMUE9CPx77bXXVsVegUyCCKF+kE9eIoeyUUb6gbZVNyMF7UQ/0hf8pY25JuQKhAf9AgEDEaLXpd58nn/+eUemgKOPPlpOPvlkp8yBXKG8tAf3HjNmjBx33HGuLEaiHHwwEsVgMBgMBoPBYDAkjB2ySlbKe1Io2+M6vsidMU2aSWvpKqMaXItjZKMSwWg/6aSTHBmCYgGlBIY+BjlEyDvvvOPIEYKuAozoyZMnOyLkySefdOQDZAfkAn8hNCA6MNI3b97szuEv/80xkAB9+vRx90CpAhHBfYcMGeJ+478x4Ik9QlkI+or6g5gvkBIQLFu3bnWqj9mzZ7vzuBZkSzzxYCCPIB5Qj0BqaMrieIGKhOPVzQdwDU0zDYnyyiuvuLb7/PPPXbknTJgg48ePdwqPt99+230HUKBAYtDGtNGoUaNc/WlTzQqE6of6ch5KEa6jZA/kDG1IsFvufdZZZ1WpW+gD1CkzZ850bch3lJNr0E8QOBxLW7/xxhvu/rQnhAvBdbWN+I46vfnmmzJp0iQLWnwQwkgUg8FgMBgMBoPBkFhAWREpCG+RzeEvpFT2xnVeqRS443vIuMqAKQ0MGOm4f0A8kGEG9xMlEyBWli1b5gzrefPmOXKDYwDHo26ACIAs4C8Khe7duzvXGgBZgLICIgH1A2QBxj7qDEgCXEf4DhcTDHsMeox7fkNdAoGD4c81OA4ygd8OP/xwR3ysWbPGGfYoJpSIwV0oHihJBMGAokQD9cYDDeLrB6QH5Aq/US5ICa5N+agrRA/tyz1RpvBv2oV24sN3pK6GnKI9+NA/ED7EbaGOtAnnH3nkkVXuPBBJkFP8pd1oH+oCYcL9uebUqVMdCYOihO/pJ8qEMoXyUhYIEtoVNcvQoUMdaQYpxH+j2IFMQS3D9dWNKF7XKUPjR3UHN4PBYDAYDAaDwWCIA8WyS3bLOueuEw84jjTI/P+GCIiRiy66SC644AJHZkAmKDSQKgoQUvtixPuBsQ45gJoBAx9CRgEJg/GNIc91IApwGfJms4EcQUlBOXDN4Tp+QNjw/ejRo50BTxkhA1C0QAbg3gJRgIEPORIPUFhARmjsEYiFVASJhVwaO3asU3VAilBWyn7ZZZc5FySIJ4iit956y7UBQWshoTgGqNIFUgMVEIQMyiHOoe2oBwqUGTNmuH7ARYj2UXcbrglBQltBmLz33ntOPRQNECu0M32uBAtl4TsIIo27oiSK4eCBKVEMBoPBYDAYDAZDLRD2fBI5p2ECJQQKCg30qu4jgO8gPHAJ0VS+fKdBSwHGOuQLx0BkYGBrfBMUFBApkACQCRAsHIPhr0Fj+TcfjsH49wd0VRIFMgACgo9+B/EBicNv3FPjpKQClBGVBuXmo/dRgof6RVJlUEYNtqtxTKgjhIrGn6HNIICUxEG5wz28oO21vWhTzuHeqvDhHMpEO0CweMvC8YDzOU7Jo0htTXtSXlWyaB2on7oHcS7XsjTaBxeMRDEYDAaDwWAwGAwJo5m0kpbSQ3bJmrhcejIlR1pJD3deQwTGsKo4CCaKgc1HDWx1d8EQV/UGBrb+zr9RP6jrDq4/uI1ACPAdxAFKBlx4cCkh9gaGPGQI1+K6KBy86gk/1L0o0u9cH5cTyAOuFS+JwrU4TzPYKLETDdQNtQj1o72UmKDsKEAuvPDCiOdRPkgm7qWA4PAqfmgn3H9oM65/3333HUBQUDbqSLkhMyCkKAMEjvYZsVdI2fzhhx9WI1GoHzFkOJ/rKjnGuX7ih/5EgeINXEsbaf+oGxTtFel8Q9OFkSgGg8FgMBgMBoMhbgT2BTTJC3SQDjJIisLb4iJRsiRfOgQGuvMaEjCsMcIxrglaigoFAxrFgZdcgDDgA4nAf+tHgeGP0Q0pwr9Ra6CEUBKF3yARcBPh+hjhEAAY6Zp9B5cWfotmkGva5WjQ2CCJqFAgE1T9AhlAWbxuRn7QJsQbQbVDEFhckDSWSazzKJsqRrzfeaHqH8oCYQQpoyoQ/zH0GWVALQIgRPiN69OOkDqoXPyAhOFYCBBinVD3SO3Ndfy/8W/9aFnMnefgg5EoBoPBYDAYDAaDIWG0kT7SV06QrbJI9sqmGo/Pk7bSR06QtnJIg2ttFCEoH0jJi1FMjI7+/fu7+BkAo5tYKMTgIEtOJGiQUtQmECGoUDgHQxyDnAw8GPVkgtFAqgSEhXyAcOEc7qmZaiKBcyAiIhn9fuM+XqiLEKSDuhnhFhMN1I/0zNoujz32mAvmumXLFufikgiJEg2QTWTFIT5NpMC1flBu2lv7gZgptDMxWOJViPhjyGh5/ef7lS1Gohx8MBLFYDAYDAaDwWAwJIzW0lMyAzmyRRZKs3Ab+VI+kwopiejG013GSefAodI9cIQ0l4713tq4fJDlBYIDAgEDnA9qEBQQBHbFkPcazBjZNQVr5XiUKBAm3ANyAdcPiBGyyEBU8N+oUiBUIG5QvqD+wOgn408i6YWTASVfIHAgDSCJ1BUJAsOfqcevzEgmNFAu/aBZiPykBYCs+eyzz1zZcI+iH2lbdavhXIgpfxm5Hv3C72Rbgqih3Q2GRGAkisFgMBgMBoPBYEgY+YGOkhduL11klEt7vFUWOwolLJVEA6ZrQDIkR5pLFxkpXeQwaS8DJRioHuOiPoArCNldIFAgLSAyUKOgrMAgJz0wBIJXZaCBVKNBjXWIAAgSlBmoOtSwh5ThmhAVkCqQBdyXe1IeVCy4ofjdV9IBysf9qR9xRGgLyo5qhDbyqlz8bjXJVGPgKoR7jqpzNOiu9/7qykN2IxQ9kCAQU/Qjbc2/ORdiyl82/s216RtctzjWSBRDojASxWAwGAwGg8FgMNQKAQnKwMDp0jtwjBwSniiFsk22y4qq2CltAn0kT9pLJxnuAsoGpf4JFIBxjguIqiwgNyALIFCI64GBjkoBRYlmeuE7UuLWpEYhTgduQG+++aasW7fOpciFOIFcUUKiW7duThHBMRj73AsCARIgHneXZIN7En8Eooc6UqaHHnrIqWdwjeF7f8plCCDakHTPEC7JUKYQowS88MILru0gOiB3vEQHAWO5J2oZSBDaVYPPUlbaEbcr1Cy486AM4hj6kb595513XP20zw2GRGEkisFgMBhSBhYrSGZZeLGzlurFoaaQ5IPUl8WwSnxre99I12SxxjVTkdJQ78e9+KsB/1J1P4PBYKhTgNmAOPecvHBbCQaypEi2e7LvBFz8k7xAO2khXSVDImecqQtQceh8qRluNAML7x8y7USa/zH6IQEgRFTBgPGNQoTvCB7Leaoi0bS+vNfUGCdoLKoJjHGMeb0P56AyYe7mPH3/eeOBYNhzjGZ3wcjXTD9eIoJ3AqoQyqpplbmOEkCUl/qr+wrX4zjqzzFKINREbvA79aDuBI2l3XB3UpKE+yoBpOoOyqRtSP04X+O5UA4+SrRo1h/aXa9Bu/uzDFFeSBOIKI7XFMXeLEh8x3WoF/fUmDNcEyUP7UHZ+Us/ojzhupSTttH01ZopSMvGh7JqPBiOxaVJSRrOp421LwDHomrhWvRztCC1hqaFQNgi4RgMBoMhRZg5c6Y89dRTMnLkSLe7NHjw4LgCxNUWLKzYtZo7d67zdWZxy4LqiiuuqJZSMRGwOJo3b577LF682F2TxRLXTIXfOgu42bNny8KFC92uJwtJfOevvPJKJ1s2GAyGhghnWDs3Hv5/RdX3TnmCK4YEq7L6JBOaHYb5mXka45nvmDcxvCGgIxm1atAPHDhQDj/8cBk6dKg79u2335a1a9e69xcGsZIDGngVI/q9995z8zFqkuOPP97F5OjZs2eVqkFT8N5zzz3ONeaUU05xipZjjz22ijSA8KGct9xyi7vm2Wef7d6TKCm85UVtQeBWyADcjzDkIQx4n6Jwufjii139n376aXeMkiuUmfgqlO3EE09MKLgqZefdx3WJ6UJ7QBqoAoe/tB/3oX0oB+2N6oP3IkQKaYo1FTLBc+kXjocgITsR79HJkye7//bfn4+qTWhryBDKT9vxoW60P+3KvSBIlJih7SGQOI/78y7lHO0b+pS+oO+OOeYY9xsECfWEOHr11VfdWoK25v1LWelj6ggZw28oWTQAL99zDP3HegM3rvpQEhnSC1OiGAwGgyFlYNHCwopFDgurVCsp9H4QJiyoVIlSF7CzxDXZidJ0hyy6UrXTpAEHdedQ72cwGAwNGS5mxT5XnWAaTQzmSN4xGOOoJVSJwHuAuTNaumCOhcjAmOYc5lzme8gQJd11DlY1JfdB6cL3fIfxjgGt7wcF/+beEB38m4CtqE68x/A794F44JoY45qq1/9ew5UFgx4DHaKA+1NmvSblgCzhd+qkpAEuQhyTCDQGiipCAKQFbaokipIVHMeH+DGQGrSPkhW0D/9N3Sk79aMtOU4/fvcgvT/14z3I8cOGDavK+MMaQt2ilEjxB73lHNqV+6lKRRWd+jt9TlursgZwTcpJn/E7bc51uIbWj+O5FkQX7cxHSRz+qmrJ0PRhShSDwWAwpAzs6rA7iDSYXScWIKncoVFx5euvvy6ffPKJW1By35NPPjniYi2Ra7I7+cEHH7jFFItSrllbdUs893v//ffdbhcLZRZ77LilUsVjMBgMjRENSVQfT3rhmo6JFLw1WeVKBHW5r6pC4j22rvePlL0nVeVNtDyGpglTohgMBoMhZWB3pl+/flV+z6leWOj1kdzix0yKSgiIuhA33msib6Y+7JClSlWj92OHCxk3smNIG4uHYjAYDNHnzMZWpnjLXV/1q+t96+v8dJ9nODhhJIrBYDA0IuhOifoM63+r/JW/+ptCf9OdlkhZBVQe7A9ox/dInvU+eh016L2pHvU3PZ/zIE6UANBzvGXwpx30lzfRRY1eAwKCwG8aJNC7y+RtN/+53FsJF/9uoQajUwm3+o1r2/nbz3u+Nw2k9/tIdY10v7oExjUYDAaDwWAwJA9GohgMBkMjAsQEiggCjuKuQlAzfIXxGcZ3maB1BNYjoBoGPob3qFGjnEsLqQsJ7Pb555+7cyBANNo8QdjwAyclo8bjINAdSohXXnmlKro+Qe9wkSHIGtd/5plnnLHPtQjOx2+QFnyHO4r6DJ955pkyZswYVwd+I9AbShHSF2okewLs8W/UI7jM4N+dKCiHZgTieqhQuBb1pLzUk2B1BJDzEim0AecShA9/aHys1X/ae03NkEDAPNqRutEu+FFzL4LU4X7jJTxQrxCIjgB9nI9fPdekH/EV1/rS5trHGnCQe9KetGtdY7sYDAaDwWAwGOoOW5EZDAZDI4IqGiBBIDlWrVrlDG3UHsTLwDjH+CYSvqZU5FhVTEAGQLwogQC5wDmq2iASPn815R+/cR9im0A8ENOEaxKVn+sSsR+jn3txbe7DfxMkj3MoCx+uodeDIIA84Xv+rakJIRggUyBulFBIFBqVX+urKSu5rrabpr2k7qoA4XvKQzA5fkNBo6QF9eEcJZ74bz6aQpLz+I3yQ2YRfI576v2ULKKNOR6CRr/HzYljUZr4SRTamDrQ5loHg8FgMBgMBkP9wkgUg8FgaETQLATjxo1z6Rjvv/9+mTNnjlOhoDbBsMfYxignpSHqEMgVvsMoxxgn4jzfczzfY7CvWLHCfV588UU599xzHSmDgY/Bf/XVV8u0adOc+oJziPaPoQ9RAWFAjBCUKRwLmaKECKoWCBtUGJQBQoB0g1yHgKkQDqTt5Xh+g6RB1UEgWoiJ2oC6aApIJZY0oKyqPzS9In81qj9lQjlDeUlHedxxx1Wdp9ekTJoVALXJhAkTqtqPdnvttddcAF36YMSIEVWKIfqHtMuXXXaZU51wPkQNihhUQ48++qhcd911VVkZOB9yDKLF2w8Gg8FgMBgMhvqHkSgGg8HQiKDKCc1yAxnAR9UlkBiQJRjrfK8BXVUFwgfjHMUJ6hCuhWoEpQTKCAx4CBK9D6QN8T8w8FFpcG3UJxj1EAoQMpARHKNpBLWcmgZSUx5SBpQY3JcPJAP/rUQHbkQcBzkDWVMbUD4UH9wXgscfzFZJDwgRVdAAVDPUn7Lw8caNoTyqkqEutAUfTUGsKTTpD65N3bg294AooR1w14HYoj+0jpQPcG2OUfcq/vId7RWpDgaDwWAwGAyG+oORKAaDwdAIoYFaUYFg8M+cOdP9XbZsmRx22GEyadIkRwYoSaBuQBj5kAXEJIHEwPBXo10DxnpjhShhQ0wOYpoQ14MPsVUgVc4777xq91FwTYgJyBGOU/cg7gPhw71x2+FaEDEoO/hANkAA6b0TBSQQahfqQZm95aKu/DcEEvdVwghA5lBeYr740xZDcKBUgcwgUw5xTPirUJch2oHraJwaroc65fDDD3exaqifqlu4lga8Vbcm7sN1OJc60F7UobapmQ0Gg8FgMBgMyYeRKAaDwdAIodlmICj4S5BZ/qIKwQUEY9wbiBR1xttvv+0MdcgUjd3BdVBOQMJAfKiaxXsfgMFPwFXcTCAKUIpwb9QYkCx+woNrEVAVNQzHqlKD4LVcH1ckyoHrzNy5c911IFMI0Mp9KLs3k028gICAnIHQoB0gKzRwLmV/9913nWpG76V1xV3nzTffdOehGPG2nV4TMgNXJv76M++gLIEI4X5cEwKFc1DGQKrgKgVxpG45fI9LD/1COfheFSf8RtvxHW1H+xoMBoPBYDAYGgaMRDEYDIZGCFWL4AID1P0EoxsSQI11VaBgsBPzg9+I24HaAxULwGCHRIAs4FgviaL3gVzo1auX+43juA739max8R4PiaJZa/go8aBqDO4PqUFMEA0CS5wX7oHSQ4O+JtoelA3SQl2QlESBwCDYLiQK8U4gasj+g3sNgHQioxF/IZeUxAGQGtQFAgiljF91w/U5BoKK8yA9aFPOoR1oe9QvkCre9M+aLchLogC+pw6QVNTBfz+DwWAwGAwGQ/3BSBSDwWBohFByBBUHLjwY3Bjfn376qVN8oPQAHAN5gBICQx4iYOLEiVVBTJV4gNDAmEeh4c+Mo9dA7QIJAPlA8FeICVxV/Kl3+R7iAIULZUEdo+48lBGSgUC0kA5nnHGGuzdlQw2D28zIkSNd+VC/JArN/AMRw325F/eZNWuWqwPXhaihDlomzcxDGUaPHu3UJl71B24/XJM2po2U7ACQILje4CJF3TgXlyCC5HJfyBzaCPcqoCQKbapECkQL/aK/aYwa7qfKF4PBYDAYDAZDw4CRKAaDwdCI4FVcaIBUjHzcZjTLjgYq1YCyGPoQG/odahUlAlBQcD6kBwY/KgyUD3ofDZDKh2twDCQLJAFqC86FKNHraRplPvwbgoXjOQbCgPtAFuBqoy5J/Iby5IMPPqiWJjlRQEZQH02bTFm5ripJaAdNF8xveo7WjeM4D3WKEkN6Tc7VwK9abq0rJAr9oSoWrq2ECMdDBkGGeJU16s6jwXhVOaT30yxLGljWYDAYDAaDwdAwYCSKwWAwNEKgPvn444+dW8wJJ5zgiApcclCiEPSVlLoEP8UIhzzBMFfjH4IC4x01BGQI1yLjDq4quPrguqMgZgfpe1FwaBpjzrvjjjucWoLsMwQ/Rd2h10fRAcECWaOuPJAYkAakNoY0ufjiix1Zo+mYNVuNpiZWkiNeQD6QSpn7cC2IEJQc6n6kbeANmgsgK3Dxoc1oQ82+QxlpJ1xwNFAs5BT3wA2K63BN1C1Tpkxxrk2oTSBLqAdtSVkgdJRUgsCBMOG6nPf888871QqqGdodEoZ2437UgfJQByNRDAaDwWAwGBoOjEQxGAyGRgCN64ExjiEP+UHwUgxwjG2Mbgx9gLGPuw0EAuSCkgOQFZw/Z84cR1JgnOM+gysKx3F9CBBNs8t9MOr5DvIEcoXvuQbl4X5Llixx5AT3UBWFuufw3yg4uAfEAR/uwfdkx9E0zRA1qEFwaeE7/T4eaMYfrgsZxH0hZvgOYgiXHggjlDq0EcQPyhHcoGgfiBDNFgQoB7/TNpSTa9IO6uJEffQ+tAMkC4QNpAmkFW3E/WhvSCTqRDt98cUX7hr8RjtAsHAeH83qg/sT16aMWhbIFkgqL7FlMBgMBoPBYKg/GIliMBgMjQCQFpARGNivv/56lcLhiCOOcGSAGt/8m+Mw7vmd2B/ER4GYQPUAYfLggw86wxwiBRICY52/kDIEnx0xYoQjHaZOneqOh2BAnQGRgmIDAkGVGGS00ZTE6hbz2WefOdWJEihk4IFggMRR0uK5556rymSjgWVPOukkR0agyIBEiSewrKppuA/uQJATkEBLly51v5155plO2UKcFdpg9uzZMn36dPdXA89CuGgbUD+uAwny/+3dQU4CQRCGUT0QGy7AmiXH5BJcTfORlAs00glBIL6XEIMyPT3lij/V3YUo1aM5N6/GneOhq23hSGNsNptzjav1zLmOlBm7IOR4PH4tlWpeXbfdbs+dJr0KtnqG7tczNE5hVPXd7/dCFACAJyFEAXgBhQqFAS2NmU6Rwoc6UepmaInJLJ9Jn6kLYk5+6Ut5G8r2xb9XnQ2zeWrvO/K4Tok+3zgFGS0TKqzpPoUIXTNjNo/Che5TIFDHR10ovQpgGrPrCmo6kacAoWt2u905gKgjY/ZCmZOFCh66R3NdPZmnMQohGr86NKfm3BwLbWZflP5erQ6Hw9d959jlqUkBUDXueapN85rumwKWPt8zNH6/q6Ok99Wr5Twz5/nZfKprNSukmeU8M1Z1mtOBpr79D6pPAVRBzjwHAADP4f3jcoE4AAAAAN+sLToHAAAA+Ocs5wHg4aYpsiU0czzyNXM88CwNAgCAexOiAPA02pfkdDr9eBzxpfYRaQ+TOR4YAADuTYgCwNOYjWrnxJ7ftFnsnOQDAAB/wcayADzcrXucr57mAwAAt9CJAsDDCUEAAHgFeqABAAAAFghRAAAAABYIUQAAAAAWCFEAAAAAFghRAAAAABYIUQAAAAAWCFEAAAAAFghRAAAAABYIUQAAAAAWCFEAAAAAFghRAAAAABYIUQAAAAAWCFEAAAAA3q77BKnnm2TA2u1bAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "📈 Final Extracted JSON Output:\n", + "{\n", + " \"title\": \"title\",\n", + " \"x_axis_label\": \"xaxis label\",\n", + " \"y_axis_label\": \"xaxis label\",\n", + " \"total_points\": 104,\n", + " \"data\": [\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": -0.58,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": -0.29,\n", + " \"y\": 94.0\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": -0.29,\n", + " \"y\": 90.53\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 4.96,\n", + " \"y\": 93.86\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 4.96,\n", + " \"y\": 90.18\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 4.96,\n", + " \"y\": 90.64\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 4.96,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 10.22,\n", + " \"y\": 93.72\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 10.22,\n", + " \"y\": 90.61\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 10.22,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 10.22,\n", + " \"y\": 90.17\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 10.22,\n", + " \"y\": 90.32\n", + " },\n", + " {\n", + " \"class\": \"Medium Periwinkle\",\n", + " \"x\": 10.22,\n", + " \"y\": 90.39\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 15.47,\n", + " \"y\": 93.58\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 15.47,\n", + " \"y\": 90.19\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 15.47,\n", + " \"y\": 90.58\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 15.47,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 15.47,\n", + " \"y\": 90.47\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 20.73,\n", + " \"y\": 90.79\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 20.73,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 20.73,\n", + " \"y\": 93.44\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 20.73,\n", + " \"y\": 90.24\n", + " },\n", + " {\n", + " \"class\": \"Medium Periwinkle\",\n", + " \"x\": 20.73,\n", + " \"y\": 90.06\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 25.99,\n", + " \"y\": 90.99\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 25.99,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 26.28,\n", + " \"y\": 93.31\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 26.28,\n", + " \"y\": 90.4\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 26.28,\n", + " \"y\": 90.25\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 26.28,\n", + " \"y\": 90.12\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 31.53,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 31.53,\n", + " \"y\": 93.17\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 31.53,\n", + " \"y\": 91.19\n", + " },\n", + " {\n", + " \"class\": \"Medium Periwinkle\",\n", + " \"x\": 31.53,\n", + " \"y\": 90.18\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 31.53,\n", + " \"y\": 90.5\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 31.53,\n", + " \"y\": 90.4\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 36.5,\n", + " \"y\": 90.29\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 36.79,\n", + " \"y\": 91.4\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 36.79,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 36.79,\n", + " \"y\": 93.03\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 36.79,\n", + " \"y\": 90.46\n", + " },\n", + " {\n", + " \"class\": \"Medium Periwinkle\",\n", + " \"x\": 36.79,\n", + " \"y\": 90.19\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 36.79,\n", + " \"y\": 90.35\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 42.04,\n", + " \"y\": 91.6\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 42.04,\n", + " \"y\": 92.89\n", + " },\n", + " {\n", + " \"class\": \"Medium Periwinkle\",\n", + " \"x\": 42.04,\n", + " \"y\": 90.17\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 42.04,\n", + " \"y\": 90.46\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 42.04,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 42.04,\n", + " \"y\": 90.6\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 42.04,\n", + " \"y\": 90.07\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 47.3,\n", + " \"y\": 90.79\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 47.3,\n", + " \"y\": 91.81\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 47.3,\n", + " \"y\": 90.39\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 47.3,\n", + " \"y\": 92.75\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 47.3,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Medium Periwinkle\",\n", + " \"x\": 47.3,\n", + " \"y\": 90.1\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 52.55,\n", + " \"y\": 90.72\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 52.55,\n", + " \"y\": 90.96\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 52.55,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 52.55,\n", + " \"y\": 92.01\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 52.55,\n", + " \"y\": 92.61\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 57.52,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 57.81,\n", + " \"y\": 92.46\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 57.81,\n", + " \"y\": 92.21\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 57.81,\n", + " \"y\": 91.07\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 57.81,\n", + " \"y\": 90.65\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 63.07,\n", + " \"y\": 90.82\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 63.07,\n", + " \"y\": 92.32\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 63.07,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 63.07,\n", + " \"y\": 92.42\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 68.03,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 68.32,\n", + " \"y\": 92.18\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 68.32,\n", + " \"y\": 91.11\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 68.32,\n", + " \"y\": 92.61\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 68.32,\n", + " \"y\": 90.88\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 73.28,\n", + " \"y\": 92.82\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 73.58,\n", + " \"y\": 92.04\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 73.58,\n", + " \"y\": 91.32\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 73.58,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 73.58,\n", + " \"y\": 91.0\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 78.54,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 78.83,\n", + " \"y\": 91.14\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 78.83,\n", + " \"y\": 93.03\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 78.83,\n", + " \"y\": 91.9\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 78.83,\n", + " \"y\": 90.78\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 84.09,\n", + " \"y\": 93.22\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 84.09,\n", + " \"y\": 91.76\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 84.09,\n", + " \"y\": 91.15\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 84.09,\n", + " \"y\": 90.79\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 84.09,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 89.05,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 89.34,\n", + " \"y\": 93.43\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 89.34,\n", + " \"y\": 91.62\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 89.34,\n", + " \"y\": 91.24\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 89.34,\n", + " \"y\": 91.17\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 94.6,\n", + " \"y\": 93.64\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 94.6,\n", + " \"y\": 91.19\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 94.6,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 94.6,\n", + " \"y\": 91.57\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 94.6,\n", + " \"y\": 91.49\n", + " },\n", + " {\n", + " \"class\": \"Sienna\",\n", + " \"x\": 99.85,\n", + " \"y\": 91.51\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 99.85,\n", + " \"y\": 91.35\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 99.85,\n", + " \"y\": 93.83\n", + " },\n", + " {\n", + " \"class\": \"Black\",\n", + " \"x\": 99.85,\n", + " \"y\": 89.97\n", + " },\n", + " {\n", + " \"class\": \"Salmon\",\n", + " \"x\": 99.85,\n", + " \"y\": 90.96\n", + " }\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "import cv2\n", + "import numpy as np\n", + "import easyocr\n", + "from ultralytics import YOLO\n", + "import matplotlib.pyplot as plt\n", + "import json\n", + "import re\n", + "import os\n", + "import warnings\n", + "\n", + "# Suppress warnings for clean output\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "def extract_number(text_str):\n", + " \"\"\"Safely parse numbers from OCR text.\"\"\"\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "def color_distance(c1, c2):\n", + " \"\"\"Calculate Euclidean distance between two BGR colors.\"\"\"\n", + " return np.linalg.norm(np.array(c1, dtype=np.float32) - np.array(c2, dtype=np.float32))\n", + "\n", + "def get_robust_scale(axis_nums, axis_key='y'):\n", + " \"\"\"\n", + " Robust scaling that ignores OCR typos (like reading 64.5 as 645).\n", + " Calculates slopes between all pairs and takes the median to reject outliers.\n", + " \"\"\"\n", + " if len(axis_nums) < 2:\n", + " return 1.0, 0.0\n", + "\n", + " coords = np.array([n[axis_key] for n in axis_nums])\n", + " vals = np.array([n['val'] for n in axis_nums])\n", + "\n", + " # Try to fix obvious missing decimals (if a value is >10x the median)\n", + " median_val = np.median(vals)\n", + " if median_val > 0:\n", + " for i in range(len(vals)):\n", + " if vals[i] > median_val * 5: \n", + " vals[i] /= 10.0\n", + "\n", + " slopes = []\n", + " for i in range(len(coords)):\n", + " for j in range(i+1, len(coords)):\n", + " # Avoid division by zero if pixels are too close\n", + " if abs(coords[i] - coords[j]) > 10: \n", + " slope = (vals[i] - vals[j]) / (coords[i] - coords[j])\n", + " slopes.append(slope)\n", + " \n", + " if not slopes:\n", + " return 1.0, 0.0\n", + " \n", + " best_m = np.median(slopes)\n", + " intercepts = vals - best_m * coords\n", + " best_c = np.median(intercepts)\n", + " \n", + " return best_m, best_c\n", + "\n", + "\n", + "def test_dot_extraction(image_path, yolo_model_path):\n", + " print(f\"🚀 Loading YOLO model from: {yolo_model_path}\")\n", + " \n", + " if not os.path.exists(yolo_model_path):\n", + " print(f\"❌ ERROR: Model not found at {yolo_model_path}\")\n", + " return\n", + " \n", + " yolo_model = YOLO(yolo_model_path)\n", + " ocr_reader = easyocr.Reader(['en'], gpu=True, verbose=False)\n", + "\n", + " print(f\"📸 Analyzing image: {image_path}\")\n", + " \n", + " # 1. Run YOLO to find dots\n", + " results = yolo_model(image_path, conf=0.5, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + "\n", + " if len(boxes) == 0:\n", + " print(\"❌ No dots detected by YOLO.\")\n", + " return\n", + "\n", + " # 2. Upscaled OCR Scanning\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " \n", + " numbers = []\n", + " text_labels = []\n", + " raw_legend_candidates = []\n", + "\n", + " for (bbox, text, prob) in ocr_results:\n", + " orig_tl_x, orig_tl_y = bbox[0][0] / 2.0, bbox[0][1] / 2.0\n", + " orig_br_x, orig_br_y = bbox[2][0] / 2.0, bbox[2][1] / 2.0\n", + " \n", + " cx = (orig_tl_x + orig_br_x) / 2.0\n", + " cy = (orig_tl_y + orig_br_y) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + " raw_legend_candidates.append({\n", + " 'text': text, \n", + " 'x': cx,\n", + " 'tl_x': orig_tl_x, \n", + " 'cy': cy, \n", + " 'height': orig_br_y - orig_tl_y\n", + " })\n", + "\n", + " # 3. Robust Axis Scaling\n", + " leftmost_dot = boxes[:, 0].min()\n", + " bottommost_dot = boxes[:, 3].max()\n", + "\n", + " # Isolate numbers strictly on the left axis (X < leftmost dot)\n", + " y_axis_nums = [n for n in numbers if n['x'] < leftmost_dot]\n", + " y_m, y_c = get_robust_scale(y_axis_nums, axis_key='y')\n", + "\n", + " # Isolate numbers strictly on the bottom axis (Y > bottommost dot)\n", + " x_axis_nums = [n for n in numbers if n['y'] > bottommost_dot]\n", + " x_m, x_c = get_robust_scale(x_axis_nums, axis_key='x')\n", + "\n", + " # 4. Extract Colors from Legend\n", + " legend_colors = {}\n", + " ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'x_axis', 'y_axis']\n", + " \n", + " for item in raw_legend_candidates:\n", + " clean_text = item['text'].strip()\n", + " # Only look at text far to the right (past the middle of the image)\n", + " if clean_text.lower() in ignore_words or item['x'] < (img_cv.shape[1] * 0.7):\n", + " continue\n", + " \n", + " sample_x = int(item['tl_x'] - item['height']) \n", + " sample_y = int(item['cy'])\n", + " \n", + " if sample_x > 0 and sample_y > 0 and sample_x < img_cv.shape[1] and sample_y < img_cv.shape[0]:\n", + " bgr_color = img_cv[sample_y, sample_x]\n", + " # Ignore backgrounds (white/gray)\n", + " if int(bgr_color[0]) + int(bgr_color[1]) + int(bgr_color[2]) < 700:\n", + " legend_colors[clean_text] = bgr_color\n", + "\n", + " print(f\"🎨 Detected {len(legend_colors)} Legend Classes: {list(legend_colors.keys())}\")\n", + "\n", + " # 5. Map Dots to Real (X, Y) Coordinates & Colors\n", + " extracted_points = []\n", + " \n", + " # Image for visualization\n", + " vis_img = cv2.cvtColor(img_cv.copy(), cv2.COLOR_BGR2RGB)\n", + "\n", + " for box in boxes:\n", + " cx = int((box[0] + box[2]) / 2)\n", + " cy = int((box[1] + box[3]) / 2)\n", + " \n", + " # Apply the robust math\n", + " real_x = (x_m * cx) + x_c\n", + " real_y = (y_m * cy) + y_c\n", + " \n", + " # Sample dot color and find best class\n", + " dot_color = img_cv[cy, cx]\n", + " best_class = \"Unknown\"\n", + " best_color_rgb = (0, 0, 0)\n", + " \n", + " if legend_colors:\n", + " best_class = min(legend_colors.keys(), key=lambda k: color_distance(dot_color, legend_colors[k]))\n", + " # Convert BGR back to RGB for matplotlib drawing\n", + " b, g, r = legend_colors[best_class]\n", + " best_color_rgb = (int(r), int(g), int(b))\n", + "\n", + " # Save to list\n", + " extracted_points.append({\n", + " \"class\": best_class,\n", + " \"x\": float(round(real_x, 2)), \n", + " \"y\": float(round(real_y, 2))\n", + " })\n", + " \n", + " # Draw on visualization image\n", + " cv2.circle(vis_img, (cx, cy), radius=8, color=best_color_rgb, thickness=-1)\n", + " cv2.putText(vis_img, f\"{real_y:.1f}\", (cx + 10, cy - 10), \n", + " cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 0), 1)\n", + "\n", + " # Sort sequentially left to right\n", + " extracted_points.sort(key=lambda p: p['x'])\n", + "\n", + " # 6. Extract Axis Labels\n", + " title, x_axis_label, y_axis_label = None, None, None\n", + "\n", + " if text_labels:\n", + " top_most = min(text_labels, key=lambda l: l['y'])\n", + " if top_most['y'] < boxes[:, 1].min(): \n", + " title = top_most['text']\n", + " \n", + " remaining = [l for l in text_labels if l != top_most]\n", + " if remaining:\n", + " bottom_most = max(remaining, key=lambda l: l['y'])\n", + " x_axis_label = bottom_most['text']\n", + " left_most = min(remaining, key=lambda l: l['x'])\n", + " y_axis_label = left_most['text']\n", + "\n", + " # --- FINAL DISPLAY & OUTPUT ---\n", + " plt.figure(figsize=(14, 10))\n", + " plt.imshow(vis_img)\n", + " plt.title(\"Extracted Data Validation (Colors matched & Y-vals overlaid)\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " output = {\n", + " \"title\": title,\n", + " \"x_axis_label\": x_axis_label,\n", + " \"y_axis_label\": y_axis_label,\n", + " \"total_points\": len(extracted_points),\n", + " \"data\": extracted_points\n", + " }\n", + "\n", + " print(\"\\n📈 Final Extracted JSON Output:\")\n", + " print(json.dumps(output, indent=4))\n", + " \n", + " return output\n", + "\n", + "# ==========================================\n", + "# RUN THE TEST\n", + "# ==========================================\n", + "# 🚨 UPDATE THESE TWO PATHS 🚨\n", + "my_model_path = \"dot_detector_run/weights/best.pt\"\n", + "my_image_path = \"./../FigureQA_Dataset/train1/png/85007.png\"\n", + "\n", + "results = test_dot_extraction(my_image_path, my_model_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4f30e465-cd08-441e-8815-ce9f674f6d7d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🚀 Loading YOLO model from: dot_detector_run/weights/best.pt\n", + "📸 Analyzing image: ./../FigureQA_Dataset/train1/png/85004.png\n", + "🎨 Detected 0 Legend Classes: []\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "📈 Final Extracted JSON Output:\n", + "{\n", + " \"title\": \"title\",\n", + " \"x_axis_label\": \"xaxis label\",\n", + " \"y_axis_label\": \"Deep\",\n", + " \"total_points\": 75,\n", + " \"data\": [\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": -0.36,\n", + " \"y\": 95.9\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": -0.06,\n", + " \"y\": 79.72\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": -0.06,\n", + " \"y\": 78.3\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 7.17,\n", + " \"y\": 95.15\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 7.17,\n", + " \"y\": 94.78\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 7.47,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 7.47,\n", + " \"y\": 80.03\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 15.3,\n", + " \"y\": 80.15\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 15.3,\n", + " \"y\": 94.41\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 15.3,\n", + " \"y\": 95.9\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 15.3,\n", + " \"y\": 78.8\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 15.3,\n", + " \"y\": 93.73\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 22.82,\n", + " \"y\": 93.55\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 22.82,\n", + " \"y\": 95.46\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 22.82,\n", + " \"y\": 92.56\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 22.82,\n", + " \"y\": 92.25\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 23.12,\n", + " \"y\": 79.97\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 23.12,\n", + " \"y\": 78.86\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 30.65,\n", + " \"y\": 92.75\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 30.65,\n", + " \"y\": 79.54\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 30.65,\n", + " \"y\": 94.66\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 30.65,\n", + " \"y\": 80.28\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 38.48,\n", + " \"y\": 94.35\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 38.48,\n", + " \"y\": 80.65\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 38.48,\n", + " \"y\": 78.8\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 38.48,\n", + " \"y\": 91.94\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 38.48,\n", + " \"y\": 90.34\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 38.48,\n", + " \"y\": 89.85\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 46.0,\n", + " \"y\": 92.44\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 46.0,\n", + " \"y\": 91.14\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 46.0,\n", + " \"y\": 80.9\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 46.0,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 46.0,\n", + " \"y\": 88.61\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 46.0,\n", + " \"y\": 89.17\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 53.83,\n", + " \"y\": 81.51\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 53.83,\n", + " \"y\": 93.73\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 53.83,\n", + " \"y\": 87.38\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 53.83,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 53.83,\n", + " \"y\": 90.34\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 53.83,\n", + " \"y\": 88.06\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 61.35,\n", + " \"y\": 81.39\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 61.35,\n", + " \"y\": 86.88\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 61.35,\n", + " \"y\": 91.57\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 61.35,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 61.35,\n", + " \"y\": 89.66\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 61.35,\n", + " \"y\": 86.2\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 69.18,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 69.18,\n", + " \"y\": 88.8\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 69.18,\n", + " \"y\": 84.97\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 69.18,\n", + " \"y\": 91.2\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 69.18,\n", + " \"y\": 85.77\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 69.18,\n", + " \"y\": 82.13\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 77.01,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 77.01,\n", + " \"y\": 91.7\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 77.01,\n", + " \"y\": 84.66\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 77.01,\n", + " \"y\": 88.06\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 77.01,\n", + " \"y\": 83.73\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 84.53,\n", + " \"y\": 90.59\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 84.53,\n", + " \"y\": 87.19\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 84.53,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 84.53,\n", + " \"y\": 82.5\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 84.53,\n", + " \"y\": 83.92\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 84.53,\n", + " \"y\": 83.49\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 92.36,\n", + " \"y\": 86.39\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 92.36,\n", + " \"y\": 91.27\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 92.36,\n", + " \"y\": 82.38\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 92.36,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 92.36,\n", + " \"y\": 84.04\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 92.36,\n", + " \"y\": 81.33\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 99.89,\n", + " \"y\": 78.06\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 99.89,\n", + " \"y\": 80.15\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 99.89,\n", + " \"y\": 90.96\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 99.89,\n", + " \"y\": 85.59\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 99.89,\n", + " \"y\": 83.36\n", + " },\n", + " {\n", + " \"class\": \"Unknown\",\n", + " \"x\": 99.89,\n", + " \"y\": 81.27\n", + " }\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "import cv2\n", + "import numpy as np\n", + "import easyocr\n", + "from ultralytics import YOLO\n", + "import matplotlib.pyplot as plt\n", + "import json\n", + "import re\n", + "import os\n", + "import warnings\n", + "\n", + "# Suppress warnings for clean output\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "def extract_number(text_str):\n", + " \"\"\"Safely parse numbers from OCR text.\"\"\"\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "def color_distance(c1, c2):\n", + " \"\"\"Calculate Euclidean distance between two BGR colors.\"\"\"\n", + " return np.linalg.norm(np.array(c1, dtype=np.float32) - np.array(c2, dtype=np.float32))\n", + "\n", + "def get_robust_scale(axis_nums, axis_key='y'):\n", + " \"\"\"\n", + " Robust scaling that ignores OCR typos (like reading 64.5 as 645).\n", + " Calculates slopes between all pairs and takes the median to reject outliers.\n", + " \"\"\"\n", + " if len(axis_nums) < 2:\n", + " return 1.0, 0.0\n", + "\n", + " coords = np.array([n[axis_key] for n in axis_nums])\n", + " vals = np.array([n['val'] for n in axis_nums])\n", + "\n", + " # Try to fix obvious missing decimals (if a value is >10x the median)\n", + " median_val = np.median(vals)\n", + " if median_val > 0:\n", + " for i in range(len(vals)):\n", + " if vals[i] > median_val * 5: \n", + " vals[i] /= 10.0\n", + "\n", + " slopes = []\n", + " for i in range(len(coords)):\n", + " for j in range(i+1, len(coords)):\n", + " # Avoid division by zero if pixels are too close\n", + " if abs(coords[i] - coords[j]) > 10: \n", + " slope = (vals[i] - vals[j]) / (coords[i] - coords[j])\n", + " slopes.append(slope)\n", + " \n", + " if not slopes:\n", + " return 1.0, 0.0\n", + " \n", + " best_m = np.median(slopes)\n", + " intercepts = vals - best_m * coords\n", + " best_c = np.median(intercepts)\n", + " \n", + " return best_m, best_c\n", + "\n", + "\n", + "def test_dot_extraction(image_path, yolo_model_path):\n", + " print(f\"🚀 Loading YOLO model from: {yolo_model_path}\")\n", + " \n", + " if not os.path.exists(yolo_model_path):\n", + " print(f\"❌ ERROR: Model not found at {yolo_model_path}\")\n", + " return\n", + " \n", + " yolo_model = YOLO(yolo_model_path)\n", + " ocr_reader = easyocr.Reader(['en'], gpu=True, verbose=False)\n", + "\n", + " print(f\"📸 Analyzing image: {image_path}\")\n", + " \n", + " # 1. Run YOLO to find dots\n", + " results = yolo_model(image_path, conf=0.5, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + "\n", + " if len(boxes) == 0:\n", + " print(\"❌ No dots detected by YOLO.\")\n", + " return\n", + "\n", + " # 2. Upscaled OCR Scanning\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " \n", + " numbers = []\n", + " text_labels = []\n", + " raw_legend_candidates = []\n", + "\n", + " for (bbox, text, prob) in ocr_results:\n", + " orig_tl_x, orig_tl_y = bbox[0][0] / 2.0, bbox[0][1] / 2.0\n", + " orig_br_x, orig_br_y = bbox[2][0] / 2.0, bbox[2][1] / 2.0\n", + " \n", + " cx = (orig_tl_x + orig_br_x) / 2.0\n", + " cy = (orig_tl_y + orig_br_y) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + " raw_legend_candidates.append({\n", + " 'text': text, \n", + " 'x': cx,\n", + " 'tl_x': orig_tl_x, \n", + " 'cy': cy, \n", + " 'height': orig_br_y - orig_tl_y\n", + " })\n", + "\n", + " # 3. Robust Axis Scaling\n", + " leftmost_dot = boxes[:, 0].min()\n", + " bottommost_dot = boxes[:, 3].max()\n", + "\n", + " # Isolate numbers strictly on the left axis (X < leftmost dot)\n", + " y_axis_nums = [n for n in numbers if n['x'] < leftmost_dot]\n", + " y_m, y_c = get_robust_scale(y_axis_nums, axis_key='y')\n", + "\n", + " # Isolate numbers strictly on the bottom axis (Y > bottommost dot)\n", + " x_axis_nums = [n for n in numbers if n['y'] > bottommost_dot]\n", + " x_m, x_c = get_robust_scale(x_axis_nums, axis_key='x')\n", + "\n", + " # 4. Extract Colors from Legend\n", + " legend_colors = {}\n", + " ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'x_axis', 'y_axis']\n", + " \n", + " for item in raw_legend_candidates:\n", + " clean_text = item['text'].strip()\n", + " # Only look at text far to the right (past the middle of the image)\n", + " if clean_text.lower() in ignore_words or item['x'] < (img_cv.shape[1] * 0.7):\n", + " continue\n", + " \n", + " sample_x = int(item['tl_x'] - item['height']) \n", + " sample_y = int(item['cy'])\n", + " \n", + " if sample_x > 0 and sample_y > 0 and sample_x < img_cv.shape[1] and sample_y < img_cv.shape[0]:\n", + " bgr_color = img_cv[sample_y, sample_x]\n", + " # Ignore backgrounds (white/gray)\n", + " if int(bgr_color[0]) + int(bgr_color[1]) + int(bgr_color[2]) < 700:\n", + " legend_colors[clean_text] = bgr_color\n", + "\n", + " print(f\"🎨 Detected {len(legend_colors)} Legend Classes: {list(legend_colors.keys())}\")\n", + "\n", + " # 5. Map Dots to Real (X, Y) Coordinates & Colors\n", + " extracted_points = []\n", + " \n", + " # Image for visualization\n", + " vis_img = cv2.cvtColor(img_cv.copy(), cv2.COLOR_BGR2RGB)\n", + "\n", + " for box in boxes:\n", + " cx = int((box[0] + box[2]) / 2)\n", + " cy = int((box[1] + box[3]) / 2)\n", + " \n", + " # Apply the robust math\n", + " real_x = (x_m * cx) + x_c\n", + " real_y = (y_m * cy) + y_c\n", + " \n", + " # Sample dot color and find best class\n", + " dot_color = img_cv[cy, cx]\n", + " best_class = \"Unknown\"\n", + " best_color_rgb = (0, 0, 0)\n", + " \n", + " if legend_colors:\n", + " best_class = min(legend_colors.keys(), key=lambda k: color_distance(dot_color, legend_colors[k]))\n", + " # Convert BGR back to RGB for matplotlib drawing\n", + " b, g, r = legend_colors[best_class]\n", + " best_color_rgb = (int(r), int(g), int(b))\n", + "\n", + " # Save to list\n", + " extracted_points.append({\n", + " \"class\": best_class,\n", + " \"x\": float(round(real_x, 2)), \n", + " \"y\": float(round(real_y, 2))\n", + " })\n", + " \n", + " # Draw on visualization image\n", + " cv2.circle(vis_img, (cx, cy), radius=8, color=best_color_rgb, thickness=-1)\n", + " cv2.putText(vis_img, f\"{real_y:.1f}\", (cx + 10, cy - 10), \n", + " cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 0), 1)\n", + "\n", + " # Sort sequentially left to right\n", + " extracted_points.sort(key=lambda p: p['x'])\n", + "\n", + " # 6. Extract Axis Labels\n", + " title, x_axis_label, y_axis_label = None, None, None\n", + "\n", + " if text_labels:\n", + " top_most = min(text_labels, key=lambda l: l['y'])\n", + " if top_most['y'] < boxes[:, 1].min(): \n", + " title = top_most['text']\n", + " \n", + " remaining = [l for l in text_labels if l != top_most]\n", + " if remaining:\n", + " bottom_most = max(remaining, key=lambda l: l['y'])\n", + " x_axis_label = bottom_most['text']\n", + " left_most = min(remaining, key=lambda l: l['x'])\n", + " y_axis_label = left_most['text']\n", + "\n", + " # --- FINAL DISPLAY & OUTPUT ---\n", + " plt.figure(figsize=(14, 10))\n", + " plt.imshow(vis_img)\n", + " plt.title(\"Extracted Data Validation (Colors matched & Y-vals overlaid)\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " output = {\n", + " \"title\": title,\n", + " \"x_axis_label\": x_axis_label,\n", + " \"y_axis_label\": y_axis_label,\n", + " \"total_points\": len(extracted_points),\n", + " \"data\": extracted_points\n", + " }\n", + "\n", + " print(\"\\n📈 Final Extracted JSON Output:\")\n", + " print(json.dumps(output, indent=4))\n", + " \n", + " return output\n", + "\n", + "# ==========================================\n", + "# RUN THE TEST\n", + "# ==========================================\n", + "# 🚨 UPDATE THESE TWO PATHS 🚨\n", + "my_model_path = \"dot_detector_run/weights/best.pt\"\n", + "my_image_path = \"./../FigureQA_Dataset/train1/png/85004.png\"\n", + "\n", + "results = test_dot_extraction(my_image_path, my_model_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "799fa55a-dfcc-490e-8fec-ce8b6e44a090", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🚀 Loading YOLO model from: dot_detector_run/weights/best.pt\n", + "📸 Analyzing image: ./../FigureQA_Dataset/train1/png/85004.png\n", + "🎨 Detected 5 Legend Classes: ['Lawn Green', 'Deep', 'Medium Mint', 'Indigo', 'Hot Pink']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "📈 Final Extracted JSON Output:\n", + "{\n", + " \"title\": \"title\",\n", + " \"x_axis_label\": \"xaxis label\",\n", + " \"y_axis_label\": \"Web Gray\",\n", + " \"total_points\": 75,\n", + " \"data\": [\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": -0.36,\n", + " \"y\": 95.9\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": -0.06,\n", + " \"y\": 79.72\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": -0.06,\n", + " \"y\": 78.3\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 7.17,\n", + " \"y\": 95.15\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 7.17,\n", + " \"y\": 94.78\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 7.47,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 7.47,\n", + " \"y\": 80.03\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 15.3,\n", + " \"y\": 80.15\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 15.3,\n", + " \"y\": 94.41\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 15.3,\n", + " \"y\": 95.9\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 15.3,\n", + " \"y\": 78.8\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 15.3,\n", + " \"y\": 93.73\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 22.82,\n", + " \"y\": 93.55\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 22.82,\n", + " \"y\": 95.46\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 22.82,\n", + " \"y\": 92.56\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 22.82,\n", + " \"y\": 92.25\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 23.12,\n", + " \"y\": 79.97\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 23.12,\n", + " \"y\": 78.86\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 30.65,\n", + " \"y\": 92.75\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 30.65,\n", + " \"y\": 79.54\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 30.65,\n", + " \"y\": 94.66\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 30.65,\n", + " \"y\": 80.28\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 38.48,\n", + " \"y\": 94.35\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 38.48,\n", + " \"y\": 80.65\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 38.48,\n", + " \"y\": 78.8\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 38.48,\n", + " \"y\": 91.94\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 38.48,\n", + " \"y\": 90.34\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 38.48,\n", + " \"y\": 89.85\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 46.0,\n", + " \"y\": 92.44\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 46.0,\n", + " \"y\": 91.14\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 46.0,\n", + " \"y\": 80.9\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 46.0,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 46.0,\n", + " \"y\": 88.61\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 46.0,\n", + " \"y\": 89.17\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 53.83,\n", + " \"y\": 81.51\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 53.83,\n", + " \"y\": 93.73\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 53.83,\n", + " \"y\": 87.38\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 53.83,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 53.83,\n", + " \"y\": 90.34\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 53.83,\n", + " \"y\": 88.06\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 61.35,\n", + " \"y\": 81.39\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 61.35,\n", + " \"y\": 86.88\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 61.35,\n", + " \"y\": 91.57\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 61.35,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 61.35,\n", + " \"y\": 89.66\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 61.35,\n", + " \"y\": 86.2\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 69.18,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 69.18,\n", + " \"y\": 88.8\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 69.18,\n", + " \"y\": 84.97\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 69.18,\n", + " \"y\": 91.2\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 69.18,\n", + " \"y\": 85.77\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 69.18,\n", + " \"y\": 82.13\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 77.01,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 77.01,\n", + " \"y\": 91.7\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 77.01,\n", + " \"y\": 84.66\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 77.01,\n", + " \"y\": 88.06\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 77.01,\n", + " \"y\": 83.73\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 84.53,\n", + " \"y\": 90.59\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 84.53,\n", + " \"y\": 87.19\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 84.53,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 84.53,\n", + " \"y\": 82.5\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 84.53,\n", + " \"y\": 83.92\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 84.53,\n", + " \"y\": 83.49\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 92.36,\n", + " \"y\": 86.39\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 92.36,\n", + " \"y\": 91.27\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 92.36,\n", + " \"y\": 82.38\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 92.36,\n", + " \"y\": 77.99\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 92.36,\n", + " \"y\": 84.04\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 92.36,\n", + " \"y\": 81.33\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 99.89,\n", + " \"y\": 78.06\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 99.89,\n", + " \"y\": 80.15\n", + " },\n", + " {\n", + " \"class\": \"Medium Mint\",\n", + " \"x\": 99.89,\n", + " \"y\": 90.96\n", + " },\n", + " {\n", + " \"class\": \"Indigo\",\n", + " \"x\": 99.89,\n", + " \"y\": 85.59\n", + " },\n", + " {\n", + " \"class\": \"Lawn Green\",\n", + " \"x\": 99.89,\n", + " \"y\": 83.36\n", + " },\n", + " {\n", + " \"class\": \"Hot Pink\",\n", + " \"x\": 99.89,\n", + " \"y\": 81.27\n", + " }\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "import cv2\n", + "import numpy as np\n", + "import easyocr\n", + "from ultralytics import YOLO\n", + "import matplotlib.pyplot as plt\n", + "import json\n", + "import re\n", + "import os\n", + "import warnings\n", + "\n", + "# Suppress warnings for clean output\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "def extract_number(text_str):\n", + " \"\"\"Safely parse numbers from OCR text.\"\"\"\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "def color_distance(c1, c2):\n", + " \"\"\"Calculate Euclidean distance between two BGR colors.\"\"\"\n", + " return np.linalg.norm(np.array(c1, dtype=np.float32) - np.array(c2, dtype=np.float32))\n", + "\n", + "def get_robust_scale(axis_nums, axis_key='y'):\n", + " \"\"\"\n", + " Robust scaling that ignores OCR typos (like reading 64.5 as 645).\n", + " Calculates slopes between all pairs and takes the median to reject outliers.\n", + " \"\"\"\n", + " if len(axis_nums) < 2:\n", + " return 1.0, 0.0\n", + "\n", + " coords = np.array([n[axis_key] for n in axis_nums])\n", + " vals = np.array([n['val'] for n in axis_nums])\n", + "\n", + " # Try to fix obvious missing decimals (if a value is >10x the median)\n", + " median_val = np.median(vals)\n", + " if median_val > 0:\n", + " for i in range(len(vals)):\n", + " if vals[i] > median_val * 5: \n", + " vals[i] /= 10.0\n", + "\n", + " slopes = []\n", + " for i in range(len(coords)):\n", + " for j in range(i+1, len(coords)):\n", + " # Avoid division by zero if pixels are too close\n", + " if abs(coords[i] - coords[j]) > 10: \n", + " slope = (vals[i] - vals[j]) / (coords[i] - coords[j])\n", + " slopes.append(slope)\n", + " \n", + " if not slopes:\n", + " return 1.0, 0.0\n", + " \n", + " best_m = np.median(slopes)\n", + " intercepts = vals - best_m * coords\n", + " best_c = np.median(intercepts)\n", + " \n", + " return best_m, best_c\n", + "\n", + "\n", + "def test_dot_extraction(image_path, yolo_model_path):\n", + " print(f\"🚀 Loading YOLO model from: {yolo_model_path}\")\n", + " \n", + " if not os.path.exists(yolo_model_path):\n", + " print(f\"❌ ERROR: Model not found at {yolo_model_path}\")\n", + " return\n", + " \n", + " yolo_model = YOLO(yolo_model_path)\n", + " ocr_reader = easyocr.Reader(['en'], gpu=True, verbose=False)\n", + "\n", + " print(f\"📸 Analyzing image: {image_path}\")\n", + " \n", + " # 1. Run YOLO to find dots\n", + " results = yolo_model(image_path, conf=0.5, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + "\n", + " if len(boxes) == 0:\n", + " print(\"❌ No dots detected by YOLO.\")\n", + " return\n", + "\n", + " # 2. Upscaled OCR Scanning\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " \n", + " numbers = []\n", + " text_labels = []\n", + " raw_legend_candidates = []\n", + "\n", + " for (bbox, text, prob) in ocr_results:\n", + " # Scale bounding box back down to original image coordinates\n", + " orig_tl_x, orig_tl_y = bbox[0][0] / 2.0, bbox[0][1] / 2.0\n", + " orig_br_x, orig_br_y = bbox[2][0] / 2.0, bbox[2][1] / 2.0\n", + " \n", + " cx = (orig_tl_x + orig_br_x) / 2.0\n", + " cy = (orig_tl_y + orig_br_y) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + " # Save raw coordinates for color sampling later\n", + " raw_legend_candidates.append({\n", + " 'text': text, \n", + " 'x': cx,\n", + " 'tl_x': orig_tl_x, \n", + " 'cy': cy, \n", + " 'height': orig_br_y - orig_tl_y\n", + " })\n", + "\n", + " # 3. Robust Axis Scaling\n", + " leftmost_dot = boxes[:, 0].min()\n", + " bottommost_dot = boxes[:, 3].max()\n", + "\n", + " # Y-AXIS\n", + " y_axis_nums = [n for n in numbers if n['x'] < leftmost_dot]\n", + " y_m, y_c = get_robust_scale(y_axis_nums, axis_key='y')\n", + "\n", + " # X-AXIS\n", + " x_axis_nums = [n for n in numbers if n['y'] > bottommost_dot]\n", + " x_m, x_c = get_robust_scale(x_axis_nums, axis_key='x')\n", + "\n", + " # 4. DYNAMIC LEGEND DETECTION\n", + " legend_colors = {}\n", + " legend_texts = set() # We will use this to block these words from becoming axis labels\n", + " ignore_words = ['xaxis_label', 'yaxis_label', 'xaxis label', 'yaxis label', 'title', 'x_axis', 'y_axis']\n", + " \n", + " for item in raw_legend_candidates:\n", + " clean_text = item['text'].strip()\n", + " if clean_text.lower() in ignore_words:\n", + " continue\n", + " \n", + " # Look 80% of the text height to the left to find the color dot\n", + " sample_x = int(item['tl_x'] - item['height'] * 0.8) \n", + " sample_y = int(item['cy'])\n", + " \n", + " if sample_x > 0 and sample_y > 0 and sample_x < img_cv.shape[1] and sample_y < img_cv.shape[0]:\n", + " bgr_color = img_cv[sample_y, sample_x]\n", + " b, g, r = int(bgr_color[0]), int(bgr_color[1]), int(bgr_color[2])\n", + " \n", + " # Color Heuristics:\n", + " is_not_white = (b + g + r) < 700 # Backgrounds are usually near 765\n", + " is_not_black = (b + g + r) > 50 # Gridlines/Axis lines are usually near 0\n", + " is_colorful = max(b, g, r) - min(b, g, r) > 20 # Requires some saturation, avoiding pure grays\n", + " \n", + " if is_not_white and is_not_black and is_colorful:\n", + " legend_colors[clean_text] = bgr_color\n", + " legend_texts.add(item['text'])\n", + "\n", + " print(f\"🎨 Detected {len(legend_colors)} Legend Classes: {list(legend_colors.keys())}\")\n", + "\n", + " # 5. Map Dots to Real (X, Y) Coordinates & Colors\n", + " extracted_points = []\n", + " \n", + " # Image for visualization\n", + " vis_img = cv2.cvtColor(img_cv.copy(), cv2.COLOR_BGR2RGB)\n", + "\n", + " for box in boxes:\n", + " cx = int((box[0] + box[2]) / 2)\n", + " cy = int((box[1] + box[3]) / 2)\n", + " \n", + " # Apply the robust math\n", + " real_x = (x_m * cx) + x_c\n", + " real_y = (y_m * cy) + y_c\n", + " \n", + " # Sample dot color and find best class\n", + " dot_color = img_cv[cy, cx]\n", + " best_class = \"Unknown\"\n", + " best_color_rgb = (0, 0, 0)\n", + " \n", + " if legend_colors:\n", + " best_class = min(legend_colors.keys(), key=lambda k: color_distance(dot_color, legend_colors[k]))\n", + " # Convert BGR back to RGB for matplotlib drawing\n", + " b, g, r = legend_colors[best_class]\n", + " best_color_rgb = (int(r), int(g), int(b))\n", + "\n", + " # Save to list\n", + " extracted_points.append({\n", + " \"class\": best_class,\n", + " \"x\": float(round(real_x, 2)), \n", + " \"y\": float(round(real_y, 2))\n", + " })\n", + " \n", + " # Draw on visualization image\n", + " cv2.circle(vis_img, (cx, cy), radius=8, color=best_color_rgb, thickness=-1)\n", + " cv2.putText(vis_img, f\"{real_y:.1f}\", (cx + 10, cy - 10), \n", + " cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 0), 1)\n", + "\n", + " # Sort sequentially left to right\n", + " extracted_points.sort(key=lambda p: p['x'])\n", + "\n", + " # 6. Extract Axis Labels (FILTERED)\n", + " title, x_axis_label, y_axis_label = None, None, None\n", + "\n", + " if text_labels:\n", + " top_most = min(text_labels, key=lambda l: l['y'])\n", + " if top_most['y'] < boxes[:, 1].min(): \n", + " title = top_most['text']\n", + " \n", + " # Filter out the title AND any text we proved was a legend item!\n", + " remaining = [l for l in text_labels if l != top_most and l['text'] not in legend_texts]\n", + " \n", + " if remaining:\n", + " bottom_most = max(remaining, key=lambda l: l['y'])\n", + " x_axis_label = bottom_most['text']\n", + " left_most = min(remaining, key=lambda l: l['x'])\n", + " y_axis_label = left_most['text']\n", + "\n", + " # --- FINAL DISPLAY & OUTPUT ---\n", + " plt.figure(figsize=(14, 10))\n", + " plt.imshow(vis_img)\n", + " plt.title(\"Extracted Data Validation (Colors matched & Y-vals overlaid)\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " output = {\n", + " \"title\": title,\n", + " \"x_axis_label\": x_axis_label,\n", + " \"y_axis_label\": y_axis_label,\n", + " \"total_points\": len(extracted_points),\n", + " \"data\": extracted_points\n", + " }\n", + "\n", + " print(\"\\n📈 Final Extracted JSON Output:\")\n", + " print(json.dumps(output, indent=4))\n", + " \n", + " return output\n", + "\n", + "# ==========================================\n", + "# RUN THE TEST\n", + "# ==========================================\n", + "# 🚨 UPDATE THESE TWO PATHS TO MATCH YOUR LOCAL FILES 🚨\n", + "my_model_path = \"dot_detector_run/weights/best.pt\"\n", + "my_image_path = \"./../FigureQA_Dataset/train1/png/85004.png\" # Test with your new image here!\n", + "\n", + "results = test_dot_extraction(my_image_path, my_model_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb83a86a-f5e0-4352-95c2-e8603ae012c3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/FigureQA.ipynb b/notebooks/FigureQA.ipynb new file mode 100644 index 0000000..501466d --- /dev/null +++ b/notebooks/FigureQA.ipynb @@ -0,0 +1,1840 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e5e3afef-c89d-4ea5-8ff6-504f0670b60e", + "metadata": {}, + "source": [ + "## For sample train data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f7bcc049-15f6-4528-9e6b-bdd0df485c72", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.image as mpimg\n", + "\n", + "dataset_path = '../FigureQA_Dataset/sample_train1'\n", + "annotations_file = os.path.join(dataset_path, 'annotations.json')\n", + "qa_file = os.path.join(dataset_path, 'qa_pairs.json')\n", + "images_dir = os.path.join(dataset_path, 'png')\n", + "\n", + "with open(annotations_file, 'r') as f:\n", + " annotations = json.load(f)\n", + "\n", + "with open(qa_file, 'r') as f:\n", + " qa_pairs_data = json.load(f)['qa_pairs']\n", + "\n", + "def get_annotations(idx):\n", + " return annotations[idx]\n", + "\n", + "def get_qa_pairs(idx):\n", + " return [qa for qa in qa_pairs_data if qa['image_index'] == idx]\n", + "\n", + "\n", + "def get_original_json_data(idx):\n", + " original_annotation = annotations[idx]\n", + " \n", + " original_qa_list = [qa for qa in qa_pairs_data if qa['image_index'] == idx]\n", + " \n", + " full_original_data = {\n", + " \"original_annotation\": original_annotation,\n", + " \"original_qa_pairs\": original_qa_list\n", + " }\n", + " \n", + " return full_original_data\n", + "\n", + "\n", + "def explore_chart(idx):\n", + " \"\"\"Visualizes the chart, its annotations, and its QA pairs.\"\"\"\n", + " img_path = os.path.join(images_dir, f\"{idx}.png\")\n", + " if os.path.exists(img_path):\n", + " plt.figure(figsize=(15, 8))\n", + " img = mpimg.imread(img_path)\n", + " plt.imshow(img)\n", + " plt.title(f\"Image Index: {idx}\", fontsize=15)\n", + " plt.axis('off')\n", + " plt.show()\n", + " print(json.dumps(get_original_json_data(idx), indent=4))\n", + "\n", + "\n", + "def get_good_qa(idx):\n", + " original_qa_list = [qa for qa in qa_pairs_data if qa['image_index'] == idx]\n", + " for i in original_qa_list:\n", + " print(\"Question: \", i['question_string'])\n", + " ans = \"Yes\" if i['answer'] == 1 else \"No\"\n", + " print(\"Answer: \", ans)\n", + " print(\"-\")\n", + " \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5dede0f5-8df9-452f-be69-12ea451cc8f1", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"original_annotation\": {\n", + " \"models\": [\n", + " {\n", + " \"name\": \"bars\",\n", + " \"labels\": [\n", + " \"Gray\",\n", + " \"Olive\",\n", + " \"Blue\"\n", + " ],\n", + " \"width\": 0.5,\n", + " \"colors\": [\n", + " \"#BEBEBE\",\n", + " \"#808000\",\n", + " \"#0000FF\"\n", + " ],\n", + " \"bboxes\": [\n", + " {\n", + " \"y\": 153,\n", + " \"x\": 79,\n", + " \"w\": 60,\n", + " \"h\": 167\n", + " },\n", + " {\n", + " \"y\": 45,\n", + " \"x\": 200,\n", + " \"w\": 60,\n", + " \"h\": 275\n", + " },\n", + " {\n", + " \"y\": 238,\n", + " \"x\": 321,\n", + " \"w\": 60,\n", + " \"h\": 82\n", + " }\n", + " ],\n", + " \"y\": [\n", + " 52.28527425417128,\n", + " 86.14654783337511,\n", + " 25.665660582579676\n", + " ],\n", + " \"x\": [\n", + " \"Gray\",\n", + " \"Olive\",\n", + " \"Blue\"\n", + " ]\n", + " }\n", + " ],\n", + " \"type\": \"vbar_categorical\",\n", + " \"general_figure_info\": {\n", + " \"y_axis\": {\n", + " \"label\": {\n", + " \"text\": \"yaxis_label\",\n", + " \"bbox\": {\n", + " \"y\": 146,\n", + " \"x\": 6,\n", + " \"w\": 16,\n", + " \"h\": 71.796875\n", + " }\n", + " },\n", + " \"major_labels\": {\n", + " \"values\": [\n", + " \"0\",\n", + " \"20\",\n", + " \"40\",\n", + " \"60\",\n", + " \"80\",\n", + " \"0\",\n", + " \"20\",\n", + " \"40\",\n", + " \"60\",\n", + " \"80\"\n", + " ],\n", + " \"bboxes\": [\n", + " {\n", + " \"y\": 313,\n", + " \"x\": 31,\n", + " \"w\": 6.984375,\n", + " \"h\": 14\n", + " },\n", + " {\n", + " \"y\": 249,\n", + " \"x\": 24,\n", + " \"w\": 13.96875,\n", + " \"h\": 14\n", + " },\n", + " {\n", + " \"y\": 185,\n", + " \"x\": 24,\n", + " \"w\": 13.96875,\n", + " \"h\": 14\n", + " },\n", + " {\n", + " \"y\": 121,\n", + " \"x\": 24,\n", + " \"w\": 13.96875,\n", + " \"h\": 14\n", + " },\n", + " {\n", + " \"y\": 57,\n", + " \"x\": 24,\n", + " \"w\": 13.96875,\n", + " \"h\": 14\n", + " },\n", + " {\n", + " \"y\": 313,\n", + " \"x\": 31,\n", + " \"w\": 6.984375,\n", + " \"h\": 14\n", + " },\n", + " {\n", + " \"y\": 249,\n", + " \"x\": 24,\n", + " \"w\": 13.96875,\n", + " \"h\": 14\n", + " },\n", + " {\n", + " \"y\": 185,\n", + " \"x\": 24,\n", + " \"w\": 13.96875,\n", + " \"h\": 14\n", + " },\n", + " {\n", + " \"y\": 121,\n", + " \"x\": 24,\n", + " \"w\": 13.96875,\n", + " \"h\": 14\n", + " },\n", + " {\n", + " \"y\": 57,\n", + " \"x\": 24,\n", + " \"w\": 13.96875,\n", + " \"h\": 14\n", + " }\n", + " ]\n", + " },\n", + " \"major_ticks\": {\n", + " \"values\": [\n", + " 0,\n", + " 20,\n", + " 40,\n", + " 60,\n", + " 80,\n", + " 0,\n", + " 20,\n", + " 40,\n", + " 60,\n", + " 80\n", + " ],\n", + " \"bboxes\": [\n", + " {\n", + " \"y\": 316,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 252,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 188,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 124,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 60,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 316,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 252,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 188,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 124,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 60,\n", + " \"x\": 43,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " }\n", + " ]\n", + " },\n", + " \"rule\": {\n", + " \"bbox\": {\n", + " \"y\": 31,\n", + " \"x\": 47,\n", + " \"w\": 4,\n", + " \"h\": 303\n", + " }\n", + " },\n", + " \"minor_ticks\": {\n", + " \"values\": [\n", + " -4,\n", + " 0,\n", + " 4,\n", + " 8,\n", + " 12,\n", + " 16,\n", + " 20,\n", + " 24,\n", + " 28,\n", + " 32,\n", + " 36,\n", + " 40,\n", + " 44,\n", + " 48,\n", + " 52,\n", + " 56,\n", + " 60,\n", + " 64,\n", + " 68,\n", + " 72,\n", + " 76,\n", + " 80,\n", + " 84,\n", + " 88,\n", + " -4,\n", + " 0,\n", + " 4,\n", + " 8,\n", + " 12,\n", + " 16,\n", + " 20,\n", + " 24,\n", + " 28,\n", + " 32,\n", + " 36,\n", + " 40,\n", + " 44,\n", + " 48,\n", + " 52,\n", + " 56,\n", + " 60,\n", + " 64,\n", + " 68,\n", + " 72,\n", + " 76,\n", + " 80,\n", + " 84,\n", + " 88\n", + " ],\n", + " \"bboxes\": [\n", + " {\n", + " \"y\": 331,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 318,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 305,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 292,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 280,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 267,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 254,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 241,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 228,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 216,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 203,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 190,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 177,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 165,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 152,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 139,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 126,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 113,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 101,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 88,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 75,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 62,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 50,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 37,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 331,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 318,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 305,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 292,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 280,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 267,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 254,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 241,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 228,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 216,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 203,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 190,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 177,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 165,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 152,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 139,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 126,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 113,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 101,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 88,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 75,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 62,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 50,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " },\n", + " {\n", + " \"y\": 37,\n", + " \"x\": 45,\n", + " \"w\": 4,\n", + " \"h\": 4\n", + " }\n", + " ]\n", + " }\n", + " },\n", + " \"x_axis\": {\n", + " \"label\": {\n", + " \"text\": \"xaxis_label\",\n", + " \"bbox\": {\n", + " \"y\": 381.27,\n", + " \"x\": 194,\n", + " \"w\": 71.78125,\n", + " \"h\": 16\n", + " }\n", + " },\n", + " \"major_labels\": {\n", + " \"values\": [\n", + " \"Gray\",\n", + " \"Olive\",\n", + " \"Blue\",\n", + " \"Gray\",\n", + " \"Olive\",\n", + " \"Blue\"\n", + " ],\n", + " \"bboxes\": [\n", + " {\n", + " \"y\": 345,\n", + " \"x\": 102,\n", + " \"w\": 14,\n", + " \"h\": 26.78125\n", + " },\n", + " {\n", + " \"y\": 345,\n", + " \"x\": 223,\n", + " \"w\": 14,\n", + " \"h\": 28.75\n", + " },\n", + " {\n", + " \"y\": 345,\n", + " \"x\": 344,\n", + " \"w\": 14,\n", + " \"h\": 25.171875\n", + " },\n", + " {\n", + " \"y\": 345,\n", + " \"x\": 102,\n", + " \"w\": 14,\n", + " \"h\": 26.78125\n", + " },\n", + " {\n", + " \"y\": 345,\n", + " \"x\": 223,\n", + " \"w\": 14,\n", + " \"h\": 28.75\n", + " },\n", + " {\n", + " \"y\": 345,\n", + " \"x\": 344,\n", + " \"w\": 14,\n", + " \"h\": 25.171875\n", + " }\n", + " ]\n", + " },\n", + " \"major_ticks\": {\n", + " \"values\": [\n", + " \"Gray\",\n", + " \"Olive\",\n", + " \"Blue\",\n", + " \"Gray\",\n", + " \"Olive\",\n", + " \"Blue\"\n", + " ],\n", + " \"bboxes\": [\n", + " {\n", + " \"y\": 332,\n", + " \"x\": 105,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 332,\n", + " \"x\": 226,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 332,\n", + " \"x\": 347,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 332,\n", + " \"x\": 105,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 332,\n", + " \"x\": 226,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " },\n", + " {\n", + " \"y\": 332,\n", + " \"x\": 347,\n", + " \"w\": 8,\n", + " \"h\": 8\n", + " }\n", + " ]\n", + " },\n", + " \"rule\": {\n", + " \"bbox\": {\n", + " \"y\": 332,\n", + " \"h\": 4,\n", + " \"w\": 362,\n", + " \"x\": 49\n", + " }\n", + " },\n", + " \"minor_ticks\": {\n", + " \"values\": [],\n", + " \"bboxes\": []\n", + " }\n", + " },\n", + " \"figure_info\": {\n", + " \"bbox\": {\n", + " \"bbox\": {\n", + " \"y\": 0,\n", + " \"x\": 0,\n", + " \"w\": 416,\n", + " \"h\": 400\n", + " }\n", + " }\n", + " },\n", + " \"plot_info\": {\n", + " \"bbox\": {\n", + " \"y\": 31,\n", + " \"x\": 47,\n", + " \"w\": 364,\n", + " \"h\": 305\n", + " }\n", + " },\n", + " \"title\": {\n", + " \"text\": \"title\",\n", + " \"bbox\": {\n", + " \"y\": 9,\n", + " \"x\": 49.09562500000001,\n", + " \"w\": 50.234375,\n", + " \"h\": 16\n", + " }\n", + " }\n", + " },\n", + " \"image_index\": 1\n", + " },\n", + " \"original_qa_pairs\": [\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"--None--\",\n", + " \"color1_id\": 2,\n", + " \"color1_rgb\": [\n", + " 0,\n", + " 0,\n", + " 255\n", + " ],\n", + " \"question_string\": \"Is Blue the minimum?\",\n", + " \"color2_id\": -1,\n", + " \"color1_name\": \"Blue\",\n", + " \"answer\": 1,\n", + " \"color2_rgb\": [\n", + " -1,\n", + " -1,\n", + " -1\n", + " ],\n", + " \"question_id\": 0\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"--None--\",\n", + " \"color1_id\": 69,\n", + " \"color1_rgb\": [\n", + " 128,\n", + " 128,\n", + " 0\n", + " ],\n", + " \"question_string\": \"Is Olive the maximum?\",\n", + " \"color2_id\": -1,\n", + " \"color1_name\": \"Olive\",\n", + " \"answer\": 1,\n", + " \"color2_rgb\": [\n", + " -1,\n", + " -1,\n", + " -1\n", + " ],\n", + " \"question_id\": 1\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"--None--\",\n", + " \"color1_id\": 69,\n", + " \"color1_rgb\": [\n", + " 128,\n", + " 128,\n", + " 0\n", + " ],\n", + " \"question_string\": \"Is Olive the minimum?\",\n", + " \"color2_id\": -1,\n", + " \"color1_name\": \"Olive\",\n", + " \"answer\": 0,\n", + " \"color2_rgb\": [\n", + " -1,\n", + " -1,\n", + " -1\n", + " ],\n", + " \"question_id\": 0\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"--None--\",\n", + " \"color1_id\": 2,\n", + " \"color1_rgb\": [\n", + " 0,\n", + " 0,\n", + " 255\n", + " ],\n", + " \"question_string\": \"Is Blue the maximum?\",\n", + " \"color2_id\": -1,\n", + " \"color1_name\": \"Blue\",\n", + " \"answer\": 0,\n", + " \"color2_rgb\": [\n", + " -1,\n", + " -1,\n", + " -1\n", + " ],\n", + " \"question_id\": 1\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"Blue\",\n", + " \"color1_id\": 69,\n", + " \"color1_rgb\": [\n", + " 128,\n", + " 128,\n", + " 0\n", + " ],\n", + " \"question_string\": \"Is Olive greater than Blue?\",\n", + " \"color2_id\": 2,\n", + " \"color1_name\": \"Olive\",\n", + " \"answer\": 1,\n", + " \"color2_rgb\": [\n", + " 0,\n", + " 0,\n", + " 255\n", + " ],\n", + " \"question_id\": 3\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"Olive\",\n", + " \"color1_id\": 2,\n", + " \"color1_rgb\": [\n", + " 0,\n", + " 0,\n", + " 255\n", + " ],\n", + " \"question_string\": \"Is Blue less than Olive?\",\n", + " \"color2_id\": 69,\n", + " \"color1_name\": \"Blue\",\n", + " \"answer\": 1,\n", + " \"color2_rgb\": [\n", + " 128,\n", + " 128,\n", + " 0\n", + " ],\n", + " \"question_id\": 2\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"Olive\",\n", + " \"color1_id\": 2,\n", + " \"color1_rgb\": [\n", + " 0,\n", + " 0,\n", + " 255\n", + " ],\n", + " \"question_string\": \"Is Blue greater than Olive?\",\n", + " \"color2_id\": 69,\n", + " \"color1_name\": \"Blue\",\n", + " \"answer\": 0,\n", + " \"color2_rgb\": [\n", + " 128,\n", + " 128,\n", + " 0\n", + " ],\n", + " \"question_id\": 3\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"Blue\",\n", + " \"color1_id\": 69,\n", + " \"color1_rgb\": [\n", + " 128,\n", + " 128,\n", + " 0\n", + " ],\n", + " \"question_string\": \"Is Olive less than Blue?\",\n", + " \"color2_id\": 2,\n", + " \"color1_name\": \"Olive\",\n", + " \"answer\": 0,\n", + " \"color2_rgb\": [\n", + " 0,\n", + " 0,\n", + " 255\n", + " ],\n", + " \"question_id\": 2\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"--None--\",\n", + " \"color1_id\": 38,\n", + " \"color1_rgb\": [\n", + " 190,\n", + " 190,\n", + " 190\n", + " ],\n", + " \"question_string\": \"Is Gray the high median?\",\n", + " \"color2_id\": -1,\n", + " \"color1_name\": \"Gray\",\n", + " \"answer\": 1,\n", + " \"color2_rgb\": [\n", + " -1,\n", + " -1,\n", + " -1\n", + " ],\n", + " \"question_id\": 5\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"--None--\",\n", + " \"color1_id\": 38,\n", + " \"color1_rgb\": [\n", + " 190,\n", + " 190,\n", + " 190\n", + " ],\n", + " \"question_string\": \"Is Gray the low median?\",\n", + " \"color2_id\": -1,\n", + " \"color1_name\": \"Gray\",\n", + " \"answer\": 1,\n", + " \"color2_rgb\": [\n", + " -1,\n", + " -1,\n", + " -1\n", + " ],\n", + " \"question_id\": 4\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"--None--\",\n", + " \"color1_id\": 2,\n", + " \"color1_rgb\": [\n", + " 0,\n", + " 0,\n", + " 255\n", + " ],\n", + " \"question_string\": \"Is Blue the high median?\",\n", + " \"color2_id\": -1,\n", + " \"color1_name\": \"Blue\",\n", + " \"answer\": 0,\n", + " \"color2_rgb\": [\n", + " -1,\n", + " -1,\n", + " -1\n", + " ],\n", + " \"question_id\": 5\n", + " },\n", + " {\n", + " \"image_index\": 1,\n", + " \"color2_name\": \"--None--\",\n", + " \"color1_id\": 2,\n", + " \"color1_rgb\": [\n", + " 0,\n", + " 0,\n", + " 255\n", + " ],\n", + " \"question_string\": \"Is Blue the low median?\",\n", + " \"color2_id\": -1,\n", + " \"color1_name\": \"Blue\",\n", + " \"answer\": 0,\n", + " \"color2_rgb\": [\n", + " -1,\n", + " -1,\n", + " -1\n", + " ],\n", + " \"question_id\": 4\n", + " }\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "explore_chart(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d7171dfe-393c-4701-b927-4ceef1ef4f4e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Question: Is Blue the minimum?\n", + "Answer: Yes\n", + "-\n", + "Question: Is Olive the maximum?\n", + "Answer: Yes\n", + "-\n", + "Question: Is Olive the minimum?\n", + "Answer: No\n", + "-\n", + "Question: Is Blue the maximum?\n", + "Answer: No\n", + "-\n", + "Question: Is Olive greater than Blue?\n", + "Answer: Yes\n", + "-\n", + "Question: Is Blue less than Olive?\n", + "Answer: Yes\n", + "-\n", + "Question: Is Blue greater than Olive?\n", + "Answer: No\n", + "-\n", + "Question: Is Olive less than Blue?\n", + "Answer: No\n", + "-\n", + "Question: Is Gray the high median?\n", + "Answer: Yes\n", + "-\n", + "Question: Is Gray the low median?\n", + "Answer: Yes\n", + "-\n", + "Question: Is Blue the high median?\n", + "Answer: No\n", + "-\n", + "Question: Is Blue the low median?\n", + "Answer: No\n", + "-\n" + ] + } + ], + "source": [ + "get_good_qa(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "517b926d-4a93-4250-a67f-6c2ddcfb6d1f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating metadata for 1000 images...\n", + "✅ Success! Robust metadata saved at: /Users/aryangahlot/Desktop/Coding/AI-ML/Spectra/metadata.jsonl\n" + ] + } + ], + "source": [ + "import json\n", + "import os\n", + "\n", + "def convert_to_donut_format_robust(annotations_list, target_folder):\n", + " \"\"\"\n", + " Robust conversion that handles missing 'labels' keys and string values.\n", + " \"\"\"\n", + " output_path = os.path.join(target_folder, \"metadata.jsonl\")\n", + " print(f\"Generating metadata for {len(annotations_list)} images...\")\n", + " \n", + " with open(output_path, 'w') as f:\n", + " for ann in annotations_list:\n", + " \n", + " if not ann.get('models'):\n", + " continue\n", + " \n", + " chart_model = ann['models'][0]\n", + " \n", + " if 'labels' in chart_model:\n", + " labels = chart_model['labels']\n", + " elif 'x' in chart_model:\n", + " labels = chart_model['x']\n", + " if 'y' in chart_model:\n", + " values = chart_model['y']\n", + " else:\n", + " continue\n", + " \n", + " if labels is None:\n", + " labels = [str(i) for i in range(len(values))]\n", + " \n", + " data_points = []\n", + " for i in range(min(len(labels), len(values))):\n", + " label = labels[i]\n", + " val = values[i]\n", + " \n", + " try:\n", + " numeric_val = float(val)\n", + " except (ValueError, TypeError):\n", + " numeric_val = 0.0\n", + " \n", + " data_points.append({\n", + " \"label\": str(label), \n", + " \"value\": round(numeric_val, 2)\n", + " })\n", + "\n", + " gt_parse = {\n", + " \"chart_type\": ann.get('type', 'unknown'),\n", + " \"data\": data_points\n", + " }\n", + " \n", + " img_filename = f\"{ann['image_index']}.png\"\n", + " line = {\n", + " \"file_name\": img_filename,\n", + " \"ground_truth\": json.dumps({\"gt_parse\": gt_parse})\n", + " }\n", + " \n", + " f.write(json.dumps(line) + \"\\n\")\n", + " \n", + " print(f\"✅ Success! Robust metadata saved at: {output_path}\")\n", + "\n", + "spectra_path = \"/Users/aryangahlot/Desktop/Coding/AI-ML/Spectra\"\n", + "convert_to_donut_format_robust(annotations, spectra_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb5eabef-5e54-4e5c-9653-4cd453dac665", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aryangahlot/.pyenv/versions/tfenv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🛠️ Initializing Lazy-Load Training Pipeline...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n", + "The image processor of type `DonutImageProcessor` is now loaded as a fast processor by default, even if the model checkpoint was saved with a slow processor. This is a breaking change and may produce slightly different outputs. To continue using the slow processor, instantiate this class with `use_fast=False`. \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Dataset set to Lazy Mode (No pre-computation needed).\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights: 100%|█| 484/484 [00:00<00:00, 1666.95it/s, Materializing param=encoder.encoder.layers.3.blocks.\n", + "The tied weights mapping and config for this model specifies to tie decoder.model.decoder.embed_tokens.weight to decoder.lm_head.weight, but both are present in the checkpoints, so we will NOT tie them. You should update the config with `tie_word_embeddings=False` to silence this warning\n", + "The new embeddings will be initialized from a multivariate normal distribution that has old embeddings' mean and covariance. As described in this article: https://nlp.stanford.edu/~johnhew/vocab-expansion.html. To disable this, use `mean_resizing=False`\n", + "The new lm_head weights will be initialized from a multivariate normal distribution that has old embeddings' mean and covariance. As described in this article: https://nlp.stanford.edu/~johnhew/vocab-expansion.html. To disable this, use `mean_resizing=False`\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🚀 Starting Training on mps...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aryangahlot/.pyenv/versions/tfenv/lib/python3.10/site-packages/torch/utils/data/dataloader.py:775: UserWarning: 'pin_memory' argument is set as true but not supported on MPS now, device pinned memory won't be used.\n", + " super().__init__(loader)\n", + "`use_cache=True` is incompatible with gradient checkpointing`. Setting `use_cache=False`...\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [300/300 1:47:09, Epoch 3/3]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
539.857513
1024.885057
1521.031561
2017.067975
2513.385222
3012.675267
3511.067305
4010.441199
458.655729
508.163565
557.787546
607.129817
657.144477
707.369234
756.596828
806.140364
855.450072
905.591711
956.560335
1006.206481
1055.457001
1105.500572
1154.983832
1205.989582
1254.753556
1305.199777
1355.537530
1404.784230
1455.095908
1504.889403
1555.377960
1604.539291
1655.237383
1705.193280
1755.236347
1805.007818
1855.031464
1904.913902
1955.120100
2004.431554
2054.695727
2104.295371
2154.515560
2204.514498
2253.947401
2304.732474
2354.273049
2404.592325
2454.342963
2503.951458
2554.294534
2604.332790
2654.384932
2704.455032
2755.030238
2804.366542
2854.629052
2904.416201
2954.225395
3004.040600

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Writing model shards: 100%|███████████████████████████████████████████████████████| 1/1 [00:00<00:00, 1.48it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=300, training_loss=7.058731517791748, metrics={'train_runtime': 6451.6006, 'train_samples_per_second': 0.372, 'train_steps_per_second': 0.047, 'total_flos': 7.50458796244992e+18, 'train_loss': 7.058731517791748, 'epoch': 3.0})" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import json\n", + "import os\n", + "import torch\n", + "from datasets import Dataset, Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel, Seq2SeqTrainingArguments, Seq2SeqTrainer\n", + "\n", + "print(\"🛠️ Initializing Lazy-Load Training Pipeline...\")\n", + "\n", + "base_path = '../FigureQA_Dataset/sample_train1'\n", + "metadata_path = os.path.join(base_path, 'metadata.jsonl')\n", + "images_folder = os.path.join(base_path, 'png')\n", + "\n", + "data_entries = []\n", + "with open(metadata_path, 'r') as f:\n", + " for line in f:\n", + " entry = json.loads(line)\n", + " entry['image'] = os.path.join(images_folder, entry['file_name'])\n", + " data_entries.append(entry)\n", + "\n", + "dataset = Dataset.from_list(data_entries)\n", + "dataset = dataset.cast_column(\"image\", Image())\n", + "\n", + "processor = DonutProcessor.from_pretrained(\"naver-clova-ix/donut-base\")\n", + "processor.image_processor.size = {\"height\": 1280, \"width\": 960} \n", + "\n", + "new_special_tokens = [\"\", \"\"]\n", + "processor.tokenizer.add_special_tokens({\"additional_special_tokens\": new_special_tokens})\n", + "\n", + "\n", + "def transform_fn(batch):\n", + " \n", + " images = [x.convert(\"RGB\") for x in batch[\"image\"]]\n", + " pixel_values = processor(images, return_tensors=\"pt\").pixel_values\n", + "\n", + " targets = [f\"{gt}\" for gt in batch[\"ground_truth\"]]\n", + " labels = processor.tokenizer(\n", + " targets,\n", + " add_special_tokens=False,\n", + " max_length=512,\n", + " padding=\"max_length\",\n", + " truncation=True,\n", + " return_tensors=\"pt\"\n", + " ).input_ids\n", + "\n", + " labels[labels == processor.tokenizer.pad_token_id] = -100\n", + " \n", + " return {\"pixel_values\": pixel_values, \"labels\": labels}\n", + "\n", + "dataset.set_transform(transform_fn)\n", + "print(\"✅ Dataset set to Lazy Mode (No pre-computation needed).\")\n", + "\n", + "model = VisionEncoderDecoderModel.from_pretrained(\"naver-clova-ix/donut-base\")\n", + "model.decoder.resize_token_embeddings(len(processor.tokenizer))\n", + "model.config.decoder_start_token_id = processor.tokenizer.convert_tokens_to_ids(\"\")\n", + "model.config.pad_token_id = processor.tokenizer.pad_token_id\n", + "model.config.vocab_size = model.config.decoder.vocab_size\n", + "model.config.encoder.image_size = [1280, 960] # Match processor\n", + "\n", + "device = \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n", + "model.to(device)\n", + "\n", + "training_args = Seq2SeqTrainingArguments(\n", + " output_dir=\"./stem_sight_model_v1\",\n", + " num_train_epochs=3,\n", + " learning_rate=2e-5,\n", + " per_device_train_batch_size=1, \n", + " gradient_accumulation_steps=8,\n", + " dataloader_num_workers=0, \n", + " gradient_checkpointing=True, \n", + " logging_steps=5, \n", + " save_total_limit=1,\n", + " fp16=False, \n", + " remove_unused_columns=False, \n", + " report_to=\"none\"\n", + ")\n", + "\n", + "trainer = Seq2SeqTrainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=dataset, \n", + ")\n", + "\n", + "print(f\"🚀 Starting Training on {device}...\")\n", + "trainer.train()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2ab69fc-f687-4e0b-84c0-175a2789f54f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "📂 Loading weights from ./stem_sight_model_v1...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights: 100%|█| 484/484 [00:00<00:00, 1950.42it/s, Materializing param=encoder.encoder.layers.3.blocks.\n", + "The tied weights mapping and config for this model specifies to tie decoder.model.decoder.embed_tokens.weight to decoder.lm_head.weight, but both are present in the checkpoints, so we will NOT tie them. You should update the config with `tie_word_embeddings=False` to silence this warning\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found checkpoint: ./stem_sight_model_v1/checkpoint-300\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights: 100%|█| 483/483 [00:00<00:00, 1684.72it/s, Materializing param=encoder.encoder.layers.3.blocks.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Model loaded successfully!\n" + ] + } + ], + "source": [ + "import torch\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "\n", + "trained_model_path = \"./stem_sight_model_v1\" \n", + "\n", + "print(f\"📂 Loading weights from {trained_model_path}...\")\n", + "\n", + "\n", + "model = VisionEncoderDecoderModel.from_pretrained(\"naver-clova-ix/donut-base\")\n", + "\n", + "\n", + "checkpoint_path = f\"{trained_model_path}/checkpoint-300\" \n", + "if os.path.exists(checkpoint_path):\n", + " print(f\"Found checkpoint: {checkpoint_path}\")\n", + " model = VisionEncoderDecoderModel.from_pretrained(checkpoint_path)\n", + "else:\n", + " print(\"⚠️ specific checkpoint not found, trying root folder...\")\n", + " model = VisionEncoderDecoderModel.from_pretrained(trained_model_path)\n", + "\n", + "processor = DonutProcessor.from_pretrained(\"naver-clova-ix/donut-base\")\n", + "processor.image_processor.size = {\"height\": 1280, \"width\": 960}\n", + "model.config.encoder.image_size = [1280, 960]\n", + "\n", + "device = \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n", + "model.to(device)\n", + "model.eval()\n", + "\n", + "print(\"✅ Model loaded successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0b9518d-0d64-437f-a884-66330c77fb6b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------------------\n", + "🖼️ Scanning Image: 15.png\n", + "📄 Raw Output (Broken JSON): : \"vbar_categorical\", \"data\": [{\"label\": \"Cyan\", \"value\": 99.0}, {\"label\": \"Peru\", \"value\": 99.0}, {...\n", + "\n", + "🔊 STEM SIGHT AUDIO:\n", + "---------------------\n", + "\"This is a vbar_categorical. It contains 7 data points, including Cyan, Peru, Cornflower, and others. The highest value is 99.0 for Cyan, and the lowest is 99.0 for Cyan.\"\n", + "---------------------\n" + ] + } + ], + "source": [ + "import re\n", + "import json\n", + "import torch\n", + "from PIL import Image\n", + "\n", + "dataset.reset_format()\n", + "\n", + "\n", + "def robust_json_to_speech(raw_text):\n", + " try:\n", + " \n", + " chart_type_match = re.search(r'(vbar_categorical|line|bar|pie|dot)', raw_text)\n", + " chart_type = chart_type_match.group(0) if chart_type_match else \"chart\"\n", + " \n", + " \n", + " pattern = r'\\{\\s*\"label\":\\s*\"([^\"]+)\",\\s*\"value\":\\s*([0-9\\.]+)\\s*\\}'\n", + " matches = re.findall(pattern, raw_text)\n", + " \n", + " if not matches:\n", + " return \"I can see the graph structure, but the data points are fuzzy.\"\n", + "\n", + " labels = [m[0] for m in matches]\n", + " values = [float(m[1]) for m in matches]\n", + " \n", + " max_val = max(values)\n", + " min_val = min(values)\n", + " max_label = labels[values.index(max_val)]\n", + " min_label = labels[values.index(min_val)]\n", + " \n", + " summary = (\n", + " f\"This is a {chart_type}. \"\n", + " f\"It contains {len(values)} data points, including {', '.join(labels[:3])}, and others. \"\n", + " f\"The highest value is {max_val} for {max_label}, \"\n", + " f\"and the lowest is {min_val} for {min_label}.\"\n", + " )\n", + " return summary\n", + "\n", + " except Exception as e:\n", + " return f\"I am having trouble reading this graph. (Error: {str(e)})\"\n", + "\n", + "test_sample = dataset[15] \n", + "image = test_sample['image'].convert(\"RGB\") \n", + "\n", + "print(\"------------------------------------------------\")\n", + "print(f\"🖼️ Scanning Image: {test_sample['file_name']}\")\n", + "\n", + "device = \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n", + "model.to(device)\n", + "\n", + "pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "decoder_input_ids = processor.tokenizer(\n", + " \"\", add_special_tokens=False, return_tensors=\"pt\"\n", + ").input_ids.to(device)\n", + "\n", + "outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " num_beams=1,\n", + " bad_words_ids=[[processor.tokenizer.unk_token_id]],\n", + " return_dict_in_generate=True,\n", + ")\n", + "\n", + "sequence = processor.batch_decode(outputs.sequences)[0]\n", + "sequence = sequence.replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\")\n", + "raw_output = re.sub(r\"<.*?>\", \"\", sequence, count=1).strip()\n", + "\n", + "print(f\"📄 Raw Output (Broken JSON): {raw_output[:100]}...\")\n", + "\n", + "audio_text = robust_json_to_speech(raw_output)\n", + "\n", + "print(\"\\n🔊 STEM SIGHT AUDIO:\")\n", + "print(\"---------------------\")\n", + "print(f\"\\\"{audio_text}\\\"\")\n", + "print(\"---------------------\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dddf4829-291f-4ba3-b630-8c23d74e9d06", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tfenv", + "language": "python", + "name": "tfenv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/FigureQA_2.ipynb b/notebooks/FigureQA_2.ipynb new file mode 100644 index 0000000..beb2d3c --- /dev/null +++ b/notebooks/FigureQA_2.ipynb @@ -0,0 +1,2883 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "64caf20f-8127-40dc-a9d8-4d296180e00a", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "import shutil\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.image as mpimg\n", + "import matplotlib.patches as patches\n", + "\n", + "dataset_path = '../FigureQA_Dataset/sample_train1'\n", + "annotations_file = os.path.join(dataset_path, 'annotations.json')\n", + "qa_file = os.path.join(dataset_path, 'qa_pairs.json')\n", + "images_dir = os.path.join(dataset_path, 'png')" + ] + }, + { + "cell_type": "markdown", + "id": "ae05a94e-807e-4705-8af0-059f125f6541", + "metadata": {}, + "source": [ + "## Preproccesing" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "08244fff-2801-4227-be08-f72b52fc636d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph Type Counts:\n", + "type\n", + "vbar_categorical 200\n", + "hbar_categorical 200\n", + "line 200\n", + "pie 200\n", + "dot_line 200\n", + "Name: count, dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "def get_graph_counts(file_path):\n", + " # 1. Load the annotations\n", + " with open(file_path, 'r') as f:\n", + " data = json.load(f)\n", + " \n", + " # 2. Extract types (vbar_categorical, line, pie, etc.)\n", + " graph_types = [item['type'] for item in data]\n", + " \n", + " # 3. Create a summary table\n", + " df = pd.DataFrame(graph_types, columns=['type'])\n", + " counts = df['type'].value_counts()\n", + " \n", + " print(\"Graph Type Counts:\")\n", + " print(counts)\n", + " \n", + " # 4. Visualize the distribution\n", + " plt.figure(figsize=(10, 6))\n", + " counts.plot(kind='bar', color='salmon', edgecolor='black')\n", + " plt.title(\"Distribution of Graph Types in FigureQA\")\n", + " plt.ylabel(\"Number of Images\")\n", + " plt.xlabel(\"Graph Type\")\n", + " plt.xticks(rotation=45)\n", + " plt.grid(axis='y', linestyle='--', alpha=0.6)\n", + " plt.tight_layout()\n", + " \n", + " # Save the plot for your records\n", + " plt.savefig('dataset_distribution.png')\n", + " plt.show()\n", + "\n", + "# Run the analysis\n", + "get_graph_counts(annotations_file)" + ] + }, + { + "cell_type": "markdown", + "id": "dfb441ae-42f1-4cc7-a94f-e7ed5519d2f1", + "metadata": {}, + "source": [ + "## Classify graph" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6d496546-db44-4edd-a685-c6bf83676220", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data organized into ./classifier_sample_data\n" + ] + } + ], + "source": [ + "output_dir = './classifier_sample_data'\n", + "\n", + "def prepare_folders():\n", + " with open(annotations_file, 'r') as f:\n", + " annotations = json.load(f)\n", + "\n", + " for item in annotations:\n", + " img_idx = item['image_index']\n", + " graph_type = item['type']\n", + " \n", + " # Create folder for each type if it doesn't exist\n", + " type_dir = os.path.join(output_dir, graph_type)\n", + " os.makedirs(type_dir, exist_ok=True)\n", + " \n", + " # Copy image to its respective type folder\n", + " src = os.path.join(images_dir, f\"{img_idx}.png\")\n", + " dst = os.path.join(type_dir, f\"{img_idx}.png\")\n", + " if os.path.exists(src):\n", + " shutil.copy(src, dst)\n", + "\n", + " print(f\"Data organized into {output_dir}\")\n", + "\n", + "prepare_folders()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "36ca7e5c-cd39-435c-bb6b-1f68a928a8a2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model ready for training.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aryangahlot/.pyenv/versions/tfenv/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", + " warnings.warn(\n", + "/Users/aryangahlot/.pyenv/versions/tfenv/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n", + " warnings.warn(msg)\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import datasets, models, transforms\n", + "\n", + "# 1. Define Image Transformations\n", + "data_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# 2. Load organized data\n", + "dataset = datasets.ImageFolder(output_dir, transform=data_transforms)\n", + "train_size = int(0.8 * len(dataset))\n", + "val_size = len(dataset) - train_size\n", + "train_dataset, val_dataset = torch.utils.data.random_split(dataset, [train_size, val_size])\n", + "\n", + "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=32, shuffle=False)\n", + "\n", + "# 3. Initialize Pre-trained ResNet18\n", + "model = models.resnet18(pretrained=True)\n", + "\n", + "# Freeze early layers so we only train the new head\n", + "for param in model.parameters():\n", + " param.requires_grad = False\n", + "\n", + "# Replace the last fully connected layer\n", + "num_ftrs = model.fc.in_features\n", + "model.fc = nn.Linear(num_ftrs, 5) # 5 = your number of graph types\n", + "\n", + "print(\"Model ready for training.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "73253d78-5f08-4bb4-a46b-5db0b3a4f837", + "metadata": {}, + "outputs": [], + "source": [ + "if torch.backends.mps.is_available():\n", + " device = torch.device(\"mps\")\n", + "elif torch.cuda.is_available():\n", + " device = torch.device(\"cuda\")\n", + "else:\n", + " device = torch.device(\"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ea2b4d60-5139-4ab5-b382-bed95007fa16", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training started on mps...\n", + "Epoch 1/5 | Train Loss: 0.9718 Acc: 0.7375 | Val Acc: 0.9700 | Time: 4s\n", + "Epoch 2/5 | Train Loss: 0.2545 Acc: 0.9962 | Val Acc: 0.9850 | Time: 3s\n", + "Epoch 3/5 | Train Loss: 0.1383 Acc: 0.9987 | Val Acc: 0.9950 | Time: 5s\n", + "Epoch 4/5 | Train Loss: 0.0835 Acc: 0.9975 | Val Acc: 1.0000 | Time: 4s\n", + "Epoch 5/5 | Train Loss: 0.0618 Acc: 0.9987 | Val Acc: 0.9950 | Time: 4s\n", + "\n", + "Fixed! Model saved as 'graph_classifier.pth'\n" + ] + } + ], + "source": [ + "import torch.optim as optim\n", + "import time\n", + "\n", + "if torch.backends.mps.is_available():\n", + " device = torch.device(\"mps\")\n", + "elif torch.cuda.is_available():\n", + " device = torch.device(\"cuda\")\n", + "else:\n", + " device = torch.device(\"cpu\")\n", + "\n", + "model = model.to(device)\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(model.fc.parameters(), lr=0.001)\n", + "\n", + "num_epochs = 5 \n", + "\n", + "print(f\"Training started on {device}...\")\n", + "\n", + "for epoch in range(num_epochs):\n", + " start_time = time.time()\n", + " \n", + " model.train()\n", + " running_loss = 0.0\n", + " running_corrects = 0\n", + "\n", + " for inputs, labels in train_loader:\n", + " inputs, labels = inputs.to(device), labels.to(device)\n", + "\n", + " optimizer.zero_grad()\n", + " outputs = model(inputs)\n", + " _, preds = torch.max(outputs, 1)\n", + " loss = criterion(outputs, labels)\n", + " \n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item() * inputs.size(0)\n", + " running_corrects += torch.sum(preds == labels.data)\n", + "\n", + " epoch_loss = running_loss / train_size\n", + " epoch_acc = running_corrects.float() / train_size\n", + "\n", + " model.eval()\n", + " val_corrects = 0\n", + " with torch.no_grad():\n", + " for inputs, labels in val_loader:\n", + " inputs, labels = inputs.to(device), labels.to(device)\n", + " outputs = model(inputs)\n", + " _, preds = torch.max(outputs, 1)\n", + " val_corrects += torch.sum(preds == labels.data)\n", + " \n", + " val_acc = val_corrects.float() / val_size\n", + " \n", + " duration = time.time() - start_time\n", + " print(f'Epoch {epoch+1}/{num_epochs} | '\n", + " f'Train Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f} | '\n", + " f'Val Acc: {val_acc:.4f} | Time: {duration:.0f}s')\n", + "\n", + "torch.save(model.state_dict(), 'graph_classifier.pth')\n", + "print(\"\\nFixed! Model saved as 'graph_classifier.pth'\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3305309f-2662-4758-850d-6156da3e99b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Class Mapping: ['dot_line', 'hbar_categorical', 'line', 'pie', 'vbar_categorical']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Vision System Output ---\n", + "Detected Graph Type: dot_line\n" + ] + } + ], + "source": [ + "import torch\n", + "from PIL import Image\n", + "import random\n", + "\n", + "# 1. Setup Class Mapping\n", + "# ImageFolder assigns indices alphabetically based on folder names\n", + "class_names = dataset.classes \n", + "print(f\"Class Mapping: {class_names}\")\n", + "\n", + "def predict_and_summarize(image_path):\n", + " # --- Part A: Classification ---\n", + " model.eval()\n", + " img = Image.open(image_path).convert('RGB')\n", + " \n", + " # Preprocess the image exactly like training\n", + " img_tensor = data_transforms(img).unsqueeze(0).to(device)\n", + " \n", + " with torch.no_grad():\n", + " outputs = model(img_tensor)\n", + " _, preds = torch.max(outputs, 1)\n", + " predicted_type = class_names[preds[0]]\n", + "\n", + " print(f\"\\n--- Vision System Output ---\")\n", + " print(f\"Detected Graph Type: {predicted_type}\")\n", + "\n", + "\n", + "# 2. Test it on a random image from your original folder\n", + "random_idx = random.randint(0, 999)\n", + "test_image_path = os.path.join(images_dir, f\"{random_idx}.png\")\n", + "\n", + "# Show the image\n", + "plt.imshow(Image.open(test_image_path))\n", + "plt.axis('off')\n", + "plt.show()\n", + "\n", + "# Run the switch\n", + "predict_and_summarize(test_image_path)" + ] + }, + { + "cell_type": "markdown", + "id": "eeba7b7e-0193-44c0-bcdc-287d2e3cdda1", + "metadata": {}, + "source": [ + "## Extracting data from vbar_categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "92afc1e5-cd4e-4043-ae95-f84018bba6c6", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Model on Ground Truth Values...\n", + "Epoch 1 - MSE Loss: 0.0811\n", + "Epoch 2 - MSE Loss: 0.0332\n", + "Epoch 3 - MSE Loss: 0.0263\n", + "Epoch 4 - MSE Loss: 0.0220\n", + "Epoch 5 - MSE Loss: 0.0172\n", + "Epoch 6 - MSE Loss: 0.0100\n", + "Epoch 7 - MSE Loss: 0.0094\n", + "Epoch 8 - MSE Loss: 0.0071\n", + "Epoch 9 - MSE Loss: 0.0060\n", + "Epoch 10 - MSE Loss: 0.0064\n", + "Epoch 11 - MSE Loss: 0.0045\n", + "Epoch 12 - MSE Loss: 0.0041\n", + "Epoch 13 - MSE Loss: 0.0037\n", + "Epoch 14 - MSE Loss: 0.0043\n", + "Epoch 15 - MSE Loss: 0.0049\n", + "Model saved successfully!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aryangahlot/.pyenv/versions/tfenv/lib/python3.10/site-packages/torch/utils/data/dataloader.py:775: UserWarning: 'pin_memory' argument is set as true but not supported on MPS now, device pinned memory won't be used.\n", + " super().__init__(loader)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"title\": \"title\",\n", + " \"x_axis_labels\": [\n", + " \"Medium Aqua\",\n", + " \"Violet Red\",\n", + " \"Orchid\",\n", + " \"Dark Turquoise\",\n", + " \"Gold\",\n", + " \"Firebrick\",\n", + " \"Unknown_Label_7\"\n", + " ],\n", + " \"values\": [\n", + " 36.51,\n", + " 12.54,\n", + " 25.63,\n", + " 38.34,\n", + " 76.49,\n", + " 73.64,\n", + " 2.37\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from torchvision import models, transforms\n", + "from PIL import Image\n", + "import json\n", + "import os\n", + "import cv2\n", + "import easyocr\n", + "import numpy as np\n", + "\n", + "# --- 1. CONFIGURATION ---\n", + "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cpu\")\n", + "reader = easyocr.Reader(['en']) \n", + "vbar_dir = './classifier_sample_data/vbar_categorical'\n", + "annotations_file = '../FigureQA_Dataset/sample_train1/annotations.json'\n", + "\n", + "# --- 2. DATASET (Uses Real Annotations for Training) ---\n", + "class VBarValueDataset(Dataset):\n", + " def __init__(self, image_dir, annotations_file, indices, transform=None):\n", + " self.image_dir = image_dir\n", + " with open(annotations_file, 'r') as f:\n", + " full_data = json.load(f)\n", + " # Filter for training images\n", + " self.data = [item for item in full_data if item['image_index'] in indices]\n", + " self.transform = transform\n", + "\n", + " def __len__(self):\n", + " return len(self.data)\n", + "\n", + " def __getitem__(self, idx):\n", + " item = self.data[idx]\n", + " img_path = os.path.join(self.image_dir, f\"{item['image_index']}.png\")\n", + " image = Image.open(img_path).convert('RGB')\n", + " \n", + " # GROUND TRUTH: We take the REAL values from the JSON\n", + " values = item['models'][0]['y']\n", + " \n", + " # Prepare target vector (fixed size of 10 for the model)\n", + " target = torch.zeros(10) \n", + " val_len = min(len(values), 10)\n", + " # Normalize 0-100 scale down to 0-1 for the model\n", + " target[:val_len] = torch.tensor(values[:val_len]) / 100.0 \n", + " \n", + " if self.transform:\n", + " image = self.transform(image)\n", + " \n", + " return image, target\n", + "\n", + "# --- 3. MODEL (With Sigmoid to prevent negative numbers) ---\n", + "class VBarRegressor(nn.Module):\n", + " def __init__(self):\n", + " super(VBarRegressor, self).__init__()\n", + " self.backbone = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)\n", + " num_ftrs = self.backbone.fc.in_features\n", + " self.backbone.fc = nn.Linear(num_ftrs, 10)\n", + " self.sigmoid = nn.Sigmoid() # Forces output between 0 and 1\n", + "\n", + " def forward(self, x):\n", + " x = self.backbone(x)\n", + " return self.sigmoid(x)\n", + "\n", + "# --- 4. TRAINING SETUP ---\n", + "# Re-load indices from previous step\n", + "image_files = [f for f in os.listdir(vbar_dir) if f.endswith('.png')]\n", + "indices = [int(f.split('.')[0]) for f in image_files]\n", + "train_idx = indices[:int(len(indices)*0.8)] # Simple split\n", + "\n", + "# Setup Data\n", + "data_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "train_dataset = VBarValueDataset(vbar_dir, annotations_file, train_idx, data_transforms)\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "\n", + "# Setup Model\n", + "model = VBarRegressor().to(device)\n", + "criterion = nn.MSELoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + "\n", + "# Training Loop\n", + "print(\"Training Model on Ground Truth Values...\")\n", + "model.train()\n", + "for epoch in range(15): # Increased epochs slightly\n", + " running_loss = 0.0\n", + " for images, targets in train_loader:\n", + " images, targets = images.to(device), targets.to(device)\n", + " \n", + " optimizer.zero_grad()\n", + " outputs = model(images)\n", + " loss = criterion(outputs, targets)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " running_loss += loss.item()\n", + " print(f\"Epoch {epoch+1} - MSE Loss: {running_loss/len(train_loader):.4f}\")\n", + "\n", + "torch.save(model.state_dict(), \"vbar_regressor.pth\")\n", + "print(\"Model saved successfully!\")\n", + "\n", + "# --- 5. INFERENCE (Correct Format) ---\n", + "import cv2\n", + "import numpy as np\n", + "import json\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def get_graph_json_robust(image_path):\n", + " model.eval()\n", + " \n", + " # --- A. Get VALUES from Model ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " input_tensor = data_transforms(img_pil).unsqueeze(0).to(device)\n", + " with torch.no_grad():\n", + " # Predict 0-1 and scale to 0-100\n", + " preds = model(input_tensor).squeeze().cpu().numpy() * 100.0\n", + " \n", + " # --- B. Get TEXT from OCR (Improved) ---\n", + " cv_img = cv2.imread(image_path)\n", + " h, w, _ = cv_img.shape\n", + " \n", + " # 1. Title (Top 15%)\n", + " title_res = reader.readtext(cv_img[0:int(h*0.15), :])\n", + " title = title_res[0][1] if title_res else \"Untitled\"\n", + " \n", + " # 2. X-Axis Labels (Bottom 30% - Widened Area)\n", + " # Start crop earlier (0.70 instead of 0.85) to catch long vertical text\n", + " label_area = cv_img[int(h*0.70):h, :] \n", + " \n", + " # Pre-processing for better OCR\n", + " gray = cv2.cvtColor(label_area, cv2.COLOR_BGR2GRAY)\n", + " _, thresh = cv2.threshold(gray, 150, 255, cv2.THRESH_BINARY_INV)\n", + " \n", + " # Rotate 90 degrees counter-clockwise (Standard for FigureQA)\n", + " label_rot = cv2.rotate(label_area, cv2.ROTATE_90_COUNTERCLOCKWISE)\n", + " \n", + " # Read text with 'allowlist' removed to catch complex words\n", + " label_res = reader.readtext(label_rot)\n", + " \n", + " # Filter noise (labels usually > 2 chars) and reverse list\n", + " x_labels = [res[1] for res in label_res if len(res[1]) > 2]\n", + " x_labels = x_labels[::-1]\n", + "\n", + " # --- C. Intelligent Matching ---\n", + " # The model predicts 10 slots. We take non-zero predictions (e.g. > 1.0)\n", + " # or match the number of labels found.\n", + " \n", + " valid_preds = [round(float(v), 2) for v in preds if v > 1.0] # Filter essentially zero bars\n", + " \n", + " # Heuristic: If we found labels, use that count. If not, use the non-zero predictions.\n", + " count = max(len(x_labels), len(valid_preds))\n", + " count = min(count, 10) # Cap at 10\n", + " \n", + " final_values = [round(float(v), 2) for v in preds[:count]]\n", + " \n", + " # Pad labels if OCR missed some\n", + " while len(x_labels) < len(final_values):\n", + " x_labels.append(f\"Unknown_Label_{len(x_labels)+1}\")\n", + "\n", + " return {\n", + " \"title\": title,\n", + " \"x_axis_labels\": x_labels,\n", + " \"values\": final_values\n", + " }, label_rot # Return image for debug\n", + "\n", + "# --- VISUALIZATION BLOCK ---\n", + "# Pick an image to test\n", + "test_img_path = f\"{vbar_dir}/{train_idx[0]}.png\"\n", + "\n", + "# Run Inference\n", + "result_json, debug_img = get_graph_json_robust(test_img_path)\n", + "\n", + "# 1. Show the cropped area the OCR actually saw\n", + "plt.figure(figsize=(10, 4))\n", + "plt.subplot(1, 2, 1)\n", + "plt.imshow(Image.open(test_img_path))\n", + "plt.title(\"Original Image\")\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(debug_img)\n", + "plt.title(\"What OCR Saw (Rotated Crop)\")\n", + "plt.axis('off')\n", + "plt.show()\n", + "\n", + "# 2. Print Result\n", + "print(json.dumps(result_json, indent=4))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f18abd50-243e-4e66-89e6-991de6bd72c3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"title\": \"title\",\n", + " \"x_axis_labels\": [\n", + " \"Dark Orange\",\n", + " \"Medium Blue\",\n", + " \"Green Yellow\",\n", + " \"Midnight Blue\",\n", + " \"Bubblegum\",\n", + " \"Violet Red\",\n", + " \"Blue\",\n", + " \"Turquoise\",\n", + " \"Dark Red\"\n", + " ],\n", + " \"values\": [\n", + " 37.5,\n", + " 4.4,\n", + " 75.53,\n", + " 46.37,\n", + " 8.61,\n", + " 53.93,\n", + " 77.0,\n", + " 4.95,\n", + " 58.58\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "def get_graph_json_final(image_path):\n", + " model.eval()\n", + " \n", + " # --- A. Get VALUES from Model ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " input_tensor = data_transforms(img_pil).unsqueeze(0).to(device)\n", + " with torch.no_grad():\n", + " # Predict 0-1 and scale to 0-100\n", + " preds = model(input_tensor).squeeze().cpu().numpy() * 100.0\n", + " \n", + " # --- B. Get TEXT from OCR ---\n", + " cv_img = cv2.imread(image_path)\n", + " h, w, _ = cv_img.shape\n", + " \n", + " # 1. Title\n", + " title_res = reader.readtext(cv_img[0:int(h*0.15), :])\n", + " title = title_res[0][1] if title_res else \"Untitled\"\n", + " \n", + " # 2. X-Axis Labels\n", + " label_area = cv_img[int(h*0.70):h, :] \n", + " label_rot = cv2.rotate(label_area, cv2.ROTATE_90_COUNTERCLOCKWISE)\n", + " label_res = reader.readtext(label_rot)\n", + " \n", + " x_labels = [res[1] for res in label_res if len(res[1]) > 1]\n", + " x_labels = x_labels[::-1]\n", + "\n", + " # --- C. Intelligent Matching (The Fix) ---\n", + " # 1. Determine Dynamic Threshold (e.g., 5% of the max value)\n", + " max_val = np.max(preds)\n", + " noise_threshold = max_val * 0.05 \n", + " \n", + " # 2. Filter out \"Ghost Bars\"\n", + " valid_preds = [v for v in preds if v > noise_threshold]\n", + " \n", + " # 3. Match Counts\n", + " # If OCR and Model agree on count (after filtering), perfect.\n", + " # If they disagree, trust the one that found MORE items (safety net),\n", + " # but only if those items are significant.\n", + " count = max(len(x_labels), len(valid_preds))\n", + " count = min(count, 10) \n", + " \n", + " final_values = [round(float(v), 2) for v in preds[:count]]\n", + " \n", + " # Pad labels ONLY if legitimate bars are missing names\n", + " while len(x_labels) < len(final_values):\n", + " x_labels.append(f\"Unknown_Label_{len(x_labels)+1}\")\n", + "\n", + " return {\n", + " \"title\": title,\n", + " \"x_axis_labels\": x_labels,\n", + " \"values\": final_values\n", + " }\n", + "\n", + "# Run Test\n", + "test_img_path = f\"{vbar_dir}/{train_idx[1]}.png\"\n", + "\n", + "plt.figure(figsize=(10, 4))\n", + "plt.subplot(1, 2, 1)\n", + "plt.imshow(Image.open(test_img_path))\n", + "plt.title(\"Original Image\")\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(debug_img)\n", + "plt.title(\"What OCR Saw (Rotated Crop)\")\n", + "plt.axis('off')\n", + "plt.show()\n", + "print(json.dumps(get_graph_json_final(test_img_path), indent=4))" + ] + }, + { + "cell_type": "markdown", + "id": "ba5904a8-78bc-40c2-8d7c-9528535c4986", + "metadata": {}, + "source": [ + "## Extracting data from hbar_categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6a95b4b0-70a2-44d7-b938-127e5aa978e9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Stable Masked HBar Model...\n", + "Epoch 1/40 - Masked L1 Error: 0.2408\n", + "Epoch 5/40 - Masked L1 Error: 0.1231\n", + "Epoch 10/40 - Masked L1 Error: 0.0789\n", + "Epoch 15/40 - Masked L1 Error: 0.0724\n", + "Epoch 20/40 - Masked L1 Error: 0.0626\n", + "Epoch 25/40 - Masked L1 Error: 0.0593\n", + "Epoch 30/40 - Masked L1 Error: 0.0564\n", + "Epoch 35/40 - Masked L1 Error: 0.0496\n", + "Epoch 40/40 - Masked L1 Error: 0.0483\n", + "Stable Masked HBar Model saved successfully!\n", + "\n", + "\n", + "--- DEBUG INFO ---\n", + "Raw Model Predictions: [53.96, 84.2, 29.12, 3.86, 76.59, 4.13, 87.42, 20.8, 91.74, 77.89]\n", + "Raw OCR Labels Found: ['Chocolate', 'Medium Periwinkle', 'Web Purple', 'Dark Slate', 'Indian Red', 'Medium Turquoise', 'Navy Blue', 'Dim Gray', 'Rosy Brown', 'Hot Pink']\n", + "------------------\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"title\": \"title\",\n", + " \"y_axis_labels\": [\n", + " \"Chocolate\",\n", + " \"Medium Periwinkle\",\n", + " \"Web Purple\",\n", + " \"Dark Slate\",\n", + " \"Indian Red\",\n", + " \"Medium Turquoise\",\n", + " \"Navy Blue\",\n", + " \"Dim Gray\",\n", + " \"Rosy Brown\",\n", + " \"Hot Pink\"\n", + " ],\n", + " \"values\": [\n", + " 53.96,\n", + " 84.2,\n", + " 29.12,\n", + " 3.86,\n", + " 76.59,\n", + " 4.13,\n", + " 87.42,\n", + " 20.8,\n", + " 91.74,\n", + " 77.89\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from torchvision import models, transforms\n", + "from PIL import Image\n", + "import json\n", + "import os\n", + "import cv2\n", + "import easyocr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# --- 1. CONFIGURATION ---\n", + "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cpu\")\n", + "reader = easyocr.Reader(['en']) \n", + "\n", + "# Ensure this path matches where your horizontal bar charts are\n", + "hbar_dir = './classifier_sample_data/hbar_categorical' \n", + "annotations_file = '../FigureQA_Dataset/sample_train1/annotations.json'\n", + "\n", + "# --- 2. DATASET (NORMALIZED & MASKED) ---\n", + "class HBarValueDataset(Dataset):\n", + " def __init__(self, image_dir, annotations_file, indices, transform=None):\n", + " self.image_dir = image_dir\n", + " with open(annotations_file, 'r') as f:\n", + " full_data = json.load(f)\n", + " self.data = [item for item in full_data if item['image_index'] in indices]\n", + " self.transform = transform\n", + "\n", + " def __len__(self):\n", + " return len(self.data)\n", + "\n", + " def __getitem__(self, idx):\n", + " item = self.data[idx]\n", + " img_path = os.path.join(self.image_dir, f\"{item['image_index']}.png\")\n", + " image = Image.open(img_path).convert('RGB')\n", + " \n", + " values = item['models'][0]['x'] \n", + " \n", + " target = torch.zeros(10)\n", + " mask = torch.zeros(10)\n", + " \n", + " val_len = min(len(values), 10)\n", + " # We MUST normalize to 0-1 for stable training\n", + " target[:val_len] = torch.tensor(values[:val_len]) / 100.0 \n", + " mask[:val_len] = 1.0 \n", + " \n", + " if self.transform:\n", + " image = self.transform(image)\n", + " \n", + " return image, target, mask\n", + "\n", + "# --- 3. STABLE MODEL ---\n", + "class HBarRegressor(nn.Module):\n", + " def __init__(self):\n", + " super(HBarRegressor, self).__init__()\n", + " self.backbone = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)\n", + " num_ftrs = self.backbone.fc.in_features\n", + " self.backbone.fc = nn.Linear(num_ftrs, 10)\n", + " # Bring Sigmoid back to stabilize learning between 0.0 and 1.0\n", + " self.sigmoid = nn.Sigmoid()\n", + "\n", + " def forward(self, x):\n", + " x = self.backbone(x)\n", + " return self.sigmoid(x)\n", + "\n", + "# --- 4. TRAINING SETUP ---\n", + "image_files = [f for f in os.listdir(hbar_dir) if f.endswith('.png')]\n", + "indices = [int(f.split('.')[0]) for f in image_files]\n", + "train_idx = indices[:int(len(indices)*0.8)] \n", + "\n", + "data_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "train_dataset = HBarValueDataset(hbar_dir, annotations_file, train_idx, data_transforms)\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "\n", + "model = HBarRegressor().to(device)\n", + "\n", + "criterion = nn.L1Loss(reduction='none') \n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + "\n", + "# --- 5. MASKED TRAINING LOOP ---\n", + "print(\"Training Stable Masked HBar Model...\")\n", + "model.train()\n", + "num_epochs = 40 # Slightly longer to ensure it locks in\n", + "\n", + "for epoch in range(num_epochs): \n", + " running_loss = 0.0\n", + " valid_batches = 0\n", + " \n", + " for images, targets, masks in train_loader:\n", + " images = images.to(device)\n", + " targets = targets.to(device)\n", + " masks = masks.to(device)\n", + " \n", + " optimizer.zero_grad()\n", + " outputs = model(images)\n", + " \n", + " raw_loss = criterion(outputs, targets)\n", + " # Average only over REAL bars\n", + " masked_loss = (raw_loss * masks).sum() / masks.sum() \n", + " \n", + " masked_loss.backward()\n", + " optimizer.step()\n", + " \n", + " running_loss += masked_loss.item()\n", + " valid_batches += 1\n", + " \n", + " epoch_loss = running_loss / valid_batches\n", + " if (epoch + 1) % 5 == 0 or epoch == 0:\n", + " print(f\"Epoch {epoch+1}/{num_epochs} - Masked L1 Error: {epoch_loss:.4f}\")\n", + "\n", + "torch.save(model.state_dict(), \"hbar_regressor_stable.pth\")\n", + "print(\"Stable Masked HBar Model saved successfully!\\n\")\n", + "\n", + "# --- 6. INFERENCE & SMOOTH OCR ---\n", + "def get_hbar_json_stable(image_path):\n", + " model.eval()\n", + " \n", + " # 1. Get VALUES\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " input_tensor = data_transforms(img_pil).unsqueeze(0).to(device)\n", + " with torch.no_grad():\n", + " # Scale the 0-1 predictions back up to 0-100\n", + " preds = model(input_tensor).squeeze().cpu().numpy() * 100.0\n", + " \n", + " # 2. Get TEXT\n", + " cv_img = cv2.imread(image_path)\n", + " h, w, _ = cv_img.shape\n", + " \n", + " title_res = reader.readtext(cv_img[0:int(h*0.15), :])\n", + " title = title_res[0][1] if title_res else \"Untitled\"\n", + " \n", + " # OCR Crop\n", + " label_area = cv_img[int(h*0.10):int(h*0.95), 0:int(w*0.45)] \n", + " gray = cv2.cvtColor(label_area, cv2.COLOR_BGR2GRAY)\n", + " \n", + " # SMOOTH CONTRAST: Instead of harsh binary, we gently multiply the darkness\n", + " # This keeps the font edges smooth so EasyOCR can read \"Hot Pink\"\n", + " contrast_img = cv2.convertScaleAbs(gray, alpha=1.5, beta=-50)\n", + " \n", + " label_res = reader.readtext(contrast_img, mag_ratio=2.0)\n", + " y_labels = [res[1] for res in label_res if len(res[1]) > 1]\n", + " \n", + " y_labels = y_labels[::-1]\n", + "\n", + " print(\"\\n--- DEBUG INFO ---\")\n", + " print(f\"Raw Model Predictions: {[round(float(v), 2) for v in preds]}\")\n", + " print(f\"Raw OCR Labels Found: {y_labels}\")\n", + " print(\"------------------\\n\")\n", + "\n", + " # 3. Intelligent Matching\n", + " # Because we use Sigmoid, empty slots will be very close to 0.0 or ~50.0 depending on weight decay\n", + " # We rely on the mask to have trained the real bars.\n", + " valid_preds = [v for v in preds if v > 2.0]\n", + " \n", + " count = len(y_labels) if len(y_labels) > 0 else len(valid_preds)\n", + " count = min(count, 10) \n", + " \n", + " final_values = [round(float(v), 2) for v in preds[:count]]\n", + " \n", + " while len(y_labels) < len(final_values):\n", + " y_labels.append(f\"Unknown_Label_{len(y_labels)+1}\")\n", + "\n", + " return {\n", + " \"title\": title,\n", + " \"y_axis_labels\": y_labels,\n", + " \"values\": final_values\n", + " }, contrast_img\n", + "\n", + "# --- 7. TEST AND VISUALIZATION ---\n", + "test_img_path = f\"{hbar_dir}/{train_idx[1]}.png\"\n", + "\n", + "result_json, debug_img = get_hbar_json_stable(test_img_path)\n", + "\n", + "plt.figure(figsize=(12, 5))\n", + "plt.subplot(1, 2, 1)\n", + "plt.imshow(Image.open(test_img_path))\n", + "plt.title(\"Original HBar Image\")\n", + "plt.axis('off')\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "# Show the smooth contrast image\n", + "plt.imshow(debug_img, cmap='gray')\n", + "plt.title(\"Smooth OCR Vision\")\n", + "plt.axis('off')\n", + "plt.show()\n", + "\n", + "print(json.dumps(result_json, indent=4))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "af67ac12-ae44-4b7b-9bb5-af70fdcb5b9e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The history saving thread hit an unexpected error (OperationalError('attempt to write a readonly database')).History will not be written to the database.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ EXTRACTION SUCCESSFUL:\n", + "\n", + "{\n", + " \"title\": \"University and Emerson\",\n", + " \"y_axis_labels\": [\n", + " \"City\",\n", + " \"City\",\n", + " \"City\",\n", + " \"1,000\",\n", + " \"San Antonio Shopping Center\",\n", + " \"San Antonio Caltrain Station\",\n", + " \"South Van Ness at Marker\",\n", + " \"Caltrain Station\",\n", + " \"Reawood\",\n", + " \"Cowper at University\",\n", + " \"Broadway at Main\",\n", + " \"San Mateo County Center\",\n", + " \"Palo Alto Caltrain Station\",\n", + " \"Medical Center\",\n", + " \"Redwood\",\n", + " \"Rengstorff Avenue / California Street\",\n", + " \"San Jose Civic Center\",\n", + " \"Park at Olive\",\n", + " \"Public Library\",\n", + " \"Redwood\",\n", + " \"Jlaon\",\n", + " \"coilam\",\n", + " \"AYC\",\n", + " \"cdmona\"\n", + " ],\n", + " \"values\": [\n", + " 53.71,\n", + " 15.03,\n", + " 23.82,\n", + " 21.02,\n", + " 42.19,\n", + " 39.1,\n", + " 49.13,\n", + " 62.82,\n", + " 35.86,\n", + " 59.42\n", + " ]\n", + "}\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import models, transforms\n", + "from PIL import Image\n", + "import json\n", + "import cv2\n", + "import easyocr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# --- 1. SETUP & CONFIGURATION ---\n", + "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cpu\")\n", + "reader = easyocr.Reader(['en']) \n", + "\n", + "# --- 2. DEFINE THE MODEL ARCHITECTURE ---\n", + "# This must match exactly how you trained it\n", + "class HBarRegressor(nn.Module):\n", + " def __init__(self):\n", + " super(HBarRegressor, self).__init__()\n", + " self.backbone = models.resnet18(weights=None) # No need for pre-trained weights during inference\n", + " num_ftrs = self.backbone.fc.in_features\n", + " self.backbone.fc = nn.Linear(num_ftrs, 10)\n", + " self.sigmoid = nn.Sigmoid()\n", + "\n", + " def forward(self, x):\n", + " x = self.backbone(x)\n", + " return self.sigmoid(x)\n", + "\n", + "# --- 3. LOAD THE TRAINED WEIGHTS ---\n", + "model = HBarRegressor().to(device)\n", + "# Load the weights you just saved (Make sure the filename matches what you saved)\n", + "model.load_state_dict(torch.load(\"hbar_regressor_stable.pth\", map_location=device))\n", + "model.eval() # Set to evaluation mode\n", + "\n", + "# --- 4. IMAGE TRANSFORMS ---\n", + "data_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# --- 5. THE EXTRACTION FUNCTION ---\n", + "def extract_hbar_data(image_path):\n", + " # --- A. Predict Values ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " input_tensor = data_transforms(img_pil).unsqueeze(0).to(device)\n", + " \n", + " with torch.no_grad():\n", + " preds = model(input_tensor).squeeze().cpu().numpy() * 100.0\n", + " \n", + " # --- B. Extract Text (OCR) ---\n", + " cv_img = cv2.imread(image_path)\n", + " h, w, _ = cv_img.shape\n", + " \n", + " # 1. Title\n", + " title_res = reader.readtext(cv_img[0:int(h*0.15), :])\n", + " title = title_res[0][1] if title_res else \"Untitled\"\n", + " \n", + " # 2. Labels (Smooth Contrast for better reading)\n", + " label_area = cv_img[int(h*0.10):int(h*0.95), 0:int(w*0.45)] \n", + " gray = cv2.cvtColor(label_area, cv2.COLOR_BGR2GRAY)\n", + " contrast_img = cv2.convertScaleAbs(gray, alpha=1.5, beta=-50)\n", + " \n", + " label_res = reader.readtext(contrast_img, mag_ratio=2.0)\n", + " y_labels = [res[1] for res in label_res if len(res[1]) > 1]\n", + " y_labels = y_labels[::-1] # Reverse because graph builds from bottom to top\n", + "\n", + " # --- C. Intelligent Matching ---\n", + " # Filter out empty slots (model predicts ~0 for empty slots)\n", + " valid_preds = [v for v in preds if v > 2.0]\n", + " \n", + " count = len(y_labels) if len(y_labels) > 0 else len(valid_preds)\n", + " count = min(count, 10) \n", + " \n", + " final_values = [round(float(v), 2) for v in preds[:count]]\n", + " \n", + " while len(y_labels) < len(final_values):\n", + " y_labels.append(f\"Unknown_Label_{len(y_labels)+1}\")\n", + "\n", + " return {\n", + " \"title\": title,\n", + " \"y_axis_labels\": y_labels,\n", + " \"values\": final_values\n", + " }, contrast_img\n", + "\n", + "# ==========================================\n", + "# --- 6. TEST WITH YOUR LOCAL IMAGE ---\n", + "# ==========================================\n", + "\n", + "# 👇 REPLACE THIS PATH WITH YOUR ACTUAL IMAGE LOCATION 👇\n", + "my_image_path = \"./Real_Test_Graph/hbar2.png\" \n", + "# Example Mac path: \"/Users/aryangahlot/Desktop/my_test_graph.png\"\n", + "# Example Windows path: \"C:/Users/Aryan/Pictures/test_graph.png\"\n", + "\n", + "try:\n", + " # Run the extraction\n", + " result_json, debug_img = extract_hbar_data(my_image_path)\n", + "\n", + " # Plot the results side-by-side\n", + " plt.figure(figsize=(12, 5))\n", + " \n", + " # Original Image\n", + " plt.subplot(1, 2, 1)\n", + " plt.imshow(Image.open(my_image_path))\n", + " plt.title(\"Your Test Image\")\n", + " plt.axis('off')\n", + "\n", + " # OCR Vision\n", + " plt.subplot(1, 2, 2)\n", + " plt.imshow(debug_img, cmap='gray')\n", + " plt.title(\"What the OCR Engine Read\")\n", + " plt.axis('off')\n", + " \n", + " plt.show()\n", + "\n", + " # Print the Final JSON Data\n", + " print(\"\\n✅ EXTRACTION SUCCESSFUL:\\n\")\n", + " print(json.dumps(result_json, indent=4))\n", + "\n", + "except FileNotFoundError:\n", + " print(f\"❌ ERROR: Could not find the image at '{my_image_path}'. Please check the path and try again.\")\n", + "except Exception as e:\n", + " print(f\"❌ ERROR during extraction: {e}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ba4e26ba-95c4-492d-8cf4-87f1f53c0ec0", + "metadata": {}, + "source": [ + "## Extracting data from pie chart" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "bfad116f-f9b7-475b-8734-fa05bf6a7db9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Stable Pie Model (Using True Percentages)...\n", + "Epoch 1/40 - Masked L1 Error: 0.1604\n", + "Epoch 5/40 - Masked L1 Error: 0.0733\n", + "Epoch 10/40 - Masked L1 Error: 0.0498\n", + "Epoch 15/40 - Masked L1 Error: 0.0400\n", + "Epoch 20/40 - Masked L1 Error: 0.0386\n", + "Epoch 25/40 - Masked L1 Error: 0.0350\n", + "Epoch 30/40 - Masked L1 Error: 0.0352\n", + "Epoch 35/40 - Masked L1 Error: 0.0292\n", + "Epoch 40/40 - Masked L1 Error: 0.0284\n", + "Stable Pie Model saved successfully!\n", + "\n", + "\n", + "--- 🔍 RAW OCR X-RAY ---\n", + "Found: 'title ' | X: 0.36, Y: 0.04\n", + "Found: 'Light Seafoam ' | X: 0.18, Y: 0.78\n", + "Found: 'Olive ' | X: 0.12, Y: 0.83\n", + "Found: 'Coral ' | X: 0.12, Y: 0.89\n", + "Found: 'Violet Red ' | X: 0.16, Y: 0.95\n", + "------------------------\n", + "\n", + "✅ Filtered Legend Names: ['Light Seafoam', 'Olive', 'Coral', 'Violet Red']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ FINAL JSON DICTIONARY:\n", + "\n", + "{\n", + " \"title\": \"title\",\n", + " \"data\": {\n", + " \"Light Seafoam\": 8.97,\n", + " \"Olive\": 25.51,\n", + " \"Coral\": 23.38,\n", + " \"Violet Red\": 42.14\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from torchvision import models, transforms\n", + "from PIL import Image\n", + "import json\n", + "import os\n", + "import cv2\n", + "import easyocr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import math\n", + "\n", + "# --- 1. CONFIGURATION ---\n", + "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cpu\")\n", + "reader = easyocr.Reader(['en']) \n", + "\n", + "# Ensure this points to where your pie charts are stored\n", + "pie_dir = './classifier_sample_data/pie' \n", + "annotations_file = '../FigureQA_Dataset/sample_train1/annotations.json'\n", + "\n", + "data_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# --- 2. DATASET (SPAN TO PERCENTAGE) ---\n", + "class PieChartDataset(Dataset):\n", + " def __init__(self, image_dir, annotations_file, indices, transform=None):\n", + " self.image_dir = image_dir\n", + " with open(annotations_file, 'r') as f:\n", + " full_data = json.load(f)\n", + " \n", + " self.data = [item for item in full_data if item['image_index'] in indices and item['type'] == 'pie']\n", + " self.transform = transform\n", + "\n", + " def __len__(self):\n", + " return len(self.data)\n", + "\n", + " def __getitem__(self, idx):\n", + " item = self.data[idx]\n", + " img_path = os.path.join(self.image_dir, f\"{item['image_index']}.png\")\n", + " image = Image.open(img_path).convert('RGB')\n", + " \n", + " models_data = item['models']\n", + " values = []\n", + " \n", + " # Extract Percentage from Radians (span)\n", + " for m in models_data:\n", + " if 'span' in m:\n", + " # 2 * pi radians = 100% of the pie\n", + " pct = (m['span'] / (2 * math.pi)) * 100.0\n", + " values.append(pct)\n", + " else:\n", + " values.append(0.0)\n", + " \n", + " target = torch.zeros(10)\n", + " mask = torch.zeros(10)\n", + " \n", + " val_len = min(len(values), 10)\n", + " if val_len > 0:\n", + " target[:val_len] = torch.tensor(values[:val_len]) / 100.0 \n", + " mask[:val_len] = 1.0 \n", + " \n", + " if self.transform:\n", + " image = self.transform(image)\n", + " \n", + " return image, target, mask\n", + "\n", + "# --- 3. 10-OUTPUT MODEL ---\n", + "class PieRegressor(nn.Module):\n", + " def __init__(self):\n", + " super(PieRegressor, self).__init__()\n", + " self.backbone = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)\n", + " num_ftrs = self.backbone.fc.in_features\n", + " self.backbone.fc = nn.Linear(num_ftrs, 10)\n", + " self.sigmoid = nn.Sigmoid()\n", + "\n", + " def forward(self, x):\n", + " x = self.backbone(x)\n", + " return self.sigmoid(x)\n", + "\n", + "# --- 4. TRAINING SETUP ---\n", + "image_files = [f for f in os.listdir(pie_dir) if f.endswith('.png')]\n", + "indices = [int(f.split('.')[0]) for f in image_files]\n", + "train_idx = indices[:int(len(indices)*0.8)] \n", + "\n", + "train_dataset = PieChartDataset(pie_dir, annotations_file, train_idx, data_transforms)\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "\n", + "model = PieRegressor().to(device)\n", + "criterion = nn.L1Loss(reduction='none') \n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + "\n", + "# --- 5. MASKED TRAINING LOOP ---\n", + "print(\"Training Stable Pie Model (Using True Percentages)...\")\n", + "model.train()\n", + "num_epochs = 40 \n", + "\n", + "for epoch in range(num_epochs): \n", + " running_loss = 0.0\n", + " valid_batches = 0\n", + " for images, targets, masks in train_loader:\n", + " images, targets, masks = images.to(device), targets.to(device), masks.to(device)\n", + " \n", + " optimizer.zero_grad()\n", + " outputs = model(images)\n", + " \n", + " raw_loss = criterion(outputs, targets)\n", + " masked_loss = (raw_loss * masks).sum() / masks.sum() \n", + " \n", + " masked_loss.backward()\n", + " optimizer.step()\n", + " \n", + " running_loss += masked_loss.item()\n", + " valid_batches += 1\n", + " \n", + " epoch_loss = running_loss / valid_batches\n", + " if (epoch + 1) % 5 == 0 or epoch == 0:\n", + " print(f\"Epoch {epoch+1}/{num_epochs} - Masked L1 Error: {epoch_loss:.4f}\")\n", + "\n", + "torch.save(model.state_dict(), \"pie_regressor_stable.pth\")\n", + "print(\"Stable Pie Model saved successfully!\\n\")\n", + "\n", + "# --- 6. FULL-IMAGE OCR WITH 100% SUM ENFORCEMENT ---\n", + "def extract_pie_chart_data(image_path):\n", + " model.eval()\n", + " \n", + " # --- A. Predict Slice Values ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " input_tensor = data_transforms(img_pil).unsqueeze(0).to(device)\n", + " \n", + " with torch.no_grad():\n", + " preds = model(input_tensor).squeeze().cpu().numpy() * 100.0\n", + " \n", + " # --- B. Read Entire Image ---\n", + " cv_img = cv2.imread(image_path)\n", + " h, w, _ = cv_img.shape\n", + " gray = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY)\n", + " \n", + " all_text_results = reader.readtext(gray, mag_ratio=2.5)\n", + " \n", + " # --- C. Spatial Sorting ---\n", + " title = \"Untitled\"\n", + " raw_legend_names = [] \n", + " \n", + " print(\"\\n--- 🔍 RAW OCR X-RAY ---\")\n", + " for bbox, text, conf in all_text_results:\n", + " clean_text = text.strip()\n", + " if not clean_text:\n", + " continue\n", + " \n", + " x_center = (bbox[0][0] + bbox[2][0]) / 2\n", + " y_center = (bbox[0][1] + bbox[2][1]) / 2\n", + " \n", + " x_pct = x_center / w\n", + " y_pct = y_center / h\n", + " \n", + " print(f\"Found: '{clean_text:15}' | X: {x_pct:.2f}, Y: {y_pct:.2f}\")\n", + " \n", + " # 1. TITLE (Top 15%)\n", + " if y_pct < 0.15:\n", + " title = clean_text\n", + " \n", + " # 2. LEGEND (Anywhere below the title for Pie Charts)\n", + " elif y_pct > 0.15:\n", + " if len(clean_text) > 2 and not clean_text.replace('.', '', 1).isdigit():\n", + " if clean_text.lower() == \"grav\": clean_text = \"Gray\"\n", + " raw_legend_names.append((y_pct, clean_text)) \n", + " \n", + " print(\"------------------------\\n\")\n", + "\n", + " # Sort legend Top-to-Bottom by Y coordinate\n", + " legend_names = [item[1] for item in sorted(raw_legend_names, key=lambda i: i[0])]\n", + " print(f\"✅ Filtered Legend Names: {legend_names}\")\n", + "\n", + " # --- D. Format Dictionary & Force 100% Sum ---\n", + " num_slices = len(legend_names)\n", + " \n", + " # Fallback if OCR missed entirely\n", + " if num_slices == 0:\n", + " valid_preds = [v for v in preds if v > 1.5]\n", + " num_slices = len(valid_preds)\n", + " \n", + " num_slices = min(num_slices, 10)\n", + " \n", + " # Isolate ONLY the predictions for the slices we actually have\n", + " slice_preds = preds[:num_slices]\n", + " \n", + " # Normalize those exact slices so they perfectly equal 100%\n", + " total_pred = sum(slice_preds)\n", + " if total_pred > 0:\n", + " normalized_preds = [(v / total_pred) * 100.0 for v in slice_preds]\n", + " else:\n", + " normalized_preds = slice_preds\n", + " \n", + " final_slices = {}\n", + " for i in range(num_slices):\n", + " slice_name = legend_names[i] if i < len(legend_names) else f\"Unknown_Slice_{i+1}\"\n", + " slice_value = round(normalized_preds[i], 2) if i < len(normalized_preds) else 0.0\n", + " final_slices[slice_name] = slice_value\n", + "\n", + " return {\n", + " \"title\": title,\n", + " \"data\": final_slices\n", + " }\n", + "\n", + "# --- 7. EXECUTION ---\n", + "test_img_path = f\"{pie_dir}/{train_idx[0]}.png\"\n", + "\n", + "try:\n", + " result_json = extract_pie_chart_data(test_img_path)\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(Image.open(test_img_path))\n", + " plt.title(\"Original Pie Chart\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " print(\"\\n✅ FINAL JSON DICTIONARY:\\n\")\n", + " print(json.dumps(result_json, indent=4))\n", + " \n", + "except Exception as e:\n", + " print(f\"Error testing pie chart: {e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "54c76965-1d8e-49bf-ac24-05b1fd0d9e65", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- 🔍 RAW OCR X-RAY ---\n", + "Found: 'Recommended Diet' | X: 0.49, Y: 0.11\n", + "Found: 'Fcuil ' | X: 0.83, Y: 0.33\n", + "Found: 'Protcin ' | X: 0.85, Y: 0.43\n", + "Found: 'Uvczctab c5 ' | X: 0.86, Y: 0.52\n", + "Found: 'Daln ' | X: 0.83, Y: 0.61\n", + "Found: 'Gralts ' | X: 0.84, Y: 0.70\n", + "Found: 'Klothe: ' | X: 0.82, Y: 0.79\n", + "------------------------\n", + "\n", + "✅ Filtered Legend Names: ['Fcuil', 'Protcin', 'Uvczctab c5', 'Daln', 'Gralts', 'Klothe:']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ FINAL JSON DICTIONARY:\n", + "\n", + "{\n", + " \"title\": \"Recommended Diet\",\n", + " \"data\": {\n", + " \"Fcuil\": 28.06,\n", + " \"Protcin\": 18.35,\n", + " \"Uvczctab c5\": 14.57,\n", + " \"Daln\": 24.01,\n", + " \"Gralts\": 5.38,\n", + " \"Klothe:\": 9.62\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "# ==========================================\n", + "# --- 7. TEST WITH ANY LOCAL IMAGE ---\n", + "# ==========================================\n", + "\n", + "# 👇 REPLACE THIS PATH WITH YOUR ACTUAL IMAGE LOCATION 👇\n", + "my_image_path = \"./Real_Test_Graph/imagespie.jpeg\" \n", + "\n", + "try:\n", + " # Run the extraction function\n", + " result_json = extract_pie_chart_data(my_image_path)\n", + "\n", + " # Display the image side-by-side with the results\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(Image.open(my_image_path))\n", + " plt.title(\"Your Pie Chart Image\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " # Print the clean JSON data\n", + " print(\"\\n✅ FINAL JSON DICTIONARY:\\n\")\n", + " print(json.dumps(result_json, indent=4))\n", + " \n", + "except FileNotFoundError:\n", + " print(f\"❌ ERROR: Could not find the image at '{my_image_path}'. Please check the path and try again.\")\n", + "except Exception as e:\n", + " print(f\"❌ ERROR testing pie chart: {e}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ed5025c9-4fa8-4083-8ccd-ca09201f4077", + "metadata": {}, + "source": [ + "## Training on real dataset for classifiers" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "88a75806-d84e-45ea-8261-177a40a528ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting\n" + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "import shutil\n", + "\n", + "# Base directory as seen in your screenshot\n", + "base_dir = '../FigureQA_Dataset'\n", + "\n", + "# Explicit Train and Validation directories\n", + "train_dir = os.path.join(base_dir, 'train1')\n", + "val_dir = os.path.join(base_dir, 'validation1')\n", + "\n", + "train_annots = os.path.join(train_dir, 'annotations.json')\n", + "val_annots = os.path.join(val_dir, 'annotations.json')\n", + "\n", + "train_images_dir = os.path.join(train_dir, 'png')\n", + "val_images_dir = os.path.join(val_dir, 'png')\n", + "print(\"Starting\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "49faedc2-79b5-4a6b-8fcd-95dc529b4140", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data organized into ./classifier_data/train\n", + "Data organized into ./classifier_data/val\n" + ] + } + ], + "source": [ + "output_dir = './classifier_data'\n", + "\n", + "def prepare_folders(source_images_dir, annotations_file, target_base_dir):\n", + " with open(annotations_file, 'r') as f:\n", + " annotations = json.load(f)\n", + "\n", + " for item in annotations:\n", + " img_idx = item['image_index']\n", + " graph_type = item['type']\n", + " \n", + " # Create folder for each type inside train/val\n", + " type_dir = os.path.join(target_base_dir, graph_type)\n", + " os.makedirs(type_dir, exist_ok=True)\n", + " \n", + " # Copy image\n", + " src = os.path.join(source_images_dir, f\"{img_idx}.png\")\n", + " dst = os.path.join(type_dir, f\"{img_idx}.png\")\n", + " if os.path.exists(src):\n", + " shutil.copy(src, dst)\n", + "\n", + " print(f\"Data organized into {target_base_dir}\")\n", + "\n", + "# Run for both Train and Validation sets\n", + "prepare_folders(train_images_dir, train_annots, os.path.join(output_dir, 'train'))\n", + "prepare_folders(val_images_dir, val_annots, os.path.join(output_dir, 'val'))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3d6ac120-6ba3-4c6c-85ea-af920d5149b5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training images: 100000, Validation images: 20000\n", + "Classification model ready for training.\n" + ] + } + ], + "source": [ + "from torchvision import datasets, models, transforms\n", + "import torch\n", + "import torch.nn as nn\n", + "\n", + "data_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# Load directly from the specific train and val folders\n", + "train_dataset = datasets.ImageFolder(os.path.join(output_dir, 'train'), transform=data_transforms)\n", + "val_dataset = datasets.ImageFolder(os.path.join(output_dir, 'val'), transform=data_transforms)\n", + "\n", + "train_size = len(train_dataset)\n", + "val_size = len(val_dataset)\n", + "print(f\"Training images: {train_size}, Validation images: {val_size}\")\n", + "\n", + "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=32, shuffle=False)\n", + "\n", + "# Initialize Pre-trained ResNet18\n", + "model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)\n", + "\n", + "for param in model.parameters():\n", + " param.requires_grad = False\n", + "\n", + "num_ftrs = model.fc.in_features\n", + "model.fc = nn.Linear(num_ftrs, len(train_dataset.classes))\n", + "\n", + "print(\"Classification model ready for training.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c9b72681-6710-4760-9285-d24ea42f9646", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Classification Model on mps with 100000 images...\n", + " Epoch 1 | Processed 500/3125 batches... Loss: 0.0221\n", + " Epoch 1 | Processed 1000/3125 batches... Loss: 0.0048\n", + " Epoch 1 | Processed 1500/3125 batches... Loss: 0.0009\n", + " Epoch 1 | Processed 2000/3125 batches... Loss: 0.0010\n", + " Epoch 1 | Processed 2500/3125 batches... Loss: 0.0007\n", + " Epoch 1 | Processed 3000/3125 batches... Loss: 0.0003\n", + "*** Epoch 1/5 COMPLETE | Train Loss: 0.0193 Acc: 0.9971 | Val Acc: 1.0000 | Time: 470s ***\n", + "\n", + " Epoch 2 | Processed 500/3125 batches... Loss: 0.0172\n", + " Epoch 2 | Processed 1000/3125 batches... Loss: 0.0003\n", + " Epoch 2 | Processed 1500/3125 batches... Loss: 0.0001\n", + " Epoch 2 | Processed 2000/3125 batches... Loss: 0.0000\n", + " Epoch 2 | Processed 2500/3125 batches... Loss: 0.0000\n", + " Epoch 2 | Processed 3000/3125 batches... Loss: 0.0020\n", + "*** Epoch 2/5 COMPLETE | Train Loss: 0.0016 Acc: 0.9996 | Val Acc: 1.0000 | Time: 472s ***\n", + "\n", + " Epoch 3 | Processed 500/3125 batches... Loss: 0.0001\n", + " Epoch 3 | Processed 1000/3125 batches... Loss: 0.0001\n", + " Epoch 3 | Processed 1500/3125 batches... Loss: 0.0893\n", + " Epoch 3 | Processed 2000/3125 batches... Loss: 0.0000\n", + " Epoch 3 | Processed 2500/3125 batches... Loss: 0.0019\n", + " Epoch 3 | Processed 3000/3125 batches... Loss: 0.1111\n", + "*** Epoch 3/5 COMPLETE | Train Loss: 0.0011 Acc: 0.9997 | Val Acc: 0.9999 | Time: 483s ***\n", + "\n", + " Epoch 4 | Processed 500/3125 batches... Loss: 0.0001\n", + " Epoch 4 | Processed 1000/3125 batches... Loss: 0.0000\n", + " Epoch 4 | Processed 1500/3125 batches... Loss: 0.0000\n", + " Epoch 4 | Processed 2000/3125 batches... Loss: 0.0000\n", + " Epoch 4 | Processed 2500/3125 batches... Loss: 0.0000\n", + " Epoch 4 | Processed 3000/3125 batches... Loss: 0.0000\n", + "*** Epoch 4/5 COMPLETE | Train Loss: 0.0006 Acc: 0.9998 | Val Acc: 1.0000 | Time: 479s ***\n", + "\n", + " Epoch 5 | Processed 500/3125 batches... Loss: 0.0001\n", + " Epoch 5 | Processed 1000/3125 batches... Loss: 0.0000\n", + " Epoch 5 | Processed 1500/3125 batches... Loss: 0.0000\n", + " Epoch 5 | Processed 2000/3125 batches... Loss: 0.0133\n", + " Epoch 5 | Processed 2500/3125 batches... Loss: 0.0000\n", + " Epoch 5 | Processed 3000/3125 batches... Loss: 0.0000\n", + "*** Epoch 5/5 COMPLETE | Train Loss: 0.0008 Acc: 0.9997 | Val Acc: 0.9999 | Time: 521s ***\n", + "\n", + "\n", + "Success! Model saved as 'graph_classifier_real.pth'\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import time\n", + "import os\n", + "from torchvision import datasets, models, transforms\n", + "\n", + "# 1. Setup hardware acceleration\n", + "if torch.backends.mps.is_available():\n", + " device = torch.device(\"mps\")\n", + "elif torch.cuda.is_available():\n", + " device = torch.device(\"cuda\")\n", + "else:\n", + " device = torch.device(\"cpu\")\n", + "\n", + "# ==========================================\n", + "# 2. EXPLICITLY LOAD CLASSIFIER DATA\n", + "# ==========================================\n", + "output_dir = './classifier_data'\n", + "data_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# Load data specifically from the train/val folders\n", + "train_dataset = datasets.ImageFolder(os.path.join(output_dir, 'train'), transform=data_transforms)\n", + "val_dataset = datasets.ImageFolder(os.path.join(output_dir, 'val'), transform=data_transforms)\n", + "\n", + "train_size = len(train_dataset)\n", + "val_size = len(val_dataset)\n", + "\n", + "# Note: Renamed to 'class_train_loader' to avoid conflicts with the regression step!\n", + "class_train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)\n", + "class_val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=32, shuffle=False)\n", + "\n", + "# ==========================================\n", + "# 3. SETUP MODEL & LOSS\n", + "# ==========================================\n", + "model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)\n", + "\n", + "for param in model.parameters():\n", + " param.requires_grad = False\n", + "\n", + "num_ftrs = model.fc.in_features\n", + "model.fc = nn.Linear(num_ftrs, len(train_dataset.classes))\n", + "model = model.to(device)\n", + "\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(model.fc.parameters(), lr=0.001)\n", + "\n", + "# ==========================================\n", + "# 4. TRAINING LOOP\n", + "# ==========================================\n", + "num_epochs = 5 \n", + "print(f\"Training Classification Model on {device} with {train_size} images...\")\n", + "\n", + "\n", + "for epoch in range(num_epochs):\n", + " start_time = time.time()\n", + " \n", + " # --- TRAINING PHASE ---\n", + " model.train()\n", + " running_loss = 0.0\n", + " running_corrects = 0\n", + "\n", + " # Ensure we use the freshly loaded classification data\n", + " for i, (inputs, labels) in enumerate(class_train_loader):\n", + " inputs, labels = inputs.to(device), labels.to(device)\n", + "\n", + " optimizer.zero_grad()\n", + " outputs = model(inputs)\n", + " _, preds = torch.max(outputs, 1)\n", + " \n", + " loss = criterion(outputs, labels)\n", + " \n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item() * inputs.size(0)\n", + " running_corrects += torch.sum(preds == labels.data)\n", + " \n", + " if (i + 1) % 500 == 0:\n", + " print(f\" Epoch {epoch+1} | Processed {i+1}/{len(class_train_loader)} batches... Loss: {loss.item():.4f}\")\n", + "\n", + " epoch_loss = running_loss / train_size\n", + " epoch_acc = running_corrects.float() / train_size\n", + "\n", + " # --- VALIDATION PHASE ---\n", + " model.eval()\n", + " val_corrects = 0\n", + " with torch.no_grad():\n", + " for inputs, labels in class_val_loader:\n", + " inputs, labels = inputs.to(device), labels.to(device)\n", + " outputs = model(inputs)\n", + " _, preds = torch.max(outputs, 1)\n", + " val_corrects += torch.sum(preds == labels.data)\n", + " \n", + " val_acc = val_corrects.float() / val_size\n", + " \n", + " duration = time.time() - start_time\n", + " print(f'*** Epoch {epoch+1}/{num_epochs} COMPLETE | '\n", + " f'Train Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f} | '\n", + " f'Val Acc: {val_acc:.4f} | Time: {duration:.0f}s ***\\n')\n", + "\n", + "# Save the model weights \n", + "torch.save(model.state_dict(), 'graph_classifier_real.pth')\n", + "print(\"\\nSuccess! Model saved as 'graph_classifier_real.pth'\")" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f0745302-6fbd-4473-b6d0-04c2e7067d8b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Classification Result ---\n", + "File: 17494.png\n", + "Detected Type: vbar_categorical\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "'vbar_categorical'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import models, transforms\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import random\n", + "\n", + "# 1. Setup hardware acceleration\n", + "if torch.backends.mps.is_available():\n", + " device = torch.device(\"mps\")\n", + "elif torch.cuda.is_available():\n", + " device = torch.device(\"cuda\")\n", + "else:\n", + " device = torch.device(\"cpu\")\n", + "\n", + "# 2. Define the exact class names your model learned\n", + "# (PyTorch ImageFolder sorts folders alphabetically)\n", + "class_names = ['dot_line', 'hbar_categorical', 'line', 'pie', 'vbar_categorical']\n", + "\n", + "# 3. Re-initialize the model architecture\n", + "model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)\n", + "num_ftrs = model.fc.in_features\n", + "model.fc = nn.Linear(num_ftrs, len(class_names))\n", + "\n", + "# Load your newly trained weights!\n", + "model.load_state_dict(torch.load('graph_classifier_real.pth', map_location=device))\n", + "model = model.to(device)\n", + "model.eval() # Important: Set to evaluation mode (turns off training mechanics)\n", + "\n", + "# 4. Define the exact same image transformations used in training\n", + "data_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# 5. Create the universal prediction function\n", + "def classify_graph(image_path):\n", + " # Open image and convert to RGB (just in case it has an alpha channel)\n", + " img = Image.open(image_path).convert('RGB')\n", + " \n", + " # Apply transforms and add a batch dimension so it matches training shape\n", + " img_tensor = data_transforms(img).unsqueeze(0).to(device)\n", + " \n", + " # Run the model\n", + " with torch.no_grad():\n", + " outputs = model(img_tensor)\n", + " _, preds = torch.max(outputs, 1)\n", + " predicted_class = class_names[preds[0].item()]\n", + " \n", + " # Display the result visually\n", + " plt.figure(figsize=(7, 5))\n", + " plt.imshow(img)\n", + " plt.title(f\"Predicted Graph Type:\\n{predicted_class}\", fontsize=14, fontweight='bold', color='darkblue')\n", + " plt.axis('off')\n", + " plt.show()\n", + " \n", + " print(f\"--- Classification Result ---\")\n", + " print(f\"File: {os.path.basename(image_path)}\")\n", + " print(f\"Detected Type: {predicted_class}\\n\")\n", + " \n", + " return predicted_class\n", + "\n", + "# ==========================================\n", + "# 6. TEST IT ON AN UNSEEN REAL DATASET IMAGE\n", + "# ==========================================\n", + "test_dir = '../FigureQA_Dataset/no_annot_test1/png'\n", + "\n", + "# Pick a random image from the real test set\n", + "all_test_images = [f for f in os.listdir(test_dir) if f.endswith('.png')]\n", + "random_test_image = os.path.join(test_dir, random.choice(all_test_images))\n", + "\n", + "# Run your new tool!\n", + "detected_type = classify_graph(random_test_image)\n", + "detected_type" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "37bd8ff8-4efc-4f43-a885-617649d01dc5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Classification Result ---\n", + "File: PieChart.png\n", + "Detected Type: pie\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "'pie'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "classify_graph(\"./Real_Test_Graph/PieChart.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "5bfaa495-4cd9-414a-a67f-f01c9c1099ac", + "metadata": {}, + "source": [ + "## Graph Data Extraction real data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4bac3132-71c8-4539-be54-85ddd0e22f43", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading datasets...\n", + "Loading JSON annotations from ../FigureQA_Dataset/train1/annotations.json...\n", + "Dataset ready! Found 20000 valid pie charts.\n", + "\n", + "Loading JSON annotations from ../FigureQA_Dataset/validation1/annotations.json...\n", + "Dataset ready! Found 4000 valid pie charts.\n", + "\n", + "\n", + "========== Epoch 1/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [03:26<00:00, 3.03it/s, loss=0.0278]\n", + "Validating: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:13<00:00, 9.25it/s, loss=0.0213]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 1 Summary | Train Masked L1: 0.0354 | Val Masked L1: 0.0226\n", + "\n", + "========== Epoch 2/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [03:42<00:00, 2.80it/s, loss=0.0119]\n", + "Validating: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:14<00:00, 8.82it/s, loss=0.0154]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 2 Summary | Train Masked L1: 0.0205 | Val Masked L1: 0.0166\n", + "\n", + "========== Epoch 3/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [03:52<00:00, 2.69it/s, loss=0.0135]\n", + "Validating: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:14<00:00, 8.53it/s, loss=0.0133]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 3 Summary | Train Masked L1: 0.0167 | Val Masked L1: 0.0136\n", + "\n", + "========== Epoch 4/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [03:54<00:00, 2.66it/s, loss=0.0143]\n", + "Validating: 100%|████████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:14<00:00, 8.39it/s, loss=0.013]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 4 Summary | Train Masked L1: 0.0145 | Val Masked L1: 0.0141\n", + "\n", + "========== Epoch 5/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [03:57<00:00, 2.63it/s, loss=0.0107]\n", + "Validating: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:14<00:00, 8.35it/s, loss=0.0107]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 5 Summary | Train Masked L1: 0.0137 | Val Masked L1: 0.0105\n", + "\n", + "========== Epoch 6/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [03:59<00:00, 2.61it/s, loss=0.0134]\n", + "Validating: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:15<00:00, 8.25it/s, loss=0.0118]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 6 Summary | Train Masked L1: 0.0123 | Val Masked L1: 0.0121\n", + "\n", + "========== Epoch 7/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [04:03<00:00, 2.57it/s, loss=0.0122]\n", + "Validating: 100%|███████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:15<00:00, 7.95it/s, loss=0.0116]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 7 Summary | Train Masked L1: 0.0112 | Val Masked L1: 0.0127\n", + "\n", + "========== Epoch 8/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [04:15<00:00, 2.45it/s, loss=0.0101]\n", + "Validating: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:15<00:00, 7.85it/s, loss=0.00921]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 8 Summary | Train Masked L1: 0.0109 | Val Masked L1: 0.0105\n", + "\n", + "========== Epoch 9/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [04:15<00:00, 2.45it/s, loss=0.00876]\n", + "Validating: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:16<00:00, 7.81it/s, loss=0.00816]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 9 Summary | Train Masked L1: 0.0098 | Val Masked L1: 0.0087\n", + "\n", + "========== Epoch 10/10 ==========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|█████████████████████████████████████████████████████████████████████████████████████████████| 625/625 [04:17<00:00, 2.43it/s, loss=0.0086]\n", + "Validating: 100%|██████████████████████████████████████████████████████████████████████████████████████████| 125/125 [00:16<00:00, 7.75it/s, loss=0.00841]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-> Epoch 10 Summary | Train Masked L1: 0.0097 | Val Masked L1: 0.0101\n", + "\n", + "✅ Robust Pie Model saved successfully!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from torchvision import models, transforms\n", + "from PIL import Image\n", + "import json\n", + "import os\n", + "import math\n", + "from tqdm import tqdm\n", + "\n", + "# --- 1. CONFIGURATION & AUGMENTATION ---\n", + "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "train_dir = './classifier_data/train/pie'\n", + "val_dir = './classifier_data/val/pie'\n", + "train_annotations_file = '../FigureQA_Dataset/train1/annotations.json' \n", + "val_annotations_file = '../FigureQA_Dataset/validation1/annotations.json'\n", + "\n", + "# Heavy Augmentation for Training (Fixes Domain Shift)\n", + "train_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.1),\n", + " transforms.RandomRotation(degrees=45),\n", + " transforms.GaussianBlur(kernel_size=(5, 9), sigma=(0.1, 5)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# Clean transforms for Validation\n", + "val_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# --- 2. DATASET ---\n", + "class PieChartDataset(Dataset):\n", + " def __init__(self, image_dir, annotations_file, transform=None):\n", + " self.image_dir = image_dir\n", + " \n", + " print(f\"Loading JSON annotations from {annotations_file}...\")\n", + " with open(annotations_file, 'r') as f:\n", + " full_data = json.load(f)\n", + " \n", + " valid_indices = {int(f.split('.')[0]) for f in os.listdir(image_dir) if f.endswith('.png')}\n", + " self.data = [item for item in full_data if item['image_index'] in valid_indices and item['type'] == 'pie']\n", + " self.transform = transform\n", + " print(f\"Dataset ready! Found {len(self.data)} valid pie charts.\\n\")\n", + "\n", + " def __len__(self):\n", + " return len(self.data)\n", + "\n", + " def __getitem__(self, idx):\n", + " item = self.data[idx]\n", + " img_path = os.path.join(self.image_dir, f\"{item['image_index']}.png\")\n", + " image = Image.open(img_path).convert('RGB')\n", + " \n", + " models_data = item['models']\n", + " values = []\n", + " \n", + " for m in models_data:\n", + " if 'span' in m:\n", + " pct = (m['span'] / (2 * math.pi)) * 100.0\n", + " values.append(pct)\n", + " else:\n", + " values.append(0.0)\n", + " \n", + " # ⚡ CRITICAL FIX: Sort the values from Largest to Smallest\n", + " values.sort(reverse=True)\n", + " \n", + " target = torch.zeros(10)\n", + " mask = torch.zeros(10)\n", + " \n", + " val_len = min(len(values), 10)\n", + " if val_len > 0:\n", + " target[:val_len] = torch.tensor(values[:val_len]) / 100.0 \n", + " mask[:val_len] = 1.0 \n", + " \n", + " if self.transform:\n", + " image = self.transform(image)\n", + " \n", + " return image, target, mask\n", + "\n", + "# --- 3. 10-OUTPUT MODEL ---\n", + "class PieRegressor(nn.Module):\n", + " def __init__(self):\n", + " super(PieRegressor, self).__init__()\n", + " self.backbone = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)\n", + " num_ftrs = self.backbone.fc.in_features\n", + " self.backbone.fc = nn.Linear(num_ftrs, 10)\n", + " self.sigmoid = nn.Sigmoid()\n", + "\n", + " def forward(self, x):\n", + " x = self.backbone(x)\n", + " return self.sigmoid(x)\n", + "\n", + "# --- 4. DATA LOADERS (Jupyter Safe) ---\n", + "print(\"Loading datasets...\")\n", + "train_dataset = PieChartDataset(train_dir, train_annotations_file, train_transforms)\n", + "val_dataset = PieChartDataset(val_dir, val_annotations_file, val_transforms)\n", + "\n", + "# ⚡ CRITICAL FIX: num_workers=0 and pin_memory=False to stop Jupyter from crashing on Mac!\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=0, pin_memory=False)\n", + "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=0, pin_memory=False)\n", + "\n", + "model = PieRegressor().to(device)\n", + "criterion = nn.L1Loss(reduction='none') \n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + "\n", + "# --- 5. TRAINING LOOP ---\n", + "num_epochs = 10 # 10 Epochs is a good starting point to let the model learn through the augmentation\n", + "\n", + "for epoch in range(num_epochs): \n", + " print(f\"\\n========== Epoch {epoch+1}/{num_epochs} ==========\")\n", + " model.train()\n", + " train_loss = 0.0\n", + " train_batches = 0\n", + " \n", + " train_loop = tqdm(train_loader, desc=\"Training\", leave=True)\n", + " for images, targets, masks in train_loop:\n", + " images, targets, masks = images.to(device), targets.to(device), masks.to(device)\n", + " \n", + " optimizer.zero_grad()\n", + " outputs = model(images)\n", + " raw_loss = criterion(outputs, targets)\n", + " masked_loss = (raw_loss * masks).sum() / masks.sum() \n", + " masked_loss.backward()\n", + " optimizer.step()\n", + " \n", + " train_loss += masked_loss.item()\n", + " train_batches += 1\n", + " train_loop.set_postfix(loss=masked_loss.item())\n", + " \n", + " epoch_train_loss = train_loss / train_batches if train_batches > 0 else 0\n", + " \n", + " # Validation Phase\n", + " model.eval()\n", + " val_loss = 0.0\n", + " val_batches = 0\n", + " val_loop = tqdm(val_loader, desc=\"Validating\", leave=True)\n", + " \n", + " with torch.no_grad():\n", + " for images, targets, masks in val_loop:\n", + " images, targets, masks = images.to(device), targets.to(device), masks.to(device)\n", + " outputs = model(images)\n", + " raw_loss = criterion(outputs, targets)\n", + " \n", + " mask_sum = masks.sum()\n", + " if mask_sum > 0:\n", + " masked_loss = (raw_loss * masks).sum() / mask_sum\n", + " val_loss += masked_loss.item()\n", + " val_batches += 1\n", + " val_loop.set_postfix(loss=masked_loss.item())\n", + " \n", + " epoch_val_loss = val_loss / val_batches if val_batches > 0 else 0\n", + " print(f\"-> Epoch {epoch+1} Summary | Train Masked L1: {epoch_train_loss:.4f} | Val Masked L1: {epoch_val_loss:.4f}\")\n", + "\n", + "torch.save(model.state_dict(), \"pie_regressor_real.pth\")\n", + "print(\"\\n✅ Robust Pie Model saved successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "307eaf9c-eb25-4a91-9260-c3c402f24626", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ FINAL JSON DICTIONARY:\n", + "\n", + "{\n", + " \"title\": \"Tha Learning App\",\n", + " \"data\": {\n", + " \"Mathematics\": 27.98,\n", + " \"Science\": 25.23,\n", + " \"Social science\": 20.35,\n", + " \"English\": 14.93,\n", + " \"Hindi\": 11.51\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from torchvision import models, transforms\n", + "from PIL import Image\n", + "import cv2\n", + "import easyocr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import json\n", + "\n", + "# --- 1. CONFIGURATION ---\n", + "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "reader = easyocr.Reader(['en'], gpu=(torch.cuda.is_available() or torch.backends.mps.is_available())) \n", + "\n", + "# Inference uses clean transforms\n", + "data_transforms = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# --- 2. LOAD MODEL ---\n", + "class PieRegressor(nn.Module):\n", + " def __init__(self):\n", + " super(PieRegressor, self).__init__()\n", + " self.backbone = models.resnet18(weights=None)\n", + " num_ftrs = self.backbone.fc.in_features\n", + " self.backbone.fc = nn.Linear(num_ftrs, 10)\n", + " self.sigmoid = nn.Sigmoid()\n", + "\n", + " def forward(self, x):\n", + " x = self.backbone(x)\n", + " return self.sigmoid(x)\n", + "\n", + "model = PieRegressor().to(device)\n", + "model.load_state_dict(torch.load(\"pie_regressor_real.pth\", map_location=device))\n", + "model.eval()\n", + "\n", + "# --- 3. INFERENCE PIPELINE ---\n", + "def extract_pie_chart_data(image_path):\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " input_tensor = data_transforms(img_pil).unsqueeze(0).to(device)\n", + " \n", + " with torch.no_grad():\n", + " preds = model(input_tensor).squeeze().cpu().numpy() * 100.0\n", + " \n", + " cv_img = cv2.imread(image_path)\n", + " h, w, _ = cv_img.shape\n", + " gray = cv2.cvtColor(cv_img, cv2.COLOR_BGR2GRAY)\n", + " all_text_results = reader.readtext(gray, mag_ratio=2.5)\n", + " \n", + " title = \"Untitled\"\n", + " raw_legend_names = [] \n", + " \n", + " for bbox, text, conf in all_text_results:\n", + " clean_text = text.strip()\n", + " if not clean_text: continue\n", + " \n", + " x_center = (bbox[0][0] + bbox[2][0]) / 2\n", + " y_center = (bbox[0][1] + bbox[2][1]) / 2\n", + " y_pct = y_center / h\n", + " \n", + " if y_pct < 0.15:\n", + " title = clean_text\n", + " elif y_pct >= 0.15:\n", + " if len(clean_text) > 2 and not clean_text.replace('.', '', 1).isdigit():\n", + " if clean_text.lower() == \"grav\": clean_text = \"Gray\"\n", + " raw_legend_names.append((y_pct, clean_text)) \n", + " \n", + " legend_names = [item[1] for item in sorted(raw_legend_names, key=lambda i: i[0])]\n", + " \n", + " num_slices = len(legend_names)\n", + " if num_slices == 0:\n", + " valid_preds = [v for v in preds if v > 1.5]\n", + " num_slices = len(valid_preds)\n", + " \n", + " num_slices = min(num_slices, 10) \n", + " \n", + " # ⚡ CRITICAL FIX: Sort Predictions from Largest to Smallest to match Legend Order\n", + " slice_preds = sorted(preds[:num_slices], reverse=True)\n", + " \n", + " total_pred = sum(slice_preds)\n", + " if total_pred > 0:\n", + " normalized_preds = [(v / total_pred) * 100.0 for v in slice_preds]\n", + " else:\n", + " normalized_preds = slice_preds\n", + " \n", + " final_slices = {}\n", + " for i in range(num_slices):\n", + " slice_name = legend_names[i] if i < len(legend_names) else f\"Category_{i+1}\"\n", + " slice_value = round(normalized_preds[i], 2) if i < len(normalized_preds) else 0.0\n", + " final_slices[slice_name] = slice_value\n", + "\n", + " return {\n", + " \"title\": title,\n", + " \"data\": final_slices\n", + " }\n", + "\n", + "# --- 4. EXECUTION ---\n", + "test_img_path = './Real_Test_Graph/PieChart.png' # Make sure this points to your real test image!\n", + "\n", + "try:\n", + " result_json = extract_pie_chart_data(test_img_path)\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(Image.open(test_img_path))\n", + " plt.title(\"Analyzed Pie Chart\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " print(\"\\n✅ FINAL JSON DICTIONARY:\\n\")\n", + " print(json.dumps(result_json, indent=4))\n", + " \n", + "except Exception as e:\n", + " print(f\"Error testing pie chart: {e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "97c9b3ef-b152-4116-9065-51c2ade1165d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up STEM Sight AI Models...\n", + "\n", + "🚀 Analyzing: ./../FigureQA_Dataset/no_annot_test1/png/17.png\n", + "----------------------------------------\n", + "📊 Top Prediction: VBAR_CATEGORICAL\n", + " Confidence Scores:\n", + " - dot_line: 0.00%\n", + " - hbar_categorical: 0.00%\n", + " - line: 0.00%\n", + " - pie: 0.00%\n", + " - vbar_categorical: 100.00%\n", + "\n", + "📈 FINAL EXTRACTED DATA:\n", + " xaxis label: 41.47\n", + " xaxis label: 63.99\n", + " xaxis label: 43.79\n", + " xaxis label: 54.23\n", + " xaxis label: 65.46\n", + " xaxis label: 82.69\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import torchvision.transforms as transforms\n", + "from torchvision import models\n", + "from PIL import Image\n", + "from ultralytics import YOLO\n", + "import easyocr\n", + "import warnings\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "import os\n", + "import re\n", + "import torch.nn.functional as F\n", + "\n", + "# Suppress annoying Mac/MPS warnings to keep the terminal clean\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# ==========================================\n", + "# 1. LOAD ALL AI MODELS\n", + "# ==========================================\n", + "print(\"🧠 Booting up STEM Sight AI Models...\")\n", + "\n", + "# A. Chart Classifier\n", + "classifier = models.resnet18() \n", + "classifier.fc = torch.nn.Linear(classifier.fc.in_features, 5) \n", + "classifier.load_state_dict(torch.load('graph_classifier_real.pth', map_location='cpu'))\n", + "classifier.eval()\n", + "\n", + "# 🚨 FIXED CLASS NAMES: Now matching PyTorch's default alphabetical sorting 🚨\n", + "CLASS_NAMES = ['dot_line', 'hbar_categorical', 'line', 'pie', 'vbar_categorical'] \n", + "\n", + "transform = transforms.Compose([\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "# B. YOLO Bar Detector\n", + "yolo_model = YOLO(\"./Bar_Model_Final/weights/best.pt\") # Update path if needed\n", + "\n", + "# C. OCR Text Reader\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "# Helper function to safely extract numbers (handles floats, negatives, and ignores text)\n", + "def extract_number(text_str):\n", + " matches = re.findall(r'-?\\d+\\.?\\d*', text_str.replace(',', ''))\n", + " if matches:\n", + " return float(matches[0])\n", + " \n", + " text_clean = text_str.strip().upper()\n", + " if text_clean == 'O': return 0.0\n", + " if text_clean == 'S': return 5.0\n", + " if text_clean in ['I', 'L']: return 1.0\n", + " return None\n", + "\n", + "# ==========================================\n", + "# 2. THE EXTRACTION ENGINE\n", + "# ==========================================\n", + "def extract_full_chart_data(image_path):\n", + " print(f\"\\n🚀 Analyzing: {image_path}\")\n", + " print(\"-\" * 40)\n", + " \n", + " # --- STEP 1: Classify Chart Type ---\n", + " img_pil = Image.open(image_path).convert('RGB')\n", + " img_tensor = transform(img_pil).unsqueeze(0)\n", + " with torch.no_grad():\n", + " outputs = classifier(img_tensor)\n", + " probabilities = F.softmax(outputs, dim=1)[0]\n", + " _, predicted = torch.max(outputs, 1)\n", + " chart_type = CLASS_NAMES[predicted.item()]\n", + " \n", + " print(f\"📊 Top Prediction: {chart_type.upper()}\")\n", + " print(\" Confidence Scores:\")\n", + " for i, prob in enumerate(probabilities):\n", + " print(f\" - {CLASS_NAMES[i]}: {prob.item() * 100:.2f}%\")\n", + "\n", + " # --- STEP 2: Detect Bars (YOLO) ---\n", + " results = yolo_model(image_path, conf=0.8, iou=0.4, imgsz=1024, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + " \n", + " if len(boxes) == 0:\n", + " print(\"❌ No bars detected.\")\n", + " return\n", + " \n", + " # --- STEP 3: Read Text & Numbers (OCR) with Upscaling ---\n", + " img_cv = cv2.imread(image_path)\n", + " img_upscaled = cv2.resize(img_cv, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)\n", + " \n", + " ocr_results = ocr_reader.readtext(img_upscaled)\n", + " numbers = []\n", + " text_labels = []\n", + " \n", + " for (bbox, text, prob) in ocr_results:\n", + " cx = ((bbox[0][0] + bbox[1][0]) / 2) / 2.0\n", + " cy = ((bbox[0][1] + bbox[2][1]) / 2) / 2.0\n", + " \n", + " val = extract_number(text)\n", + " if val is not None:\n", + " numbers.append({'val': val, 'x': cx, 'y': cy})\n", + " else:\n", + " text_labels.append({'text': text, 'x': cx, 'y': cy})\n", + "\n", + " # --- STEP 4: Process based on Chart Type ---\n", + " final_data = []\n", + " \n", + " if 'hbar' in chart_type.lower():\n", + " lowest_bar_bottom = boxes[:, 3].max()\n", + " axis_nums = sorted([n for n in numbers if n['y'] > lowest_bar_bottom - 20], key=lambda d: d['x'])\n", + " \n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = (axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['x'] - axis_nums[0]['x'])\n", + " zero_x_pixel = axis_nums[0]['x'] - (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " units_per_pixel = 1.0\n", + " zero_x_pixel = boxes[:, 0].min() \n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[1]) \n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cy = (y1 + y2) / 2\n", + " if (x2 - x1) < 10 or (y2 - y1) < 5: continue \n", + " \n", + " possible_labels = [l for l in text_labels if l['x'] < x1]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['y'] - bar_cy))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = (x2 - zero_x_pixel) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " elif 'vbar' in chart_type.lower():\n", + " leftmost_bar_edge = boxes[:, 0].min()\n", + " axis_nums = sorted([n for n in numbers if n['x'] < leftmost_bar_edge + 20], key=lambda d: d['y'], reverse=True)\n", + " \n", + " if len(axis_nums) >= 2:\n", + " units_per_pixel = abs((axis_nums[-1]['val'] - axis_nums[0]['val']) / (axis_nums[-1]['y'] - axis_nums[0]['y']))\n", + " zero_y_pixel = axis_nums[0]['y'] + (axis_nums[0]['val'] / units_per_pixel)\n", + " else:\n", + " units_per_pixel = 1.0\n", + " zero_y_pixel = boxes[:, 3].max() \n", + "\n", + " sorted_boxes = sorted(boxes, key=lambda b: b[0]) \n", + " \n", + " for box in sorted_boxes:\n", + " x1, y1, x2, y2 = box\n", + " bar_cx = (x1 + x2) / 2\n", + " if (x2 - x1) < 5 or (y2 - y1) < 10: continue \n", + " \n", + " possible_labels = [l for l in text_labels if l['y'] > y2]\n", + " if possible_labels:\n", + " best_label = min(possible_labels, key=lambda l: abs(l['x'] - bar_cx))\n", + " label_text = best_label['text']\n", + " else:\n", + " label_text = \"Unknown Category\"\n", + " \n", + " real_val = (zero_y_pixel - y1) * units_per_pixel\n", + " final_data.append((label_text, round(real_val, 2)))\n", + "\n", + " else:\n", + " print(\"⚠️ Not a bar chart.\")\n", + " return\n", + "\n", + " # --- FINAL OUTPUT TEXT ---\n", + " print(\"\\n📈 FINAL EXTRACTED DATA:\")\n", + " for label, value in final_data:\n", + " print(f\" {label}: {value}\")\n", + " \n", + " # --- DISPLAY THE GRAPH WITH YOLO BOXES ---\n", + " annotated_img = results[0].plot() \n", + " annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + " \n", + " plt.figure(figsize=(12, 8))\n", + " plt.imshow(annotated_img_rgb)\n", + " file_name = os.path.basename(image_path)\n", + " plt.title(f\"STEM Sight Extraction: {file_name} ({chart_type.upper()})\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " return final_data\n", + "\n", + "# ==========================================\n", + "# 3. RUN THE ENGINE\n", + "# ==========================================\n", + "if __name__ == \"__main__\":\n", + " my_image = \"./../FigureQA_Dataset/no_annot_test1/png/17.png\" \n", + " extracted_results = extract_full_chart_data(my_image)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb41ed2c-e923-4804-a036-a5a41d253a00", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tfenv", + "language": "python", + "name": "tfenv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/STEM_Sight_Dot_Line.ipynb b/notebooks/STEM_Sight_Dot_Line.ipynb new file mode 100644 index 0000000..6d3ae8a --- /dev/null +++ b/notebooks/STEM_Sight_Dot_Line.ipynb @@ -0,0 +1,7433 @@ +{ + "cells": [ + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "iSNssWeUfeeC" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!unzip -q \"/content/drive/MyDrive/PlotQA-Stemsight/dot_line_data.zip\" -d /content/dataset_line\n", + "print(\"✅ Step 1: Unzip Complete!\")" + ], + "metadata": { + "id": "oaCl6rOYgnk7", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "993d6ef7-f7bc-44fa-e6d4-8d5644124fc2" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "✅ Step 1: Unzip Complete!\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import os\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "\n", + "# Paths\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "\n", + "# Load Model & Processor\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path)\n", + "\n", + "# Device Setup\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model.to(device)\n", + "model.config.tie_word_embeddings = False\n", + "print(f\"✅ Step 2: Model Loaded on {device.upper()}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 105, + "referenced_widgets": [ + "ef3577a4382c4c6d8d57bf08505774b6", + "74dbd4a5067749f096423e0f728da6ce", + "590469c1a20f484fbbe61f3b9018819c", + "696a822fd0734e2f88099712cff1636a", + "108ab43cb44a496f8ce8931c98f1d3d1", + "b4a40e0c280e498fb097810011f6a3c3", + "2b7630a46f234f709b478251b1de79c9", + "ef361ad22fc748e49e73ebb16ecc92b7", + "b0af1e1928c540b1ac703b72602d88be", + "cfa3db3d388e4512a3168776eb0db972", + "93f1c5f1726b471bb9b8fa2c45c2fb53" + ] + }, + "id": "qZ7_SXlvf5h0", + "outputId": "ac2b5c76-1583-4e0f-bde8-a26878819406" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [2000/2000 1:14:54, Epoch 0/1]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining LossValidation Loss
2000.0013970.001853
4000.0038800.002081
6000.0027580.001412
8000.0060640.001450
10000.0030060.001051
12000.0018360.000793
14000.0033810.000908
16000.0019470.000778
18000.0020900.000767
20000.0020180.000751

" + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📉 Step 10: Training Loss = 0.0006\n", + "📉 Step 20: Training Loss = 0.0006\n", + "📉 Step 30: Training Loss = 0.0013\n", + "📉 Step 40: Training Loss = 0.0020\n", + "📉 Step 50: Training Loss = 0.0050\n", + "📉 Step 60: Training Loss = 0.0026\n", + "📉 Step 70: Training Loss = 0.0033\n", + "📉 Step 80: Training Loss = 0.0018\n", + "📉 Step 90: Training Loss = 0.0018\n", + "📉 Step 100: Training Loss = 0.0025\n", + "📉 Step 110: Training Loss = 0.0021\n", + "📉 Step 120: Training Loss = 0.0008\n", + "📉 Step 130: Training Loss = 0.0027\n", + "📉 Step 140: Training Loss = 0.0025\n", + "📉 Step 150: Training Loss = 0.0043\n", + "📉 Step 160: Training Loss = 0.0023\n", + "📉 Step 170: Training Loss = 0.0037\n", + "📉 Step 180: Training Loss = 0.0007\n", + "📉 Step 190: Training Loss = 0.0013\n", + "📉 Step 200: Training Loss = 0.0014\n", + "🌟 Step 200: VALIDATION LOSS = 0.0019\n", + "📉 Step 210: Training Loss = 0.0016\n", + "📉 Step 220: Training Loss = 0.0010\n", + "📉 Step 230: Training Loss = 0.0018\n", + "📉 Step 240: Training Loss = 0.0015\n", + "📉 Step 250: Training Loss = 0.0043\n", + "📉 Step 260: Training Loss = 0.0040\n", + "📉 Step 270: Training Loss = 0.0031\n", + "📉 Step 280: Training Loss = 0.0037\n", + "📉 Step 290: Training Loss = 0.0035\n", + "📉 Step 300: Training Loss = 0.0026\n", + "📉 Step 310: Training Loss = 0.0037\n", + "📉 Step 320: Training Loss = 0.0021\n", + "📉 Step 330: Training Loss = 0.0046\n", + "📉 Step 340: Training Loss = 0.0051\n", + "📉 Step 350: Training Loss = 0.0044\n", + "📉 Step 360: Training Loss = 0.0037\n", + "📉 Step 370: Training Loss = 0.0037\n", + "📉 Step 380: Training Loss = 0.0026\n", + "📉 Step 390: Training Loss = 0.0027\n", + "📉 Step 400: Training Loss = 0.0039\n", + "🌟 Step 400: VALIDATION LOSS = 0.0021\n", + "📉 Step 410: Training Loss = 0.0024\n", + "📉 Step 420: Training Loss = 0.0024\n", + "📉 Step 430: Training Loss = 0.0029\n", + "📉 Step 440: Training Loss = 0.0053\n", + "📉 Step 450: Training Loss = 0.0032\n", + "📉 Step 460: Training Loss = 0.0026\n", + "📉 Step 470: Training Loss = 0.0024\n", + "📉 Step 480: Training Loss = 0.0026\n", + "📉 Step 490: Training Loss = 0.0011\n", + "📉 Step 500: Training Loss = 0.0013\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Writing model shards: 0%| | 0/1 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 31.png to 31.png\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "The following generation flags are not valid and may be ignored: ['early_stopping']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "🔍 Processing: 31.png...\n", + "✨ Model Prediction:\n", + "{\"gt_parse\": \"This is a dot line titled 'Employment to population ratio of the male population of Belize for different age-groups'. The x-axis shows Year and the y-axis shows Employment to population ratio(%).\"}\n", + "--------------------------------------------------\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "\n", + "print(\"upload the dot line chart here:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " print(f\"\\n Processing: {filename}...\")\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"Model Prediction:\")\n", + " print(prediction)\n" + ], + "metadata": { + "id": "7RFipwXYMJjU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"📊 Upload the dot line chart here:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded Image: {filename}\")\n", + " plt.show()\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " print(f\"Processing: {filename}...\")\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction:\")\n", + " print(prediction)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 568 + }, + "id": "5aPZIZgHMV4Y", + "outputId": "b291653a-984c-455e-b8b8-d62041361b81" + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📊 Upload the dot line chart here:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 7.png to 7.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "

" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Processing: 7.png...\n", + "\n", + "✨ Model Prediction:\n", + "{\"gt_parse\": \"This is a dot line titled 'Total resource balance of Thailand in different curriences'. The x-axis shows Year and the y-axis shows Balance.\"}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"📊 Upload the dot line chart here:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded Image: {filename}\")\n", + " plt.show()\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " print(f\"Processing: {filename}...\")\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction:\")\n", + " print(prediction)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 610 + }, + "id": "CzSSuxO5Mne7", + "outputId": "37f284c5-416d-4a20-ef9e-0e5adf907606" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📊 Upload the dot line chart here:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 80.png to 80.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Processing: 80.png...\n", + "\n", + "✨ Model Prediction:\n", + "{\"gt_parse\": \"This is a dot line titled 'Source data assessment of statistical capacity'. The x-axis shows Years and the y-axis shows Rating of statistical capacity (0-100).\"}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"📊 Upload the dot line chart here:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded Image: {filename}\")\n", + " plt.show()\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " print(f\"Processing: {filename}...\")\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction:\")\n", + " print(prediction)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 553 + }, + "id": "VW_edImyMvs-", + "outputId": "4fbe28f7-937b-4c56-cdf8-7f5c643fd2e5" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📊 Upload the dot line chart here:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 389.png to 389.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Processing: 389.png...\n", + "\n", + "✨ Model Prediction:\n", + "{\"gt_parse\": \"This is a dot line titled 'Amount spent on the transport and travel items of international tourists visited in Madagascar'. The x-axis shows Year and the y-axis shows Amount spent (in US$).\"}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"📊 Upload the dot line chart here:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded Image: {filename}\")\n", + " plt.show()\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " print(f\"Processing: {filename}...\")\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction:\")\n", + " print(prediction)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 549 + }, + "id": "bQPZ2-iWNU0j", + "outputId": "3271938a-9919-44b7-a286-474007c9336e" + }, + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📊 Upload the dot line chart here:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 786.png to 786.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Processing: 786.png...\n", + "\n", + "✨ Model Prediction:\n", + "{\"gt_parse\": \"This is a dot line titled 'PPP conversion factor for GDP and private consumption in children and Barbuda'. The x-axis shows Year and the y-axis shows PPP conversion factor (LCU per international $).\"}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"📊 Upload the dot line chart here:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded Image: {filename}\")\n", + " plt.show()\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " print(f\"Processing: {filename}...\")\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction:\")\n", + " print(prediction)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 610 + }, + "id": "t4oAaOLlNcqz", + "outputId": "0b894a68-0584-4b46-e655-d2ba221354f7" + }, + "execution_count": 25, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📊 Upload the dot line chart here:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 1222.png to 1222.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Processing: 1222.png...\n", + "\n", + "✨ Model Prediction:\n", + "{\"gt_parse\": \"This is a dot line titled 'Number of out-of-school female children of primary school age in a country'. The x-axis shows Years and the y-axis shows Number of children.\"}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"📊 Upload the dot line chart here:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded Image: {filename}\")\n", + " plt.show()\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " print(f\"Processing: {filename}...\")\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction:\")\n", + " print(prediction)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 546 + }, + "id": "ZE2ugy4tNlac", + "outputId": "65b94cba-cc14-4379-85b8-3e423f8187a6" + }, + "execution_count": 26, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📊 Upload the dot line chart here:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 1577.png to 1577.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAFrCAYAAABBpjj/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXoJJREFUeJzt3Xl4XGd5N/7vmX1GM6NtJI0WS9ZmyfK+JbYTx1sSZ48DKRTaQCgFWgKUvsBboJTl17SUlkB4AwTKEmgTQhInwSELSex4iZd4kSzJsnZZ+zqSRprR7Oec5/eHq6kUO4ljzWiUzPdzXbqsOXrOnHvOMyPdflZJCCFARERERElDk+gAiIiIiGh+MQEkIiIiSjJMAImIiIiSDBNAIiIioiTDBJCIiIgoyTABJCIiIkoyTACJiIiIkgwTQCIiIqIkwwSQiIiIKMkwASRaoO69914sXrw4IddevHgx7r333pg9X1dXFyRJwm9+85uYPScREV05JoBEc/Dtb38bkiRhdHT0kj9fvnw5tm3bNr9BvYcdPHgQkiRhz549iQ4lIf7lX/4Fd9xxB3JyciBJEr797W9fstz0++7NXyaTaVa53/zmN5csN/312GOPRcsuXrz4LcuVl5fH82UTUQLoEh0AERFd8I1vfANOpxNr1qzByy+//I7lH374YVit1uhjrVY76+fXXXcd/vu///ui8374wx+irq4OO3fujB578MEHMTU1Natcd3c3vvGNb+DGG298ty+FiBY4JoBERAtEZ2cnFi9ejNHRUWRlZb1j+bvvvhsOh+Mtf15SUoKSkpJZxwKBAD772c9ix44dcDqd0eO7d+++6Pz7778fAPAXf/EXl/kKiOi9gl3ARPNouovziSeewNe//nU4nU6kpKTgjjvuQG9v7zue7/P58KUvfQmLFi2C0WhERUUFvv/970MIMavcI488gh07diA7OxtGoxFVVVV4+OGHL3o+IQTuv/9+FBQUwGKxYPv27Th37twlrz0xMYEvfvGL0WuXlZXhe9/7HlRVvajcvffei9TUVKSlpeHjH/84JiYmLv8mvcl0d2drayv+8i//EqmpqcjKysI//dM/QQiB3t5e3HnnnbDb7XA6nXjggQdmnR8Oh/HNb34T69atQ2pqKlJSUrBlyxYcOHDgomuNjY3hnnvugd1uj8ZeV1d3yfGLzc3NuPvuu5GRkQGTyYT169fjueeeu+g5Ozo60NHRcVmv9d2O+RRCwOPxXFT/b+ePf/wjvF7vZSV1v/vd71BcXIzNmze/Y1lJkvC5z30Ojz32GCoqKmAymbBu3TocPnx4Vrnp+mxvb8e9996LtLQ0pKam4hOf+AT8fv+ssoFAAF/4whfgcDhgs9lwxx13oL+//227x4no8rAFkCgB/uVf/gWSJOEf/uEfMDIyggcffBDXX389amtrYTabL3mOEAJ33HEHDhw4gE9+8pNYvXo1Xn75ZXzlK19Bf38/fvjDH0bLPvzww1i2bBnuuOMO6HQ6/PGPf8RnP/tZqKqK++67L1rum9/8Ju6//37ccsstuOWWW1BTU4Mbb7wR4XB41rX9fj+2bt2K/v5+fOYzn0FhYSGOHTuGr33taxgcHMSDDz4YjfHOO+/EkSNH8Dd/8zdYunQpnn32WXz84x+f8z378Ic/jKVLl+Lf/u3f8MILL+D+++9HRkYGfv7zn2PHjh343ve+h8ceewxf/vKXsWHDBlx33XUAAI/Hg1/+8pf4yEc+gk996lPwer341a9+hV27duHkyZNYvXo1AEBVVdx+++04efIk/vZv/xaVlZXYu3fvJWM/d+4crrnmGuTn5+OrX/0qUlJS8OSTT2L37t14+umncdddd0XLTnezdnV1zfkevFlJSQmmpqaQkpKC3bt344EHHkBOTs7bnvPYY4/BbDbjAx/4wNuWO3PmDJqamvCP//iPlx3PoUOH8MQTT+ALX/gCjEYjfvrTn+Kmm27CyZMnsXz58lllP/ShD6G4uBjf/e53UVNTg1/+8pfIzs7G9773vWiZe++9F08++STuuecebNy4EYcOHcKtt9562fEQ0dsQRHTFvvWtbwkAwuVyXfLny5YtE1u3bo0+PnDggAAg8vPzhcfjiR5/8sknBQDxox/9KHrs4x//uCgqKoo+/sMf/iAAiPvvv3/WNe6++24hSZJob2+PHvP7/RfFsmvXLlFSUhJ9PDIyIgwGg7j11luFqqrR41//+tcFAPHxj388euyf//mfRUpKimhtbZ31nF/96leFVqsVPT09s2L893//92gZWZbFli1bBADxyCOPXPI+vfn+PPXUU9Fj0/f405/+9KznLCgoEJIkiX/7t3+LHne73cJsNs+KXZZlEQqFZl3H7XaLnJwc8Vd/9VfRY08//bQAIB588MHoMUVRxI4dOy6KfefOnWLFihUiGAxGj6mqKjZv3izKy8tnXauoqGhWPV4Ol8slAIhvfetbl/z5gw8+KD73uc+Jxx57TOzZs0f83d/9ndDpdKK8vFxMTk6+5fOOjY0Jg8EgPvShD71jDF/60pcEANHY2HhZMQMQAMTp06ejx7q7u4XJZBJ33XVX9Nh0fc6890IIcdddd4nMzMzo4+rqagFAfPGLX5xV7t57733be0NEl4ddwEQJ8LGPfQw2my36+O6770Zubi5efPHFtzznxRdfhFarxRe+8IVZx7/0pS9BCIGXXnopemxmK+Lk5CRGR0exdetWnD9/HpOTkwCAffv2IRwO4/Of/zwkSYqW/+IXv3jRtZ966ils2bIF6enpGB0djX5df/31UBQl2s334osvQqfT4W//9m+j52q1Wnz+85+/zDvz1v76r/961nOuX78eQgh88pOfjB5PS0tDRUUFzp8/P6uswWAAcKGVb3x8HLIsY/369aipqYmW+9Of/gS9Xo9PfepT0WMajWZWiykAjI+P47XXXsOHPvQheL3e6L0YGxvDrl270NbWhv7+/mj5rq6umLf+/d3f/R0eeughfPSjH8UHP/hBPPjgg/jtb3+LtrY2/PSnP33L8/bs2YNwOPyO3b+qquL3v/891qxZg6VLl152XJs2bcK6deuijwsLC3HnnXfi5ZdfhqIos8r+zd/8zazHW7ZswdjYGDweD4AL9QEAn/3sZ2eVi8V7iYg4BpAo7mYmV9PevKyGJEkoKyt720Shu7sbeXl5sxJHANE/0N3d3dFjR48exfXXX4+UlBSkpaUhKysLX//61wEgmgBOl39zLFlZWUhPT591rK2tDX/605+QlZU16+v6668HAIyMjESfMzc3d9bMVACoqKh4y9d1uQoLC2c9Tk1NhclkumgSRGpqKtxu96xjv/3tb7Fy5UqYTCZkZmYiKysLL7zwQvRezIzdYrHMOresrGzW4/b2dggh8E//9E8X3Y9vfetbAP73fsynj370o3A6ndi3b99blnnssceQkZGBm2+++W2f69ChQ+jv73/Xkz8utVzMkiVL4Pf74XK5Zh1/c31Ov+em6667uxsajQbFxcWzyr25PojoynAMINEcTK+7FggELvlzv99/0dps8dbR0YGdO3eisrISP/jBD7Bo0SIYDAa8+OKL+OEPf3jRpI3LoaoqbrjhBvzf//t/L/nzJUuWzDXsd/TmJU7e6hiAWZMiHn30Udx7773YvXs3vvKVryA7OxtarRbf/e53L3tyxkzT9+/LX/4ydu3adckyiUpSFi1ahPHx8Uv+rKenB6+//jo+/elPQ6/Xv+3zPPbYY9BoNPjIRz4SjzABXF7dEVH8MAEkmoOioiIAQEtLCxYtWjTrZ36/H729vZdcQ62trW3WYyEE2tvbsXLlyre91r59++D1eme1AjY3N8+K5Y9//CNCoRCee+65Wa0sb571Ol2+ra1t1lIhLpfroha00tJSTE1NRVv83i7G/fv3Y2pqalYrYEtLy9ueF0979uxBSUkJnnnmmVmtsdOtddOKiopw4MAB+P3+Wa2A7e3ts8pN3yu9Xv+O92M+CSHQ1dWFNWvWXPLnjz/+OIQQ79iqFwqF8PTTT2Pbtm3Iy8t7VzG8+X0NAK2trbBYLJe1rM1MRUVFUFUVnZ2ds1oW31wfRHRl2AVMNAc7d+6EwWDAww8/fFHL2n/+539CluVLdrf913/9F7xeb/Txnj17MDg4+LZdc7fccgsURcGPf/zjWcd/+MMfQpKk6LnTLSszW1ImJyfxyCOPzDrv+uuvh16vx0MPPTSr7PSM3pk+9KEP4fjx45dcnHhiYgKyLEdjlGV51pIziqLgoYceesvXFW+Xuh8nTpzA8ePHZ5XbtWsXIpEIfvGLX0SPqaqKn/zkJ7PKZWdnY9u2bfj5z3+OwcHBi6735q7Od7MMzOV68zWACzO/XS4Xbrrppkue87vf/Q6FhYW49tpr3/a5X3zxRUxMTLxtotjc3Iyenp6Ljh8/fnzWuMre3l7s3bsXN95441u2+L2V6dbVN49pTOR7iej9hC2ARHOQnZ2Nb37zm/jGN76B6667DnfccQcsFguOHTuGxx9/HDfeeCNuv/32i87LyMjAtddei0984hMYHh7Ggw8+iLKyslkTEN7s9ttvx/bt2/GP//iP6OrqwqpVq/DKK69g7969+OIXv4jS0lIAwI033giDwYDbb78dn/nMZzA1NYVf/OIXyM7OnpWwZGVl4ctf/jK++93v4rbbbsMtt9yCM2fO4KWXXrpoXN1XvvIVPPfcc7jttttw7733Yt26dfD5fDh79iz27NmDrq4uOBwO3H777bjmmmvw1a9+FV1dXaiqqsIzzzwza6zdfLvtttvwzDPP4K677sKtt96Kzs5O/OxnP0NVVdWsnS92796Nq666Cl/60pfQ3t6OyspKPPfcc9Eu1Zmthz/5yU9w7bXXYsWKFfjUpz6FkpISDA8P4/jx4+jr60NdXV207LtZBua///u/0d3dHV0P7/Dhw9HFmO+5555oq21RURE+/OEPY8WKFTCZTDhy5Ah+//vfY/Xq1fjMZz5z0fM2NDSgvr4eX/3qVy85JnWmxx57DEajER/84AffsszSpUuxdetWHDx4cNbx5cuXY9euXbOWgQGA73znO+/42t9s3bp10QkuY2Nj0WVgWltbAVx6bC0RvQsJmn1M9L7y6KOPio0bN4qUlBRhNBpFZWWl+M53vjNrmRAh/neZk8cff1x87WtfE9nZ2cJsNotbb71VdHd3zyr75mVghBDC6/WKv//7vxd5eXlCr9eL8vJy8R//8R+zlnERQojnnntOrFy5UphMJrF48WLxve99T/z6178WAERnZ2e0nKIo4jvf+Y7Izc0VZrNZbNu2TTQ0NIiioqJZS6lMX/trX/uaKCsrEwaDQTgcDrF582bx/e9/X4TD4Wi5sbExcc899wi73S5SU1PFPffcI86cOTPnZWDevNTOxz/+cZGSknLRc2zdulUsW7Ys+lhVVfGv//qvoqioSBiNRrFmzRrx/PPPX/L+ulwu8dGPflTYbDaRmpoq7r33XnH06FEBQPz+97+fVbajo0N87GMfE06nU+j1epGfny9uu+02sWfPnlnl3s0yMFu3bo0up/LmrwMHDkTL/fVf/7WoqqoSNptN6PV6UVZWJv7hH/5h1tJCM331q18VAER9ff3bXn9yclKYTCbxgQ984G3LAZi1vNH0sfvuu088+uijory8PHqvZ8YtxFvX5yOPPHLR+9Pn84n77rtPZGRkCKvVKnbv3i1aWloEgFnL/xDRuycJwRG3RPPl4MGD2L59O5566incfffdiQ6HLsMf/vAH3HXXXThy5AiuueaaRIezYEmShPvuu++iIQqxVltbizVr1uDRRx/lFnVEc8AxgERE/+PNs7mnxy/a7XasXbs2QVElr0vNrn/wwQeh0WiiO70Q0ZXhGEAiov/x+c9/HoFAAJs2bUIoFMIzzzyDY8eO4V//9V/fcos+ip9///d/R3V1NbZv3w6dToeXXnoJL730Ej796U9fNOueiN4dJoBERP9jx44deOCBB/D8888jGAyirKwMDz30ED73uc8lOrSktHnzZrz66qv453/+Z0xNTaGwsBDf/va339X+xER0aRwDSERERJRkOAaQiIiIKMkwASQiIiJKMkwAiYiIiJIME0AiIiKiJMMEkIiIiCjJMAEkIiIiSjJMAImIiIiSDBPASxBCwOPxYHJyEoqiQAgBv9+PiYkJRCKRi8qrqopgMAhVVWcd9/v92L9/P6ampuYr9LgSQqCzsxMvvvgijh49ClmWAVx4/TU1NXjppZdw7tw5vNulJYUQqKmpQUtLyxXF1dvbiyeffBJNTU3w+XzYv38/fD7fReW8Xi+effZZHD58eFaMfX19OHr0KCYmJrB3714cPXoUkUgEJ06cQHd3d7R+p98L1dXVaGtre9ev882EEHC73Xj55Zexb98+TE5Ozun5Ek0IEb1P70RRFNTU1ODFF1/E2bNn53wvr8RbfW6JiJIBE8BLUFUVhw8fxuc//3kcPXoUQgi0trbiV7/6FSYmJi4qPz4+jv/4j/9AV1fXrOMejwevvPIK3G73/AQeZ5FIBA8//DDGx8dht9ujf7QHBgbwox/9CJmZmdBoNFf0x/z48eM4e/bsFcWVlpaGQ4cOoaGhAW63G6+++uolkymLxYKOjg689tprs46fP38eBw8ehNFoREdHBw4ePIhwOIwjR46gtbUV4+Pj+MEPfoDz589DVVW88cYbaGhouKJYZxJC4LnnnsOxY8eQl5d3WYnTQjY1NYXvf//7aG5ufseyLpcLDz30EFJTU6HRJObXUHd3Nx544AG4XK6EXJ+IKJG4FdwlaLVaVFZWQqfT4T//8z+RlZWF8vJytLe3IzMzE2fOnEFjYyN0Oh127tyJ+vp6VFdXIz09HX/2Z3+GnJwcCCHQ09MDu92OUCiEp59+Gn19fSgvL8fAwADuuOMOpKam4sCBA3C73bDb7aisrMTLL7+MgoIC5Ofn4/Dhw9i9ezcaGxvR3NyMyspK9Pf3Q6/Xw+PxoKysDG63Gxs2bEB1dTUAYOPGjdBqtdizZw8KCwsRDAaRm5uLHTt2oLe3F4cOHYLdbkd+fj6WL1+OgwcPYnx8HNnZ2di6dSsMBgOA/23Va21thUajwbXXXgu3243u7m7Y7XZs2bIFOt2Ft8/JkycxPj6OxsZG3H777di3bx/GxsZgNBqxfft2nDhxAo2NjaioqMDIyAh27tyJU6dOIRgMory8HCUlJYhEItBqtVAUBa+//jrOnz8Pm82Gnp4erFy5Ek1NTXA6nQiHw8jMzMQNN9wQvb5Op4NWq43e87S0NEQiEXR0dKC+vh5+vx9LlizBunXroNfr4Xa78fjjj0Ov1+OGG27A4OAg7HY7VFWNPufo6CgkSQIANDQ04PTp07DZbNi6dSsikQgkSYIQAqdOnUJbWxtMJhNuuOEGjI6O4ujRo7BarSgoKMC6deuiSfHw8DAOHToERVFQXFyM4uJi1NbWIhQKwe/3Iy0tDcCFRHvfvn1wuVzQaDQYGRnBhz/8YYyNjUUTz6uvvhrt7e2oq6vDrl27EAwG0d/fj+XLl+PUqVPROuvr68Phw4exYsUK9PX1ITMzE11dXVi6dCn6+vpw3XXXwWaz4emnn4bD4UAkEkFGRgZSU1PR3NyM2267DZmZmTh48CBGR0fhcDhw7bXX4qWXXsLAwADKysowMDCA22+/Hd3d3aiurobJZILdbo/u1RoMBnHo0CGMj4/DZDJh+/btOHXqFCYmJtDS0oIPfvCD0ftZU1OD3t5eeL1ebNq0CaWlpdF68Hq9eOWVV6AoCmw2G7Zt24b29vbofxyuuuoqqKqK559/Hlu3bsXg4CB6enrw53/+53j++efh8XhQUlKC4eFh3HnnnaiurkZ1dTXy8/OxYcMGvPzyy3A6nQAuJKjhcBi33XYbBgYGIITAtm3bou8PIqL3OrYAvgWNRoM777wTTqcTDz30EIaGhgBc+MPwwx/+EIsWLUJXVxeefPJJlJeXw2Kx4LrrrkN2dnb0OYqLi1FXVwev1wuHw4GDBw8iNzcX586dw+HDh3HixAk8+uij2Lx5M/Lz86HVauHxeNDY2IisrCxUV1fD6/Vi0aJFeO2116DRaLBs2TI4HA68/vrrsNlsKCgowMMPPwyfzwej0Yif/exnyMzMRGdnJ7q7u5GTk4Pf/e53GBoawk9+8hNMTU1hx44d8Hq9OHLkCJ566imsX78eTz75JGprawEgmkj94Ac/wNKlS+H1evHjH/8Y+fn5SE1NxerVq1FYWBj9w7xs2TIYDAbs2LEDtbW1+P3vf4/t27fj2LFjeOaZZ5CXl4cjR45AlmUsXboUzzzzDE6ePImqqio8/PDDCAQCCAQCaGtrQ09PD37xi19g8eLFcLlcaG9vx7JlyzAwMICOjg4sXrwYjz76KEZHRy+qM0mSsGjRIjQ0NGBychJ6vR4FBQVQFAUPP/xwtCteVVWsWrUKe/fuxYkTJ5Ceno66urpolzYAOBwOjI+Po7OzE+Xl5UhJScHmzZuxYsUKTE1Noa2tDb29vfjJT36CkpIS1NfXY+/evdi7dy/Onz+PioqKWbEpioKf//znGBkZwerVq/GjH/0IExMTKCgoQFFREVatWhVNgpqamvDII4+gqqoKXV1d6O/vhxACP/rRj6Lvk//3//4fCgsLUVdXh3A4DCEEFi9ejB//+MfQ6XRQFAW/+tWvkJOTgzNnzmBwcBBr165Ffn4+Tp48Ca1Wi6mpKTz55JNIT0+Hy+VCc3MzcnNz8etf/xparRYtLS3Yv38/Tpw4gccffxzr16/H008/jdraWqSmpuL48eMoKChAXV0dDh06FP0cbN68GQUFBdH30pEjR/DEE09g+/bteP311/GHP/wBFRUVMJvNuPbaa2G326P3yWw2o6ioCAMDA3jkkUeiQy6EEHj++eexb98+3HDDDTCbzRgYGMADDzyA/Px8mEwm/OAHP4DNZkNraysGBweRnp6O48ePQ1VVWCwWvPHGGygqKsKxY8dQXV2NyspKWCwWbNu2DWVlZRgbG0N1dTVWr16NxYsX4/Tp0wgGg9DpdFi2bBm0Wu1cf60QES0YTADfRkZGBj73uc8hGAziZz/7GQKBAMbGxjA5OYmamhoYjUYYDIZo1910QiSEgCRJ0ceSJMFoNMJsNsPpdMJiscDj8aC7uxtGoxGpqalYuXLlrKRqmiRJSElJgcFgQGVlJTZv3oysrCxYLBZUVlZi9erVcLvd6OzsjLbQRCIR6HQ6ZGVlRR+Pjo5iaGgIOTk50Zas/v5+TE1N4Y033kBhYSECgUD0ui6XC5OTk8jMzERaWhoGBwfh9/ujr2tmnDNfZ3d3NyRJQnp6OqxWK7q7u2EwGGAymVBRUYGrr74abrcbY2NjqK+vR1FRUfR5gQstb5FIBLm5uXA6ndBoNDCZTNDpdMjOzobD4UAwGLzkWMyZsQDA0aNH8eyzz8JqtcLv9yMUCgEA0tPTUVJSAr1ej8HBwYvu+ZufZ+brm/nvyMgIJiYmUFNTA5vNBlVVsWnTJkxMTOC73/0umpqaot3hsiyjs7MTaWlpSE1NRTgcjl77zfd0+h4UFRXB4XBAp9NhYmICbrcb6enp0YTNarWioqICBw4cwMDAADIzMzE0NITW1lZ4vV5YrVYYDAZotVpUVVVh3bp1KCgogF6vR25uLtLS0jA1NQWtVguDwYCcnBwUFBRAp9MhPz8fNpsNU1NT6Onpgc/nw/Hjx6OtykajESaTCQUFBTCbzfB4PJe8d8CFrlaNRoOMjAxYrVZ0dXVBUZSLXnckEsELL7yAI0eOIDU1FR6PZ1Y9d3Z2IiUlBampqdiyZQtCoRA8Hg9SU1ORmZmJ/v5+BAKBS36GpuMtLCyE0WiEx+OZdX29Xg+DwYCCggIsXboUN910E8rLy6PDCRwOxyXfJ0RE71VMAC9BCIFQKIRwOIzCwkLcd9996OrqwuTkJLKzs5GdnY3i4mJ84AMfwJIlS2CxWKDVajE8PBwd/ySEQCQSgRAC4XB41veqqkKWZZSXl0OWZQwODuLo0aPo7++Hw+HA1NQUBgYGoudNdzlO/zGcfq5IJIKUlBQUFxfD4XBg9+7dWLVqFUwmExRFgaIo0bJmsxklJSXo6enB0NAQ9u/fj9LSUlgsFlx99dXYtWtXtMsOAPLy8uB0OtHb2wuXy4WysjKYTCaoqhp9DdPC4TAAIBQKoaKiAhqNBn19ffB4PKiqqoqWm45/6dKlSElJwc6dO3HdddchIyMDsixDlmU4nU6kpKSgubkZnZ2dABB9LdOvZ/qaM5MrVVURiUSixyORCAYGBmC1WpGSkgJFURAKhSDLMiYmJtDd3Q0hBIqLixGJRKKvS5ZlKIqCcDgMRVEgyzK0Wi10Oh1GR0dRX18fLeN0OpGVlYUlS5Zg9+7dqKiogNvtxn333YeNGzeitbU1GqNer8fy5cvhcrkwNDQEq9WKRYsWRV/3zNbH/Px8WCwW1NXVob+/HwDgdDqRm5uLgYEBDA0NYfHixXA4HLjuuutQXV0Ng8GAzMxMFBcXIzs7G3fddRdWr14dbVWUZXnWezISiVz0Wqe/f/P7dPp9smHDBtx0000oLCycdc+m62U60RobG5s1nrOyshKSJEW7dquqqiCEiJ4/fY8URcHAwACysrKiwwFm3pdly5ZFPxv79u2D2WxGTk4OhoeHMTAwgCVLliAtLQ0ZGRlwu93RltPpz9DM1xWJRKDX66NxtbW1QVEUqKoKRVGiwxeOHTuGzMxM6PX6K/+FQkS0AEkiEdPvFjhFUXDkyBH4fD5s27YNJpMJJ06cgEajwYYNG9DZ2YmmpibY7XasWLECNpsNr7/+OgKBANatWxftBj579izq6+uRn58PIQQGBwdRVlaGnp4eGAwGbN26Fe3t7RgZGUFeXh6WL18Ot9uNY8eOISsrC729vdEuv/b2dhQXF2PDhg04fvw4+vv7UV5ejg0bNmB0dBSnT5+GwWBARUUFtFotDhw4AJvNhrS0NHR3d2PFihXIz8/HqVOnYDQasXz5cqSnp6OmpgZjY2NwOp1Yvnx5dAygEAIdHR1obW2FTqfDunXrMDk5iePHj0eTN5vNBuDCBI729nYUFhbiqquuQmNjI4aGhmC327F27Vo0NTWhubkZ+fn52Lp1K4LBIE6cOBFNsHNycrBv3z5IkoQdO3ags7MTfX196OvrQ2trK774xS/i9OnTMJvNSEtLQ1dXF6qqqrB27VpIkoSenh4cPXoUNpsNDocjeq8WLVqEmpoaZGVlobu7G8XFxejv74fRaIx+rVu3DsePH8fIyAgqKirQ09MDRVFQVVWFhoaGaCJQW1uLqakpFBcXo6GhAZIk4YYbbsDw8DDa2tqQnp6OFStWoKenB/39/ZBlGcuXL4+26gohMDk5idOnTyMUCqG0tBTZ2dk4cOAAFEXBxo0bUVhYCOBCojw9rrKurg5+vx/3338/ent7ce7cOWg0GqxZswbZ2dnweDzYv38/rr32WmRlZWFoaAjV1dVISUlBZWUl3G539B5s2bIFLS0tOHfuHIqKijAxMQGfz4dly5ahubkZBoMB6enp6OnpweLFizE8PAyNRhN9n7pcLuTk5GDp0qU4ceIEBgcHUVlZiba2NhgMBtx4442or6/H2NgY1qxZE+0GjkQiqKurw/DwcPQ90djYiJaWFuTn5+O6666LjuE8d+4curq6YLPZMDAwgM2bN6OoqAjAhbGEp0+fxtTUFBYvXozy8nL09fVF78nq1auRk5OD9vZ2NDU1weFwoLOzEytXrkRvby/cbjeqqqrQ1NQUbUU8fvw4AKCsrAynT5+GVqvFli1bkJWVFZ3883/+z/+Bw+GY199BRETxxgSQFhSfz4dnn30WGzduxJ49e5CTk4OPfexjSTX+amxsDK+88grWrVuH//qv/8L69etx5513sgtyHrW1tWF8fBwulwu33HJLwmYqExHFCxNAWlAURUF7ezsmJiZgsViwZMkSGI3GRIc1ryKRCNra2uD1emG321FWVgadTscEcB6Nj4/j/PnzKC8vR2pqaqLDISKKOSaAREREREmG/RpERERESYarml7C0NBQdJIAERER0UI2vQrDuxmvzATwEo4cOYL169fPWhYl1qaX0WCSmXyml19h3Scf1n3y8vv9MJvNHMubhPx+P0wmU1wnk4VCISiKwgRwrqYXqY3nzNPpdfSSaXYrXaCqKoQQrPskNL3+Ies++Wg0Gmi1WiaASWi67uOZAF7Jc89bAriQ55rwA0lERETJZN4SwO7ubgwODiISiWDt2rV49dVXYTQasW3bNjQ2NmJqagpLlizB1NQUBgcHkZOTg7S0NDQ3N0cXta2uro4uxlxdXQ1ZlrFq1aroLh2lpaUIh8Po6+uDw+FAdnY2zp07B5PJhOXLl6O6uhoAsGHDBtTW1iIcDmPlypXIyMiYr9tARERElHDzlgBmZ2cjLy8Pzz//PCKRCDIyMqDT6aJbNl111VWora1FMBjEli1bcOTIEZhMJqxYsQI1NTUIBAJIT0+H1+vFmTNnEAgEUFRUhNraWkxMTOCaa67BqVOnIMsyNm/ejCNHjkS3h2poaEBtbW10S7AzZ87A4/GgsrISjY2NuPbaayGEQDAYnLUN3MztzmJtukU0nteghUkIEe0KpOTCz33ymv7cL+TeMIqP+fidfyXvq3lLAE0mE9rb27F06VKYzWZs2LABzc3NOH/+PABE9/4UQkCj0UT35Jzu145EItHxE+FwGBqNBhqNJrpX6PT3qqpCo9FE9z+deY7FYonuBypJ0qzzg8Egnn32Wbjd7mjrYnZ2NnS6+Nyi6deqKEpcnp8Wruk9Z5kEJB/WffKa3jOdQ46Sz3zUvSzL7zpfmbeFoDs6OnDo0CFkZWWhqqoK/f39CIfDWLZsGVpbW6GqKgoLC+HxeOD1epGSkoKMjAx0dXVBkiQsW7YMtbW1AC504Z4+fRoAsHz5crS3t0OWZeTm5iIcDmN8fBxmsxlOpxPt7e0AgNWrV0e7gNevX4+amhoAwNKlS5GXlzcr1ieeeAIbN26M7kEaD5FIBIqiwGQyxe0atDCx7pOXLMuIRCIwm82JDoXmmc/ng8ViYQKYhHw+H8xmc1wngQSDQWi1Wuj1+ss+Z94SQEVRIMsyJEmCTqebNdN2+n/EOp0u2io23XIny3K0tW+6tWxma6FOp7ui82ee8+YPJBNAiifWffJiApi8mAAmr4WaAM5bF7BWq5219MHMGzHzZ9Nds9NmvpiZzZszv7+S898cDxEREVGy4FZwREREREmGCSARERFRkmECSERERJRkmAASERERJRkmgERERERJhgngDMFgEMePH0dzc3OiQyEiIiKKGyaAM0iSBIvFAqPRmOhQiIiIiOJm3tYBfC8wGo1YtWoVWwCJiIhoTlQlAl/vWXgGOyBnFcK2eC0k7cWbTyQKE0AiIiKiGBKKjOHjj2PkxJNQQlMY0RmRtfYO5G39a0j6hdHLyC5gIiIiohgRQsA/1IqRE09ACU1dOCaH4Kr+AzydpxMc3f9iAkhEREQUQ6GJASjhwKxjQokgMNKeoIguxgSQiIiIKIaMaXnQGsyzjklaPcxZxQmK6GJMAImIiIhiRJIkmJ3lyL76Q9AYLAAkSDojMlfdDHvJ1YkOL4qTQIiIiIhiSKPVI2fjR5CSV4WJngbYnKVILb0Kks6Q6NCimAASERERxZhGZ4C9ZAO0OVUwm83QaBZWpysTwBkikQg6OzsxMDCQ6FCIiIiI4mZhpaMJJssyent74XK5Eh0KERERUdywBXAGs9mMnTt3YnR0NNGhEBEREcUNWwCJiIiIkgwTQCIiIqIkwwSQiIiIKMkwASQiIiJKMkwAiYiIiJIME0AiIiKiJMMEkIiIiCjJcB3AGRRFgdvthsfjSXQoRERERHHDFsAZAoEADh48iIaGhkSHQkRERBQ3bAGcwWq14u6774aiKIkOhYiIiChu2AJIRERElGSYABIRERElGSaAREREREmGCSARERFRkmECSERERJRkmAASERERJRkmgERERERJhgngDH6/Hy+99BKqq6sTHQoRERFR3DABnEGv16OqqgqLFi1KdChEREREccMEcAa9Xo+ioiJkZ2cnOhQiIiKiuGECSERERJRkmAASERERJRkmgERERERJhgkgERERUZJhAkhERESUZHTzdaFIJIJAIACdTgez2Qy/3w9VVWG1WhEKhRAKhWC1WqGqKvx+PywWCzQaDXw+HwwGA4xGI6ampqDRaGCxWBAIBKAoClJSUhCJRBAMBmG1WiGEgM/ng9lshk6nw9TUFPR6PUwmE3w+HwAgJSUFwWAQkUgEVqsVGg3zYCIiIkoe85YAdnd3IxAIoKOjA1u2bMHJkyeh1+tRUVGBpqYmWCwWpKWlYXJyElqtFrIsIz09HW63Gz6fD8uWLUNTUxMURcGaNWtQU1MDo9GIkpIStLe3w2KxwGKxIBQKQQiBUCgEp9OJ4eFh+P1+rFy5Eg0NDRBCYNWqVThz5gzMZjOKiopQXFw8X7eBiIiIKOHmLQEsLS1FKBRCT08PXC4XbDYbsrKy0NjYiGAwiDVr1uDYsWOIRCLYuXMnXnvtNYyPj+Pqq6/GyZMn0djYiPz8fHg8Hpw9exZGoxGLFy9Gc3MzAoEA1qxZg9dffx2KomDHjh147bXX4PV6sWbNGtTX1+PcuXPIzs6GLMs4e/YsNBoNSktL0dbWhuLiYoTDYZw9exZ+vx/Nzc3IyMhAdnZ23FoHFUWBqqoIhUJxeX5auFj3yUtRFCiKwrpPQrIsIxwOJzoMSoDpupckKa7X0Gq17+qceUsAw+Ew6uvrsXz5cqiqinA4jGAwCLvdjmAwiGAwGO3aDYVC0Ov1sFgsCAaDEELAbrcjFAohHA4jLS0NY2NjCAaDsNlsCAaDCIVCMJlMkGUZoVAIOp0OVqsVwWAQiqIgMzMToVAIsiwjLS0NLpcrek0AkCQJWq0WOp0OGo0GGo0GkiTFtcKmr0vJiXWffKbrnHWfvFj3yWk+8ol3SxJCiPm4UGdnJ06fPg2r1YpNmzbh/PnziEQiWLlyJbq6ujAxMYGKigr4fD709fUhPz8fNpsNzc3NSE1NRXFxMc6ePQutVosVK1ZEWw5XrFiB/v5+jI2NoaysDJFIBN3d3XA6ncjIyEBjYyOsViuWLFmC+vp6SJKElStXorm5GT6fD8uXL4fNZpsV6xNPPIGNGzeiqKgobvcjEolAURSYTKa4XYMWJtZ98pJlGZFIBGazOdGh0Dzz+XywWCwLLgmg+JuelxDP+QbBYBBarRZ6vf6yz5m3BPC9hAkgxRPrPnkxAUxeTACT10JNADn9lYiIiCjJMAEkIiIiSjJMAImIiIiSDBNAIiIioiTDBJCIiIgoyTABJCIiIkoy87YQ9HtBJBJBT08PhoaGEh0KERERUdywBXCGSCSCjo4ODA4OJjoUIiIiori54hZAIQSEEAgGg5AkCUajcUFudfJuWCwW3HjjjXC73YkOhYiIiChurjgB9Pl8ePnllzE0NIRgMAiz2Yy1a9di7dq10Ov17+lEkIiIiOj97IoTQFmWcc011yAtLQ2yLGNqagotLS04cOAAtm/fDoPBEMs4iYiIiChG5jQJRKfTwWg0wmQywWq1IicnB0NDQ/D5fEwAiYiIiBaoK04Ax8bGcPjwYSxatAhZWVnRL6fTGcv4iIiIiCjGrngWcE5ODu68806sX78eZrMZHR0d2LdvH0KhEMf/ERERES1gV5wAGo1G2Gw2pKWlYcmSJbj22mvhcDjQ3d0dy/iIiIiIKMauOAEcGBjAwYMHMTg4iGAwCEVRoNVqMTU1Fcv4iIiIiCjGrngMoKqqOH/+PFpbW+Hz+aDT6RAIBPCJT3wilvHNK0VRMDk5ySSWiIiI3teuOAHMz8/HBz7wAVgsFgCA3++HwWCA3W6PWXDzLRAIYN++faitrcX111+f6HCIiIiI4uKKu4C9Xi8eeeQRDAwMwGKxRFsA38usVis+9KEP4dprr010KERERERxc8UJoMvlwi233IKysjIAgFarxZEjR+DxeGIWHBERERHF3pxmAWu1WgCAJEmw2WxYtWoVhoaGYhYcEREREcXeFSeAubm5aGhoQFtbG0KhEGRZhs/ngxAilvERERERUYxd8SQQo9GILVu2YO/evRgaGoLFYkF2djbuvvvuWMZHRERERDF2xQmgJEnIycnBX/3VX8Hr9SIQCCAlJQVmszmW8RERERFRjF1xFzBwIQnU6/XIyMiA3W7HwYMH0dfXF6vYiIiIiCgOrjgBdLvdGB0dhRACQghYrVYUFxcjGAzGMj4iIiIiirEr7gIeGxvDk08+iUWLFqGoqAi5ubmYmpp6T3cB+/1+HDlyBGfOnMHGjRsTHQ4RERFRXFxxC2BaWhruvPNOrFmzBh6PB4cPH8b+/fshy3Is45tXer0epaWlyM3NTXQoRERERHFzxS2AmZmZyMzMhCRJWLZsGYQQGBwchMFgiGV882o6AXQ6nYkOhYiIiChu5jQLeOb3kiQhLy8vJkERERERUfzMaRawEAIDAwNQVRVCCE4AISIiInoPuOIEUFEUnDt3Dvv374fb7Yaqqjhz5gwGBgZiGR8RERERxdgVdwEDQDAYRG9vL37/+99DCAFJkpCWlob8/PxYxUdEREREMXbFCaBWq8W6detQXl4OIQQikQhCoRAcDkcs4yMiIiKiGJtTC6AQAvv370d3dzcMBgO0Wi1uuOEGlJaWxio+IiIiIoqxOSeAZrMZn/zkJ6HRaOByuZCVlRWr2IiIiIgoDuY0C1ij0cDj8eC3v/0tTpw4AVmWodfrYxXbvAuFQqiurkZHR0eiQyEiIiKKmzklgABQVVWFW265BSaTCbW1tXC73bGIKyGEEFAUBYqiJDoUIiIioriZUxcwABQUFGBoaAhXXXUVtFrtrAWi32tMJhOuuuoqdHZ2JjoUIiIioriZ8xjAw4cPw+VyYWxsDHa7HWVlZbBYLLGKj4iIiIhibM47gVitVtx9990YGxuD1WpFf39/rGIjIiIiojiYUwugRqNBdnY2nnjiCbjdbvj9fqxbty5WsRERERFRHMy5C1gIgY0bN2JwcBBZWVkoKSmJVWxEREREFAdzSgBVVcW5c+dw8803Y+XKlQDwnp4EQkRERJQM5jQGUKvVwmaz4ejRo+jv70cwGISqqpcsO71dnKqqEEIgFAohGAxGl14Jh8MQQkBVVYTD4Wi5cDgMRVGi50ciEQghIMty9Pvp81VVjZ4/fU44HIYsy5c8f/qaRERERMlkzl3APp8POp0O+/fvh9/vx5133om8vLyLyoZCIbz00ktYs2YNsrOz8cILL8Bms2HLli04ffo0hBAoKCiAx+OBz+eDxWJBeno6enp6AADLli1DbW0tAGDDhg04deoUNBoNqqqq0N7eDlVVkZOTg3A4jImJCRiNRjidTpw/fx5CCKxatQo1NTUAgPXr16O6uhoajQaVlZWXjJeIiIjo/WrOXcDBYBA33XQTHA4HZFmGTnfppzQYDMjMzIQsy9BoNFi8eDF8Ph+GhoYwMTGBTZs24cSJEwiHw9i+fTsOHjyIwcFBrF+/HqdOnUJ9fT1yc3Ph8Xhw5swZaDQaFBUV4ezZs/D5fNiyZQuOHj0KRVGwbds2HDx4EOPj41ixYgXq6+tRV1cXjbG2thayLGPp0qVobW1FXl4eFEVBf38/IpEIhoeHMTIygry8vLh1aSuKAlVVIctyXJ6fFq7pxcZZ98mHn/vkNV3vHCaVfFRVjX7243kNrVb7rs6ZUwKo1WqRl5eH4eFhWK1WWCyWt3xzazQaaDQXepyFEFi6dCna2towODgI4MIvRp1OB1mWoaoqNBoNdDpddFcOg8EQ/cNpNBrh8/mgKAoMBkP0++nkU1EUSJIUPV8IMet8g8GAYDA46xxZltHS0gKPx4Ouri4UFBSgqqoqGnOsTb8Z+Msg+UzXfSQSSXQoNM9Y98lLURREIhH+zk9C81H3V7IVryTmMAhOCIGnnnoKLpcLqqrCYrHgtttuQ05OzkVlI5EIXnnlFWRmZqKyshJ1dXUAgFWrVqGjowNerxcVFRWYmprCwMAAnE4nUlNT0dzcDKvVioqKCtTU1ECj0WD9+vWoqalBJBLB6tWr0dXVhYmJCZSVlSEcDqO3txdZWVnIysrCuXPnYDabsXz5cpw+fRqSJGH9+vWoq6tDKBTCypUrkZGRMSvWJ554Ahs3bkRRUdGV3pp3FIlEoCgKTCZT3K5BCxPrPnlNj102m82JDoXm2fTQJiaAycfn88FsNsetQQkAgsEgtFrtu0oC55wA+v1+WCwWhMNhTE5Owm63v+UftktdSpKky5qIMbPcW31/JedPP56JCSDFE+s+eTEBTF5MAJPXQk0A57wXcEdHB/x+P/Ly8qDX6xEKhd7yD9tbvfEv9wMxs9xbfX8l5xMRERElkzmno2lpafB6vThw4AB+8pOfwOVyxSIuIiIiIoqTObcApqamYsOGDTCbzTh79mxcmziJiIiIaO7mnAC+9NJLcLlc0Gq18Pv9uO2222IRFxERERHFyZwTwJycHCxfvhxOpxNut5t7ARMREREtcHPqr1UUBcFgEHl5eUhNTUV3dzcmJiZiFBoRERERxcOcEkCNRhPt+hVCoLi4GMPDw7GKbd5NTU1hz549OHbsWKJDISIiIoqbOXUBazQarF69Gk8//TT8fj8MBgPuvvvuWMU278xmM7Zt2wa3253oUIiIiIjiZs5jALOysvDJT34SExMTMJvNsFqtsYgrIbRaLRwOB+x2e6JDISIiIoqbOSeAkiTBYDAgOzs7FvEQERERUZzFdNE+IcRlbctGRERERIkzpxZAIQQGBgbQ29uLzMxMmM1m2Gw2pKamxio+IiIiIoqxOSWAqqritddeQ3p6Orq7uzEyMoLbbruNCSARERHRAjbnWcD5+fkoKSmB0+mMLgtDRERERAvXnCeBDA0N4cyZMzCZTEhPT8eNN94Ih8MRi9iIiIiIKA6uOAFUVRWKouCWW26BzWZDIBDA6OgozGZzLOMjIiIiohi74gTQ5XKhvb0dU1NTcLvdKCoqgk6ng9lsRkpKSixjnDeBQADHjh1DXV0dNm7cmOhwiIiIiOLiipeBsdlsWLVqFbKzs7FmzRr4fD60tLQgEonEMr55pdPpsGjRImRlZSU6FCIiIqK4ueIWwHA4jJqaGqxevRqpqalYsmQJAEBRFMiyDJ1uzsML551er8eSJUtw5syZRIdCREREFDdXnKWlpqaipKQEe/fuhRACDocDVqsVXq8XmzdvZisaERER0QJ1xQmgJEkoKirCX/zFX2BgYACDg4OQJAnLli3jLGAiIiKiBWxO/bTT+wAvXrwYixcvjlFIRERERBRPMd0LmIiIiIgWvjklgEIIjI2Nob6+HqFQCKqqQggRq9iIiIiIKA7mvBfwkSNH4Ha7MTExAbvdjvLy8vfsOoBEREREyWDOXcBWqxW7d++G2+1Gamoq+vv7YxEXEREREcXJnBJAjUYDp9OJ3/3ud2hoaMCRI0cgSVKsYpt3oVAIdXV16OzsTHQoRERERHEz59WaCwoKcP3116O/vx+ZmZkoLi6ORVwJIYSA3+9HKBRKdChEREREcTPnSSAHDhxAKBTCpk2bEAwGoapqrGKbdyaTCZs2bUJlZWWiQyEiIiKKmzklgKqqwmazoaKiAkajESkpKejr64tVbEREREQUB3PqAtZqtUhNTcWTTz6J0tJSjI2Noby8PFaxEREREVEczHknkDVr1sBiseDcuXNwOBzcEYSIiIhogZvzGMBTp07h+PHj0Ov1UFUVo6OjsYqNiIjoPW/2BgncLIEWhjkvBN3d3Y1t27bB5/Oht7cXOt2cJxYTEb2vCCGgRoIIuLqgQgujsxgarT7RYdE8EEJFaKwX3r4myPZMWAuWQ2swJzosorklgBqNBjabDefPn8eyZcuwZMkSGAyGWMVGRPSeJ4RAeHII/ft+Cm9PLSStDulLdyDvuk9Aa7ImOjyKIyEEJluOoG//wwh7hi/UfcVWFNz4BejMtkSHR0luzjuBaLVaBAIBvPLKK3jkkUcwNDQUi7iIiN4XhCJj4NCvMNF2BErQC9nnxmjNXrhq9kKI9+6yWfTOIp4R9B/6JcKTg4BQIeQw3E2vYaz+pUSHRjT3haArKirQ1dWF7du3Q5IkmM3v3aZtWZYxNDTEcYxEFDOy3w1fXwMwYxyYUGV4u6qRtf4D7A58HwtPDiE8ObtRRKgK/EOtEEK8p3fOove+Oa8DWF9fD7fbjRMnTqC5uRlTU1Oxim3ehcNhbgVHRDGl0Rmh0RkvOq41pkDSaBMQEc0XnTUTOkvaRcdNmYvmPxiiN5lzF7DFYolOAsnOzsbg4GAs4koIi8WCW2+9FRs2bEh0KET0PqE12+BYdyekGZM+tGY7HGt3zzpG7z/G9Dw4N/8FtMaU/zkiwVa8Do41d7D1jxJuzpNAiouL8dvf/hajo6MYHBzErl27YhUbEdH7gISsNXdAZ7JjvPkgJK0e2et2w7poJZOA9z0JjtW3wZRZiPH2U7Bk5CKtYgt05tREB0Y092VgBgYGcPPNNyMYDCI1NRWFhYWxio2I6D1PkiRAq0PG8uthW7IFsqLAbLYkOiyaB5IkAZIWtqI10DiWwGKxMOmnBWPOk0BGR0exZs0apKSk8I1NRPQ2JI0WUDjzl4gSb05jADUaDVRVxVNPPYXa2loMDw9DluVYxUZEREREcTDnSSDZ2dlYvnw5+vv78eKLL2JkZCQWcRERERFRnMypC1hRFPT39+Oaa67B+vXr37asEALDw8Ow2+0wm81wuVyQZRlOpxMejwderxc5OTmQZRmjo6PIzMyEwWDA0NAQrFYrUlNTMTQ0BK1Wi+zsbIyOjiIcDsPpdGJqagqTk5PIycmBqqpwuVzIyMiAyWTC0NAQLBYL0tLSMDw8DEmSkJOTg/HxcQQCATidTm5fR0REREllzrOAHQ4HrFZrdFHLtxoHGAwGceTIEaxevRqZmZmorq5GSkoKvF4v2trakJ+fj8HBQXi9XmRnZ6O1tRVpaWmQJAn19fUoLy/HwMAAQqEQlixZgsbGRqSlpWFychKdnZ0oKChAf38/QqEQMjMz0dTUhJycHEQiEQwPD6OyshLd3d1QVRV+vx+NjY3IysqCx+NBVVXVXG4DERER0XvKnBJASZIwNDSEhx9+GIWFhVi0aBHWrl0Lm+3iPQ7NZjOcTicAYGxsDDabDVlZWejs7ISiKFi0aBGOHDkCWZaxbt06tLS0wOfzYdOmTRgcHMT58+dRWFgIj8eDtrY2mM1m5OXloampCeFwGIsWLcKhQ4egKApWrVqF1tZWhMNhrFu3DqOjo+jo6IDT6YQsy2hvb4der0d+fj5aWlpQVVWFYDCIV199FZOTkzhx4gSEEMjIyIBWG5+FWhVFubBBvMoB4clGURSoqsq6T0KqqkY/+5RcwuEwJ0omqXA4DABxrX9Zlt/1Tmxz7vvcunUr7HY73G43BgcH33ISiKqqCIfDCIfDcDgcOH/+PCYmJuB0OtHT04Px8XFkZmZiamoKbrcbFosFdrsd4+PjEEIgNzcXk5OT8Pv9KCgoQHd3N9xuN3JyctDf34/x8XGkpaUhHA7D7XbDZDIhMzMT4+PjUBQFBQUFmJiYgKIoyM/PR2dnJ8bHx5GRkQEA0Ov1uPrqqyHLMqamprB06VKYzea4VZgsy1BVFQaDIS7PTwuXLMtQFAVG48W7Q9D7myzL0Gg0rPskpCgKDAYDk8AkNP37fqHV/ZwTwN7eXoyMjKCgoAA2mw2RSOSS5VRVRUZGBvR6PRwOB0pLSxGJRFBaWoqsrCxMTExg7dq1CIVCGBgYwNVXXw2z2YzOzk6sWbMGOTk5OH/+PLKyslBcXAyz2YxgMIjS0lLk5eVhbGwMGzZsgCzL6Ovrw1VXXQWbzYaOjg6sXLkSeXl5OH/+PCRJQklJCaxWK3w+HyoqKgAgOrYQANLT05GWlhbXsYGqqkIIEbcWRlq4WPfJa7rVn3WffDQaDbRa7YJLAij+NBpN9Cue13i3JDGHvgghBNxuN/r6+tDd3Y2amhrcc889KCkpudKnXBCeeOIJbNy4EUVFRXG7RiQSgaIoMJlMcbsGLUys++QlyzIikci77qqh9z6fz8eFoJOUz+eD2WyOawIYDAah1Wqh11/+9pJzbuIKBAJIT09HeXk5Fi1axHUAid6CEAJCVRB0dUKRwzDklkPSsUuIiIjm35wTwBMnTmBiYgI+nw+BQAB/9md/Fou4iN5XhBBQgl70v/YwJlqOQAgV9qK1KNj1BRhsWYkOj4iIksycE8C1a9fCbDZHx/9dagYwUdITAsNvPIGx+pcBcWH270TrEWiMFhTe/CVodJwMRERE82dOHdKqqqKurg5erxdarRa1tbUIBoOxio3ofUMoEXjOn4wmf/9zFFPdZ6AEpxIWFxERJac5j0hMSUlBXl4eDAYD8vPz0dfXF4u4iN5fNBpoTdaLDmtNNkha7kRDRETza847geTl5eE3v/lNdEu2a665JlaxEb1vSBodcq76MwRHuyD73AAArTEF2VfdDa2JwyaIiGh+zXknkMrKSqSmpqK9vR1lZWUoLCyMVWzzLhAI4MSJEzh79iw2btyY6HDofUSSJNhLN6L4zn+Cq/YFqIoMx8obkVpyNWcBExHRvJtTAqiqKl599VU0NzfDZrNFd+9YvHhxjMKbX1qtFjk5OUhLS0t0KPQ+JGk0sC1eC1P+CiiyDBPXgiMiogSZUwIohEAgEMBHPvIRyLKMgYEBpKamxiq2eWcwGLB06VLU19fH9ToX1oOTIRQZQiy87WFoHrDOiYgogeY8BlAIgVdffRUrVqxAUVERl4F5B0Ko8A80w1X7AiI+N9JKr0LGil3QGtgaRERERPNjztMPnU4ntFoturq6cOrUKdx8883Iy8uLRWzvO0II+Adb0PXcvyDk7gcATHWeRGRqDM5rPw4NZ4MSERHRPLjijMPr9WJ8fBxlZWXQarVYu3YtZFlmd+bbESrG6l+OJn8AIBQZo7XPI3PVrTCmORMYHBERESWLOTU5BYNBHD9+HG63G4qiQFVV3HzzzSgvL49VfO8rQqiQ/RMXH5cjUCNcQJuIiIjmxxUngDabDUuWLEFeXh7MZjN8Ph+8Xi8yMjJiGd/7iqTRIbV8Ezwdb8xK+MzOchjs3A+WiIiI5sec1wGcnvSRmpr6np4BPB8kSUJ65VZEvKNw1eyFGg7C4ixDwY1/B43BkujwiIiIKEnMeRkYRVGg1Wo59u8yafQm5Gz8c9grt0MOTiHFUQCN3sz7R0RERPPmivcCFkJAVVWcOXMGqqpCCIGOjg4Eg+/dsWzhcBgNDQ3o7u6O63UkjRZ6WxYMGYXQGixM/oiIiGheXXELoKIo+OMf/4gzZ87A5XKhqKgILpcL4XAYS5cujWWM80ZRFLjdbvh8vkSHQkRERBQ3V5wAarVa3HDDDUhLS4PRaERTUxO8Xi8qKipiGd+8MpvN2LJlCwYGBhIdChEREVHcXHECKEkSUlJSYDKZUFNTg927dyMlJQV2uz2W8RERERFRjF3xGEDgQpep1+vFzp07UVNTg/b2dgwPD8cqNiIiIiKKgzklgBqNBlqtFpFIBMFgEBaLBWNjY7GKjYiIiIji4IoTwOmdPzZs2ICamhrU1NTgwIEDcDq5nRkRERHRQnbFYwAHBgYwODiIqqoq/OVf/iWCwSD0ej30en0s4yMiIiKiGLviBFAIAZfLhaNHjyIcDsNgMCAlJQXLly9HWlpaDEMkIiIioli64gQwPz8feXl5kCQJ7e3teOKJJ6DRaFBWVhbL+IiIiIgoxq44AdRoNHC5XHj55Zdx/vx57Ny5E+vXr4fRaIxlfPPK6/Vi7969OHr0KDZu3JjocIiIiIji4ooTwMHBQTzwwAOoqKjApz/9aeTk5ECWZciy/J4dB5iSkoK77roLiqIkOhQiIiKiuJnTGMCbb74ZJpMJtbW1CIfDCIVCWLt27Xu2G1ij0UQXtyYiIiJ6v7riBDAvLw+5ubmQJAnAhWVhWltbmTwRERERLXBz2gpuOvkDAJ1Oh8rKypgERURERETxc8UJ4KVoNHPaWISIiIiI5gEzNiIiIqIkwwSQiIiIKMkwASQiIiJKMkwAiYiIiJIME8AZfD4fnnvuOZw8eTLRoRARERHFTUxnAb/XGY1GbNiwAf39/YkOhYiIiChu2AI4g06nQ25uLjIyMhIdChEREVHcMAEkIiIiSjJMAImIiIiSDBNAIiIioiTDBJCIiIgoyTABJCIiIkoyCVkGRlVVuFwuCCGQlZWFUCiEYDAIu90OVVUxNTUFq9UKrVaLyclJmEwmmM1meDweSJIEm80Gn88HWZZht9sRCoUQCARgt9shhIDX60VKSgp0Oh08Hg8MBgMsFstF50ciEaSmpkKjYR5MREREySMhCWAgEMDhw4fhcDhgtVpx5MgR2O12WK1WTE5Owmg0IhgMIj09HR6PB16vF1VVVWhtbYUsy1i1ahXOnDkDs9mMoqIitLe3w263w2AwIBQKQavVwufzwel0YnR0FF6vFytXrkRjYyOEEFixYgVqa2thtVqRn5+P0tLSRNwGIiIiooRISAKo1+uxYsUKDA0NoaurC6FQCOXl5Th27BgikQh27tyJ1157DRMTE7j66qtx6tQpNDU1YdGiRZicnERDQwNMJhOKiorQ0tKCYDCI9evX49ChQ1BVFTt27MBrr70Gn8+HtWvXoq6uDo2NjcjOzoaiKDh37hy0Wi2Ki4vR1taG0tJShMNhnD59Gj6fD/X19bDZbMjKyoJWq43LPZBlGaqqQpKkuDw/LVys++SlKAoURUEoFEp0KDTPZFlGKBTi5z4JybKMcDgc17qPRCLvOl9JSAIYCoXgcDgwNTWFqakpAIDf74fVaoXf70cwGITBYEBKSgoCgQBUVUV6ejr8fj9CoRAyMzPhcrng9/uRmpqKUCgEv98Pi8UCWZYRCASg1+ths9ng9/uhKAqysrIQDAYhyzIyMjIwNDQUvSYASJKEtLQ0mEwm2Gy2aBd0vCpsutuZvwySj0ajgRCCdZ+EJEmKflFykSSJw42S1Hx87q/kvSUJIUQcYnlbPp8PjY2N0Gg0qKqqQl9fH9xuN5YsWQK/34++vj7k5+fDarWipaUFqampKCoqwrlz56DT6VBVVYXm5mYEg0EsW7YMg4ODGBsbQ2lpKWRZRnd3N5xOJ9LT09HU1ASbzYbS0lI0NDRAkiQsX74cra2t8Pv9qKqqQkpKyqz4nnjiCWzcuBFFRUVxuweRSASKosBkMsXtGrQwse6TlyzLiEQiMJvNiQ6F5pnP54PFYmHyn4R8Ph/MZnNc/wMQDAah1Wqh1+sv+5yEJIALHRNAiifWffJiApi8mAAmr4WaALI9moiIiCjJMAEkIiIiSjJMAImIiIiSDBNAIiIioiTDBJCIiIgoyTABJCIiIkoyTABnCIfDaGpqQm9vb6JDISIiIoobJoAzKIqC4eFhTExMJDoUIiIiorhJyFZwC5XZbMa2bdswPDyc6FCIiIiI4oYtgERERERJhgkgERERUZJhAkhERESUZJgAEhERESUZJoBERERESYYJIBEREVGSYQJIRERElGSYAM4wNTWF3/3udzh06FCiQyEiIiKKGy4EPYPFYsHtt9+OcDic6FCIiIiI4oYtgDNoNBrYbDaYzeZEh0JEREQUN0wAiYiIiJIME0AiIiKiJMMEkIhoHgghIFQFgIAQItHhEFGS4yQQIqI4U1UZ412HMNL+EqAxYtGKP4c1exkkif8HJ6LEYAJIRBRHQqgYatyDple+BDk0CQAYbf0DVt75CNLyr0pwdESUrPjfTyKiOJJDHnSdeDCa/AFAYLIb3ad+ClXhklNElBhMAImI4kgOeRAJTl50POQbZgJIRAnDBHAGv9+PF154AadOnUp0KPQ+dWEigAyhRjgRIEkYU3Jgz1kJQPrfg5IW6QWboNVbEhYXESU3jgGcwWAwYNWqVejq6kp0KPQ+JFQFY10H0H/2cShKGHlVH0T2ktug0fBj+H4maQ0o3/ptyCEvJgerAY0W2eW3onD933ISCBElDP/yzKDT6VBQUACHw5HoUOh9RggBV8fLaHjhs4gERgEA452vojL4b8hf9TEmAu9jkiQhxVGJVR94FJODdRAaAzLzVkNrSEl0aESUxPhXh2geCDWMrpMPRZM/AFDCU+g+/TAiAXcCI6P5IEkSDOYMpBdugS1nLZM/Iko4JoBE80AIgUhg/KLjkaAbQo0kICIiIkpmTACJ5oFGo0dW6Y2QJO2MoxIyF++AzpSWqLCIiChJcQwg0TyQNFosvvqLCAfGMdzyHCBUOEquR9mWf4RWZ0p0eERElGSYABLNE4MlE0tv+D4KN3wBshxGamYJx4IREVFCMAEkmkdavRnmtBIoigKtgS1/RESUGBwDSERERJRkmADOEAwGcfz4cTQ3N8/D1S7sAsHdIIiIiGi+sQt4BkmSYLFYYDQa43YNIQTCfheG215G2OeCY/EWpOauhaTRvvPJRERERDHABHAGo9GIVatWxa0FUAiBoKcP5176HMa7D0GoCnpOpaPyhu8jt+pu7gZBRERE84IZx3wSKvrr/wtjXQcgVBnAhcWB2w//M8I+V6KjIyIioiTBBHAeCaHAO9IACHXW8UhgHGE/E0AiIiKaH0wA55Gk0SEtbwMkzeyed6MtD0arM0FRERERUbJhAjivJOSt/EvkLLkDGq0RkDQw2Rehcue/Qm/OTHRwRERElCQ4CWQeSZIEY0o2qm5+CM5lH0HQNwpH0SZY0ksgSVKiwyMiIqIkkZQJoBACXV1d8Pl8KCsrg8k0vzsy6E2pyCi+HoqizPu1iYho/kyv/jDeW41wej5Sc1ZC0hr4n/4koAoZ4/42DHmakKkWIztlOTSSbsHUfVJ2AU9OTqKxsRFCCDQ1NSUkBo/Hg7GxsYRcmxJramoKLhcn/SQjn8+HkZGRRIdB80QIgfGewzj9xJ048Nhf4dTv70TLwX+CKgcSHRrFmSoUNLmewZ86/g7PV/9/+FPb3+PM0K+gCjnRoUUlZQug3++HTqdDeno6Wlpaosf27NmDsbExdHR0oLm5GVarNW4xDA4OYmpqCuXl5XG7Bi1MIyMjcLvdqKioSHQoNM9GR0cxMjKCqqqqRIdC80Jg9Pw+BL0RnG01Y2lJOvT1ryD7DT305oxEB0dxpKgh9HqOIagE0FLrQ2mVBSeNe1CYOgyDNva5hc1mw5//+Z9Dr9df9jmSSMK9yKampnDw4EFkZmYiLS0NS5cuhRACiqJACAEhBFRVjes2bfX19XC5XNi5c2fcrkELU1NTE3p6erBr165Eh0LzrK2tDS0tLbjtttsSHQrNs5///Of42Mc+BrPZnOhQaJ798pe/xEc+8hGkpKTE7RoajQYGw7sbWpCULYApKSnYvHkzAoEAcnJyAFyYoKHTzd/tMBqNMBqN/GWQhIxGIwwGA+s+CbHuk5der4fJZGLdJyG9Xr8g/94nZQIoSRIyMhLb/F5QUACHw5HQGCgxcnNzYbPZEh0GJUBOTk5c9xqnhWvr1q0wGAyJDoMS4LrrrluQEz6TsguYiIiIKJklZQtgos3Muae/12iSckJ20lFVNTpGQ1VVaDSaBbMkAMUX6z45TY8rZ90nn+m612g00bkFC6numXUkQH9/P06ePAlVVTEyMhKdiUzvf2fPnkVHRwcAoLW1FcPDwwmOiOZLdXU1ent7AQANDQ0YHx9PcEQ0H1RVxeuvvw632w1FUVBbW4tAgMvAJANFUfDqq68iEAggGAzi1KlTiQ5pFrYAJkAoFML4+Djq6+uRm5sLn8+X6JBonkxOTmJqagrhcBgmkwkejwdOJ/eBTgaTk5OIRCIIBoPQ6/UIBoOJDonmgRACfr8fjY2NKCwshMFggM/ng8ViSXRoFGeqqsLj8aCurg5FRUUQQkCW5Xe1VEs8sQUwASwWC5xOJ9LT01FTU4O8vLxEh0TzJCMjA/n5+VBVFS0tLUz+kkhmZiYKCwvh8/nQ19eH9PT0RIdE80CSJKSlpWHJkiXo6enB5OQk6z5JaDQaZGZmoqysDA0NDbBYLPO62sg7YQKYAA6HA0IINDQ0ICUlhTNCk0hJSQn6+/vR1dWFzMzMBTkzjGJPCIGysjJ0dHSgv78fWVlZC6YVgOJLo9GgtLQUdXV18Hg8yM7O5pjvJKHValFcXIxTp05BVdUFt/IH34UJMDg4CEmSsHHjRhQVFaG5uTnRIdE8aWtrg9PpxKZNm2CxWNDT05PokGietLW1oaioCBs3boSiKBz/mSQURUF7ezuWLVuGDRs2wO12w+12JzosmgfhcBg9PT1Yt24dVq9ejba2NiiKkuiwohZOW2QSsVqtqKurQ19fH1RVxdKlSxMdEs2T1NRU1NfXQ5IkqKqKjRs3JjokmifTn3tJkiBJEkpLSxMdEs2D6R0aTp06BUmSYDabOf4vSWi1WiiKgjfeeANCCGRmZi6o1l8mgAmQlpaG5cuX4/z583A4HCgqKkp0SDRP8vPz4fP5MDg4iKKiogXXJUDxIUkSioqKEAgEMDo6ipKSEqSmpiY6LJoHkiShoqICiqIgEAigsrKSQz+ShFarxTXXXINgMAghBEwm04JZAgZgF3BCDA8Po6urCw6HA4FAAI2NjYkOieZJW1sbPB4PsrKyMDAwEF0WhN7fhBBobm5GIBCAw+HA+fPnMTIykuiwaB6oqoqzZ89Cq9UiLS0NTU1N8Hg8iQ6L5oGiKDh06BDa2trQ1NSE1157DQtp7w22ACaAJEmQZRmhUAiRSGTB7Q9I8SNJEsLhMLRaLSKRyILqDqD4mq57jUYDRVEWVEsAxV8oFIKiKLMWBKf3P6PRCJPJBJPJhOzs7ESHMwu3gksAVVXR09ODzs5OOJ1OlJWVcUZgkpBlGUNDQ/B4PEhJSYHT6eTesEkiEAigubk5uhd5QUEB/wOQBIQQmJqawuDgIFwuF4qKipCfn88kMAnMXPdv5o4wC6Xu2QKYAG63G3V1dXC5XJicnITJZEJxcXGiw6J54PF4YDabkZubi4aGBvh8PlRVVSU6LIozIQRaW1vR09MDRVHQ0dEBs9mMrKysRIdGcaYoCs6ePYv09HRMTEzA6/UiLS0NVqs10aFRnE2v95qVlYVwOIyRkRGsXbs20WFFMQFMAL/fj+LiYhQUFCAzMxMul4sJYJIwGo1obW1FU1MTVFXlgrBJZHrGf2NjIxwOB8LhcKJDonkgSRKMRiOGh4eRn58Pv9/Puk8SqqqiqakJfX19AICUlBSoqgqtVpvgyC5gF3AChMNhVFdXQ6PRoLKyEqFQaMGNDaD4EUIgHA6jo6MDWVlZbAVKAkIIjI+Po6GhAYWFhZiamkJlZSWHfiSB6S7gs2fPwuPxoLy8HCUlJQumG5DiRwiBUCh00TCfhVL3TAATZPq2L5Q3As0/vgeSy8xftazz5PLmP7Osf1oImAASERERJRlOQSMiIiJKMkwAiYiIiJIMZwETEc2REAIjIyMIh8PIzs6GLMtwu93IysriOo9EtCCxBZCIaI6EEGhoaMDPf/5zBINBdHV14Y033kAkEokuAHslX0RE8cIWQCKiOdJoNNi8eTOOHj2KoaEhuFwuXH/99Th9+jR8Ph9UVcWuXbvgcrlw7tw5dHd34/bbb8exY8fg9Xqh0+mQn58PRVEQDAZhtVqxZcsWzhYlorhhCyARUQyYTCasXr0af/zjH7FixQqcOHECqqqioqICHR0dGBkZwZ/+9CdcddVVMBqN0Ov1yMzMhMlkws033wyj0YimpiZcddVVWLRoEZM/IoorJoBERDGSmZmJ0tJS2O12NDQ0YHR0FIODg/jwhz+M9vZ2LF68GAaDAcFgEDabDaOjo1i5ciUyMjKwcuVKlJeX49e//jU8Hg8TQCKKK3YBExHN0czdXYqKiqDRaJCVlYXS0lIYjUZEIhEoioJQKISamhoEg0EIITA6Ogqn0wkhBI4dO4aqqiqEw2FEIpFEvyQiep/jQtBERHMkhMDExATq6+uRkZGBqqoqeL1etLW1ITU1FSUlJQiHw2hoaIDFYoHP58OKFSvQ09OD0tJS6HQ69Pb2YmRkBHa7HSUlJdDp+P9zIoofJoBERERESeay/4upKEo846A40Gg0HEdEREREF7nsBPCZZ55BQUFBPGOhGPL7/diwYQPsdnuiQyEiIqIF5rITQIfDgU2bNsUzFooRIQSam5s5kJyIiIguicvAEBERESUZJoBERERESYYJIBEREVGSYQJIRERElGTmNQGcXi1fCBFdFf9ylyEUQiASiVxWeSHEW5YTQiAUCiEQCCAYDF60vI0QAsFgEKqqXvH13yawC19vEVcwGHzLezIzrjnHQUREREktJgmgKhT0e07i7MjvMOZvfcvkZGxsDD/96U8RDAbhdrvx1FNPXfZMVVmW0dLSclFiNpMQAkrEj8Fzv0d/3W8Q9o9dFMv0lktPPvkkDh06hP379896znA4jD179sDtds9+jaqKpqamt73+28UV8U9gtO4FjDW8AiXkv+Tr27t3L44cOXLJ54hEInj22WcxPDyMlpYWyLL8ruMgIiIiAmK0F3DP5Ot4vedfEJTdSDcVY0fxd5FhLptVRgiB/v5+pKWloaOjA0uWLIFWq0U4HMbp06cRiUTg8XhwzTXXoLX1QhJZUVGBN954A2azGcFgEFqtFiUlJdElTiorK5GamjrjIiraD/8zuqt/DggVY92HsfzWn0KrM0eLTO/ROTExAafTicbGRvj9fjQ0NEAIgRUrVsBqtUJRFDQ1NWFkZAQTExMoKyvDyMgI0tLS0N3djeLiYnR3d8PhcKCtrQ16vR4OhwMulwubN2+etf6eGgmi79Ufw910AJJGi8BwO/J3fAaS5n9vv16vR2ZmJrKzs3H69GmMj49DCIGrr74aXq8X7e3t8Pv9CAQC6O3tRXFxMZqamhAIBFBcXIzs7OxYVCURERElgZi0APZMvo6gPA5AYCLYheGp+ovKRCIRDA8PY8mSJThz5kz0eG9vL4aGhlBaWorx8XE0NjZibGwMPp8P586dQzgcRnZ2NlatWoXR0VEEg0G4XC50d3ejtrZ29jVCHox1HYRQwhCqjPHuwwhM9Fwy5qmpKQQCAej1epw6dQpjY2Pw+/2orq4GAAQCARw7dgxr167F8PAwnE4nRkdHYTQaMTAwALPZjP7+fjgcDoyNjaGgoACdnZ2w2+3o6OiYHZfXBc/5k4CqQMhhTLa/ATUcfMv7mZaWBr/fj8zMTDQ2NuK1117DqlWrYDKZYDAY4PV6EQqF4HK5MDIy8pathkRERESXEpME0GldDb3GAgCw6LORYSmf9XMhBMbHx5GSkoKcnBx4PB5MTEwAuNC1qtFooNVqodVqo12subm5yMvLg8FggN1uh8PhgEajgcvlgtfrxYoVKxAMBmd18eoMVthyVgLShZdly14Gkz3/olgAICcnB6tXr8bw8DCCwWD02PRuJ9PlpuOSJAmSJEGj0UTHMkYiEUiSBKvVGv2yWCwXjePTpWQgJbfywgNJg5S8pZD0pkvGJYSARqOB3W6HxWJBJBKBqqrRGKZNTk6iv78f69at45hAIiIieldi0gVcmn4TJGjg8p9DUeo2ZFuWzfq5EAKdnZ3Izc1FQUEB8vPzUV9fD51Oh4yMDNjtdtTX10Oj0WDt2rWora2Fx+OBw+EAAIyOjiIlJQU6nQ4mkwl2ux19fX0ALoyd0+v1AABJo0PFzu/Ckl4CJRLAojV/Ba0+ZVYsqqrC6/XC5/PhxIkTuOaaa1BaWoq6urroNTUaDYLBINauXYsTJ04gFArB5/NBq9VClmUsXrwYHR0dMJvNGBoagkajwfj4OIALLYvTk1CmEzatMQWLbvo/GKt9HpLOAMea26HRzr71siwjEonA6/VGJ8lMP9d1112HkydPwmQyYXh4GDqdDrIsY9GiRWhpaYFer0c4HIbRaIxFdRIREdH7nCQus+nowIED2L59e8wDmE7EdDod7HY7Vq9ePefnnH5JM1vM3i1VVXH8+HEYDAaMj4/jhhtugEYzxwbT6Vs9h7gu7zIXtoLLzs5GZmZmXK9FRERE7z0xaQGcC4vFgo0bN0IIAbPZ/M4nXIa5JH4zn2PdunWQZRlGozEmzxnvxI+IiIjociQ8AZQkCRaLJdFhXESSJJhMpncuSERERPQew51AiIiIiJIME0AiIiKiJMMEkIiIiCjJXPYYwK6uLhw9ejSesVAMTe90QkRERPRml70MDBERERG9P7ALmIiIiCjJMAEkIiIiSjJMAImIiIiSDBNAIiIioiTDBJCIiIgoyTABJCIiIkoyTACJiIiIkgwTQCIiIqIkwwSQiIiIKMn8/05MBwE2LmeTAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Processing: 1577.png...\n", + "\n", + "✨ Model Prediction:\n", + "{\"gt_parse\": \"This is a dot line titled 'Net incurrence of foreign liabilities of government of a country'. The x-axis shows Years and the y-axis shows Net incurrence (in current LCU).\"}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"📊 Upload the dot line chart here:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded Image: {filename}\")\n", + " plt.show()\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " print(f\"Processing: {filename}...\")\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction:\")\n", + " print(prediction)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 596 + }, + "id": "mM7-7GgqNyvj", + "outputId": "00925cb4-ac0b-452d-f7c5-9b6dd027489b" + }, + "execution_count": 27, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📊 Upload the dot line chart here:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 631.png to 631.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Processing: 631.png...\n", + "\n", + "✨ Model Prediction:\n", + "{\"gt_parse\": \"This is a dot line titled 'Amount spent on the transport and travel items of national tourists visited in Slovenia'. The x-axis shows Year and the y-axis shows Amount spent (in US$).\"}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "print(\"📊 Upload the dot line chart here:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " plt.figure(figsize=(8, 5))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded Image: {filename}\")\n", + " plt.show()\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " print(f\"Processing: {filename}...\")\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction:\")\n", + " print(prediction)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 536 + }, + "id": "5qKa8-9fOdma", + "outputId": "b47b8733-8398-4dcd-d507-38fd88bd1436" + }, + "execution_count": 28, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📊 Upload the dot line chart here:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 1025.png to 1025.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Processing: 1025.png...\n", + "\n", + "✨ Model Prediction:\n", + "{\"gt_parse\": \"This is a dot line titled 'Net disbursements of loans from Regional development banks'. The x-axis shows Years and the y-axis shows Amount (in current US$).\"}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "\n", + "folder_to_zip = \"STEM_Sight_Line_Expert_V2\"\n", + "zip_file = \"STEM_Sight_Line_Expert_Model.zip\"\n", + "\n", + "!zip -r {zip_file} {folder_to_zip}\n", + "\n", + "print(f\"✅ Zip file ready: {zip_file}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kXlZdQNqM1qf", + "outputId": "0a67f6ff-db99-4d3e-af5b-ff1f94bc05d4" + }, + "execution_count": 29, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " adding: STEM_Sight_Line_Expert_V2/ (stored 0%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/ (stored 0%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/trainer_state.json (deflated 81%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/config.json (deflated 74%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/training_args.bin (deflated 53%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/scaler.pt (deflated 64%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/model.safetensors (deflated 7%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/optimizer.pt (deflated 30%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/tokenizer.json (deflated 74%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/scheduler.pt (deflated 61%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/tokenizer_config.json (deflated 53%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/rng_state.pth (deflated 26%)\n", + " adding: STEM_Sight_Line_Expert_V2/checkpoint-2000/generation_config.json (deflated 57%)\n", + "✅ Zip file ready: STEM_Sight_Line_Expert_Model.zip\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "import os\n", + "\n", + "if os.path.exists(\"STEM_Sight_Line_Expert_Model.zip\"):\n", + " files.download(\"STEM_Sight_Line_Expert_Model.zip\")\n", + "else:\n", + " print(\"Abhi bhi file nahi mili! Sidebar mein refresh karke dekho.\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "p4-JqKasM5fq", + "outputId": "5a8b3359-aed7-46ee-cef8-8c58f9b5d59c" + }, + "execution_count": 30, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " async function download(id, filename, size) {\n", + " if (!google.colab.kernel.accessAllowed) {\n", + " return;\n", + " }\n", + " const div = document.createElement('div');\n", + " const label = document.createElement('label');\n", + " label.textContent = `Downloading \"${filename}\": `;\n", + " div.appendChild(label);\n", + " const progress = document.createElement('progress');\n", + " progress.max = size;\n", + " div.appendChild(progress);\n", + " document.body.appendChild(div);\n", + "\n", + " const buffers = [];\n", + " let downloaded = 0;\n", + "\n", + " const channel = await google.colab.kernel.comms.open(id);\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + "\n", + " for await (const message of channel.messages) {\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + " if (message.buffers) {\n", + " for (const buffer of message.buffers) {\n", + " buffers.push(buffer);\n", + " downloaded += buffer.byteLength;\n", + " progress.value = downloaded;\n", + " }\n", + " }\n", + " }\n", + " const blob = new Blob(buffers, {type: 'application/binary'});\n", + " const a = document.createElement('a');\n", + " a.href = window.URL.createObjectURL(blob);\n", + " a.download = filename;\n", + " div.appendChild(a);\n", + " a.click();\n", + " div.remove();\n", + " }\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "download(\"download_21f5b73b-ff85-4296-8df0-cbd09db3b18a\", \"STEM_Sight_Line_Expert_Model.zip\", 2421799895)" + ] + }, + "metadata": {} + } + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "ef3577a4382c4c6d8d57bf08505774b6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_74dbd4a5067749f096423e0f728da6ce", + "IPY_MODEL_590469c1a20f484fbbe61f3b9018819c", + "IPY_MODEL_696a822fd0734e2f88099712cff1636a" + ], + "layout": "IPY_MODEL_108ab43cb44a496f8ce8931c98f1d3d1" + } + }, + "74dbd4a5067749f096423e0f728da6ce": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b4a40e0c280e498fb097810011f6a3c3", + "placeholder": "​", + "style": "IPY_MODEL_2b7630a46f234f709b478251b1de79c9", + "value": "Loading weights: 100%" + } + }, + "590469c1a20f484fbbe61f3b9018819c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ef361ad22fc748e49e73ebb16ecc92b7", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b0af1e1928c540b1ac703b72602d88be", + "value": 484 + } + }, + "696a822fd0734e2f88099712cff1636a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_cfa3db3d388e4512a3168776eb0db972", + "placeholder": "​", + "style": "IPY_MODEL_93f1c5f1726b471bb9b8fa2c45c2fb53", + "value": " 484/484 [00:15<00:00, 261.23it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "108ab43cb44a496f8ce8931c98f1d3d1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b4a40e0c280e498fb097810011f6a3c3": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b7630a46f234f709b478251b1de79c9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ef361ad22fc748e49e73ebb16ecc92b7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b0af1e1928c540b1ac703b72602d88be": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cfa3db3d388e4512a3168776eb0db972": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93f1c5f1726b471bb9b8fa2c45c2fb53": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "961eb952de8c4ae6875dc3fb17375e7f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_917709f7d3c940ebac3dde5213af6269", + "IPY_MODEL_e40e726c5af8481980e69e1fcfae5320", + "IPY_MODEL_dc316d08251e4b549b99111a842d8855" + ], + "layout": "IPY_MODEL_72f013190d024e45a2014ce5fcc8f640" + } + }, + "917709f7d3c940ebac3dde5213af6269": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_15a5737abedc4abdba2d482df839a69c", + "placeholder": "​", + "style": "IPY_MODEL_f240a0fa5c2849b18675acd64e18bdf9", + "value": "Resolving data files: 100%" + } + }, + "e40e726c5af8481980e69e1fcfae5320": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5f33dfdcbe32422d8568078433d155c7", + "max": 26011, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f310c212577a4dcfa4d15084a16f1ead", + "value": 26011 + } + }, + "dc316d08251e4b549b99111a842d8855": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9e2256d814f74d18a221a14278b9b44b", + "placeholder": "​", + "style": "IPY_MODEL_9eb5ae398f884a54b07a86e2fc1b47ff", + "value": " 26011/26011 [00:01<00:00, 15610.46it/s]" + } + }, + "72f013190d024e45a2014ce5fcc8f640": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15a5737abedc4abdba2d482df839a69c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f240a0fa5c2849b18675acd64e18bdf9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5f33dfdcbe32422d8568078433d155c7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f310c212577a4dcfa4d15084a16f1ead": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9e2256d814f74d18a221a14278b9b44b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9eb5ae398f884a54b07a86e2fc1b47ff": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c189f126720b4778b12da61f2040231a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_73ff37dc01b148aebd1cc090bdb133bd", + "IPY_MODEL_ef1e3c6b56ba4cbba97f166344acaecb", + "IPY_MODEL_b00cb94c0b0449a48ea64d29bf2d42ad" + ], + "layout": "IPY_MODEL_3b58a8bc5dcc447a94fb89947e3a6a24" + } + }, + "73ff37dc01b148aebd1cc090bdb133bd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_820e3546bf5e4b5c8ddaedcfde8da477", + "placeholder": "​", + "style": "IPY_MODEL_9e6d0c57c2ee46a18f20c8edd0dd4c36", + "value": "Downloading data: 100%" + } + }, + "ef1e3c6b56ba4cbba97f166344acaecb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eea0b8c498eb4de2a85bbf38edbf3429", + "max": 26011, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c846884a5b9446f1b9110ce5b2f747ad", + "value": 26011 + } + }, + "b00cb94c0b0449a48ea64d29bf2d42ad": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4258f359f0414fd3adbee0582ec80a88", + "placeholder": "​", + "style": "IPY_MODEL_d9f1c66eaaf34f39bc95f7b81e6aedff", + "value": " 26011/26011 [00:01<00:00, 17922.51files/s]" + } + }, + "3b58a8bc5dcc447a94fb89947e3a6a24": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "820e3546bf5e4b5c8ddaedcfde8da477": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9e6d0c57c2ee46a18f20c8edd0dd4c36": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "eea0b8c498eb4de2a85bbf38edbf3429": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c846884a5b9446f1b9110ce5b2f747ad": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4258f359f0414fd3adbee0582ec80a88": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d9f1c66eaaf34f39bc95f7b81e6aedff": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "171b0f3ce26e475ea2011f8972ba6407": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c02a5bd15d7e4037a40791cb62076454", + "IPY_MODEL_49176e32578344cf9cd5b074573c2435", + "IPY_MODEL_088415aa68d944e9a4912db8787e0f6c" + ], + "layout": "IPY_MODEL_634c64dd7384471692002edfb15f0cf8" + } + }, + "c02a5bd15d7e4037a40791cb62076454": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_049d7f89b3d84ca1acfe117f974e7a94", + "placeholder": "​", + "style": "IPY_MODEL_e0ba4ab2d950439abab4a4fac7b9bf7f", + "value": "Generating train split: " + } + }, + "49176e32578344cf9cd5b074573c2435": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0a29c4605fc14240903900da283295ba", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_4a6ea8e0b67c440aa90920cde94e399e", + "value": 1 + } + }, + "088415aa68d944e9a4912db8787e0f6c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3a212f6febf543e7a02f00620a549d0b", + "placeholder": "​", + "style": "IPY_MODEL_d9898d52818448369853cc5c5c012b92", + "value": " 26010/0 [00:01<00:00, 24486.16 examples/s]" + } + }, + "634c64dd7384471692002edfb15f0cf8": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "049d7f89b3d84ca1acfe117f974e7a94": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0ba4ab2d950439abab4a4fac7b9bf7f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0a29c4605fc14240903900da283295ba": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "4a6ea8e0b67c440aa90920cde94e399e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3a212f6febf543e7a02f00620a549d0b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d9898d52818448369853cc5c5c012b92": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "adbff237a27744a1831c87e8629d8e20": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b9c0388e54bb43d0b81b47d5f1db13f5", + "IPY_MODEL_a39bae7eaf114ea7af7cfb9708ff52ac", + "IPY_MODEL_79d84e6c644442a3a9bcfc8ab721aa9e" + ], + "layout": "IPY_MODEL_f7c206ffff5747269ca045ca75b6a723" + } + }, + "b9c0388e54bb43d0b81b47d5f1db13f5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_58e89df04c2746268ebddf5e56f0387b", + "placeholder": "​", + "style": "IPY_MODEL_a631548e80f84fb0b8e4a74826e74603", + "value": "Map (num_proc=2): 100%" + } + }, + "a39bae7eaf114ea7af7cfb9708ff52ac": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5fed2f5365824448bcb05d28a2603662", + "max": 9000, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_72d1dbfd553a44318581e18e3216f433", + "value": 9000 + } + }, + "79d84e6c644442a3a9bcfc8ab721aa9e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_58f9d2d0a60a454e80462c54dfe1618a", + "placeholder": "​", + "style": "IPY_MODEL_e00fa09f33ee412b90658c030e5e35f0", + "value": " 9000/9000 [05:13<00:00, 39.28 examples/s]" + } + }, + "f7c206ffff5747269ca045ca75b6a723": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "58e89df04c2746268ebddf5e56f0387b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a631548e80f84fb0b8e4a74826e74603": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "5fed2f5365824448bcb05d28a2603662": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72d1dbfd553a44318581e18e3216f433": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "58f9d2d0a60a454e80462c54dfe1618a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e00fa09f33ee412b90658c030e5e35f0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "63e105168a7340adbc1c472a366e6b51": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_86a505bbd19c4f72a607c435c2e1be00", + "IPY_MODEL_8c48cd3ce8e74300b00d90636cabcca8", + "IPY_MODEL_681f0d5aaa214389867ea2fbfbb35aa2" + ], + "layout": "IPY_MODEL_f1123a9fefee4ac6bfb818ecff02bf56" + } + }, + "86a505bbd19c4f72a607c435c2e1be00": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3be6bee4aa314c4e805f3c526ce12009", + "placeholder": "​", + "style": "IPY_MODEL_35d9cd70044d49c7956289b6b5ac599a", + "value": "Map (num_proc=2): 100%" + } + }, + "8c48cd3ce8e74300b00d90636cabcca8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d585e0e12ac848dd90eeeafdc765b52a", + "max": 1000, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d7289908620f43c685fc7d0633b44c03", + "value": 1000 + } + }, + "681f0d5aaa214389867ea2fbfbb35aa2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_81d66431ffd44f978f4f4420fd7cc6bb", + "placeholder": "​", + "style": "IPY_MODEL_168f732b5ddf4258ba7daac96b3ed95a", + "value": " 1000/1000 [00:41<00:00, 18.69 examples/s]" + } + }, + "f1123a9fefee4ac6bfb818ecff02bf56": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3be6bee4aa314c4e805f3c526ce12009": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "35d9cd70044d49c7956289b6b5ac599a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d585e0e12ac848dd90eeeafdc765b52a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d7289908620f43c685fc7d0633b44c03": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "81d66431ffd44f978f4f4420fd7cc6bb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "168f732b5ddf4258ba7daac96b3ed95a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2d63e8ab3c5c4cb5a3dac1d6e258f000": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_48e13326bc124c6381fef53754a9e0ea", + "IPY_MODEL_abb68d979a8f4fc79661ed96f7187579", + "IPY_MODEL_7cdbbee560444126abeef28c376bf29b" + ], + "layout": "IPY_MODEL_2466adb3f3ee4b9fa0af334c7ad34403" + } + }, + "48e13326bc124c6381fef53754a9e0ea": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_95d45782f6274d8bb7880d1a4568bb84", + "placeholder": "​", + "style": "IPY_MODEL_4bae91075bb74d15bb1762dddccef8d2", + "value": "Writing model shards: 100%" + } + }, + "abb68d979a8f4fc79661ed96f7187579": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_38c7bb2215e241d79693c8d7110aa6d6", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9ea8717c24ac4fe99df930bc1adedb5a", + "value": 1 + } + }, + "7cdbbee560444126abeef28c376bf29b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e483d200e53d49a2a24bc7fc4e93a1e2", + "placeholder": "​", + "style": "IPY_MODEL_971f542d570e4962944483bd13aa41ea", + "value": " 1/1 [00:06<00:00,  6.87s/it]" + } + }, + "2466adb3f3ee4b9fa0af334c7ad34403": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "95d45782f6274d8bb7880d1a4568bb84": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4bae91075bb74d15bb1762dddccef8d2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "38c7bb2215e241d79693c8d7110aa6d6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ea8717c24ac4fe99df930bc1adedb5a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e483d200e53d49a2a24bc7fc4e93a1e2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "971f542d570e4962944483bd13aa41ea": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "69dd565ca8c04ca394e083baf2564d35": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b7742241bfce4b30856ba536e7931daa", + "IPY_MODEL_f577a9142d8f441b8e0c515a09200196", + "IPY_MODEL_b3b1f3715e8b40fdb98d865de339507e" + ], + "layout": "IPY_MODEL_fcba2edc73174aaab085d22f34fdd30a" + } + }, + "b7742241bfce4b30856ba536e7931daa": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2496b1d6385c4dbba02e5f8cbae3394c", + "placeholder": "​", + "style": "IPY_MODEL_05216e20bf0342fda8d75b852b7225f7", + "value": "Writing model shards: 100%" + } + }, + "f577a9142d8f441b8e0c515a09200196": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc0d01fe8f094bdfb826fa54457cc91d", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bb2969f395e44f94ac9d87fba71897da", + "value": 1 + } + }, + "b3b1f3715e8b40fdb98d865de339507e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_107ef6183ed44c21aa5110900f10ce38", + "placeholder": "​", + "style": "IPY_MODEL_1b20956be2744e1c80350f66640e04ef", + "value": " 1/1 [00:13<00:00, 13.87s/it]" + } + }, + "fcba2edc73174aaab085d22f34fdd30a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2496b1d6385c4dbba02e5f8cbae3394c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "05216e20bf0342fda8d75b852b7225f7": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bc0d01fe8f094bdfb826fa54457cc91d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb2969f395e44f94ac9d87fba71897da": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "107ef6183ed44c21aa5110900f10ce38": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1b20956be2744e1c80350f66640e04ef": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "36155426db404366addedcf66574f3ac": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_720361ee7b674a17861cd87b14dbc418", + "IPY_MODEL_4a4d359c562c4ee280247d8e43ef0a97", + "IPY_MODEL_79ce7f07e96e41559409723cbf728145" + ], + "layout": "IPY_MODEL_7099e6ad3a3246ffacc503e6b3bedbb6" + } + }, + "720361ee7b674a17861cd87b14dbc418": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b08abbb9068148f8a21df9e5d77376c8", + "placeholder": "​", + "style": "IPY_MODEL_278a0e7b8cc74561bf5fdcacf3f9be52", + "value": "Writing model shards: 100%" + } + }, + "4a4d359c562c4ee280247d8e43ef0a97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9a69ab986a5e48fb91a35c18d5180ab1", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_e713a5f2015f4ae4b0b2624a87e733b5", + "value": 1 + } + }, + "79ce7f07e96e41559409723cbf728145": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8b8ea6d8363d4d28b1af30a0304ae899", + "placeholder": "​", + "style": "IPY_MODEL_12824c7b0a4942749bd5a35c806edbf2", + "value": " 1/1 [01:17<00:00, 77.94s/it]" + } + }, + "7099e6ad3a3246ffacc503e6b3bedbb6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b08abbb9068148f8a21df9e5d77376c8": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "278a0e7b8cc74561bf5fdcacf3f9be52": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9a69ab986a5e48fb91a35c18d5180ab1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e713a5f2015f4ae4b0b2624a87e733b5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8b8ea6d8363d4d28b1af30a0304ae899": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "12824c7b0a4942749bd5a35c806edbf2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c81e624b4f694f0ba577513c9e1c48c0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dc440d684ed4446c86dc4302bb8dda74", + "IPY_MODEL_0936d216d8f140e49e3045b0f0cb8e33", + "IPY_MODEL_cf7f76d5c6704d31ba2ea2fe89ebec24" + ], + "layout": "IPY_MODEL_34cad06143af4088bd19777eaa39af20" + } + }, + "dc440d684ed4446c86dc4302bb8dda74": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_615211dea2df4d77a6dc1c1d84a602d9", + "placeholder": "​", + "style": "IPY_MODEL_25ee0f7bc07747c1b1567b92e6d9c4ad", + "value": "Writing model shards: 100%" + } + }, + "0936d216d8f140e49e3045b0f0cb8e33": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ececdcc7a1db472e98286fe8c4caf6b5", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_83201efd6e3144b3997f5ab9a4219f04", + "value": 1 + } + }, + "cf7f76d5c6704d31ba2ea2fe89ebec24": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e854576903764185a00e87f4ed499346", + "placeholder": "​", + "style": "IPY_MODEL_eea3b98aa2ca492c835b2d5b2ddf6077", + "value": " 1/1 [01:05<00:00, 62.61s/it]" + } + }, + "34cad06143af4088bd19777eaa39af20": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "615211dea2df4d77a6dc1c1d84a602d9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "25ee0f7bc07747c1b1567b92e6d9c4ad": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ececdcc7a1db472e98286fe8c4caf6b5": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "83201efd6e3144b3997f5ab9a4219f04": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e854576903764185a00e87f4ed499346": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eea3b98aa2ca492c835b2d5b2ddf6077": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a43d1029417c469cb01b171d9060301b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_b5c6a98b8c3c4d8bb53c18ab042d88d7", + "IPY_MODEL_e01a9432200b4c5b95b473f7751b8fb4", + "IPY_MODEL_5d59e5c8c37849beb60c2eba2851ee6f" + ], + "layout": "IPY_MODEL_f7778981411246a09e14a71b624f5f2d" + } + }, + "b5c6a98b8c3c4d8bb53c18ab042d88d7": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_afe16847911d4e72a333de48aa668408", + "placeholder": "​", + "style": "IPY_MODEL_0242f4d70ccd4a96b13fb74604258cda", + "value": "100%" + } + }, + "e01a9432200b4c5b95b473f7751b8fb4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_82e8fb6761724604995ec0e14d1cf825", + "max": 200, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_9540a0baa6db43cd8054889546bfe270", + "value": 200 + } + }, + "5d59e5c8c37849beb60c2eba2851ee6f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d109e20a6f8046a2915200cfba075707", + "placeholder": "​", + "style": "IPY_MODEL_7b2f5e6def554a74921eb593410c8cf8", + "value": " 200/200 [03:00<00:00,  1.20it/s]" + } + }, + "f7778981411246a09e14a71b624f5f2d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "afe16847911d4e72a333de48aa668408": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0242f4d70ccd4a96b13fb74604258cda": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "82e8fb6761724604995ec0e14d1cf825": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9540a0baa6db43cd8054889546bfe270": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "d109e20a6f8046a2915200cfba075707": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b2f5e6def554a74921eb593410c8cf8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/notebooks/STEM_Sight_Horizontal.ipynb b/notebooks/STEM_Sight_Horizontal.ipynb new file mode 100644 index 0000000..bb44186 --- /dev/null +++ b/notebooks/STEM_Sight_Horizontal.ipynb @@ -0,0 +1,12395 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "8901144e21b2414c963db31530ede911": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_df8827f839654d7782aa74e175d97d06", + "IPY_MODEL_e0bf5ddecf824212aa277229d40000d8", + "IPY_MODEL_d27673383bc64d0f86cf2c4c7f1a4250" + ], + "layout": "IPY_MODEL_1bee1974fd1945029fa8a28b0aeaf36a" + } + }, + "df8827f839654d7782aa74e175d97d06": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b32d9b7c37ab4e8281ca136bd3949fe7", + "placeholder": "​", + "style": "IPY_MODEL_be951e7e695044cea85d9ef5d0c90076", + "value": "Loading weights: 100%" + } + }, + "e0bf5ddecf824212aa277229d40000d8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc0ab0820fbe46c2b3bc936fc8a766d5", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_51fee30a4f9f40918a91bafc573991f0", + "value": 484 + } + }, + "d27673383bc64d0f86cf2c4c7f1a4250": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3e06b3e1edc643f0ba475bc0414f5659", + "placeholder": "​", + "style": "IPY_MODEL_94a83d37a83c4055b575bd2d655cd6c0", + "value": " 484/484 [00:01<00:00, 523.20it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "1bee1974fd1945029fa8a28b0aeaf36a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b32d9b7c37ab4e8281ca136bd3949fe7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "be951e7e695044cea85d9ef5d0c90076": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "bc0ab0820fbe46c2b3bc936fc8a766d5": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "51fee30a4f9f40918a91bafc573991f0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3e06b3e1edc643f0ba475bc0414f5659": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "94a83d37a83c4055b575bd2d655cd6c0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "75554232bbf14a6ba39e7bb02ed55045": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_016c07e96799464ebbd81be531987e2c", + "IPY_MODEL_04966be9fd52404daf5729433449775e", + "IPY_MODEL_adfd49cd1dc2423889b6d0d6f99a1afa" + ], + "layout": "IPY_MODEL_cbd48a223ad74ae0b122846bd1b13aea" + } + }, + "016c07e96799464ebbd81be531987e2c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8d6df3b8bec843e3bd7fe0d8c0f896fd", + "placeholder": "​", + "style": "IPY_MODEL_5f55566ff7f0426b91b39f9f88ee0a54", + "value": "Writing model shards: 100%" + } + }, + "04966be9fd52404daf5729433449775e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2c3dc08702b745fc8edc4c4095f5cb80", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_bdc049b7ef3847e987530e57ea1aba6e", + "value": 1 + } + }, + "adfd49cd1dc2423889b6d0d6f99a1afa": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9084018bde0740df8edd6995ff40c46a", + "placeholder": "​", + "style": "IPY_MODEL_69470ee62217487baab017ae23f50702", + "value": " 1/1 [00:05<00:00,  5.30s/it]" + } + }, + "cbd48a223ad74ae0b122846bd1b13aea": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8d6df3b8bec843e3bd7fe0d8c0f896fd": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f55566ff7f0426b91b39f9f88ee0a54": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2c3dc08702b745fc8edc4c4095f5cb80": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bdc049b7ef3847e987530e57ea1aba6e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9084018bde0740df8edd6995ff40c46a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "69470ee62217487baab017ae23f50702": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "9572d41986644fd385469c2793a9b3ff": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_159a4fae03e847f5a04e7250625c4535", + "IPY_MODEL_0a150c50b38444bdb76aa000183d4fa5", + "IPY_MODEL_6c39b0b321c145e3a7b14df1df702254" + ], + "layout": "IPY_MODEL_7eff79ec4c564a66b61872be185ccc91" + } + }, + "159a4fae03e847f5a04e7250625c4535": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f66a9ce4994c4ef091fd7e43f0a64b7f", + "placeholder": "​", + "style": "IPY_MODEL_37772c5980b44155b81bc2058161db3e", + "value": "Writing model shards: 100%" + } + }, + "0a150c50b38444bdb76aa000183d4fa5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7a9b0d15095d47bab4cf76ac8ba04093", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c2ecc18a6d394373aa117eb0b9d62c22", + "value": 1 + } + }, + "6c39b0b321c145e3a7b14df1df702254": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7d93c19f61e44d33b84b2eb203391d7d", + "placeholder": "​", + "style": "IPY_MODEL_c3d80c05c9ea4474885e7c34cad272df", + "value": " 1/1 [00:05<00:00,  5.47s/it]" + } + }, + "7eff79ec4c564a66b61872be185ccc91": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f66a9ce4994c4ef091fd7e43f0a64b7f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "37772c5980b44155b81bc2058161db3e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7a9b0d15095d47bab4cf76ac8ba04093": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c2ecc18a6d394373aa117eb0b9d62c22": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7d93c19f61e44d33b84b2eb203391d7d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c3d80c05c9ea4474885e7c34cad272df": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a96a2688f16045cda2c6f345b7f93598": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_395a31c685e14cbda3488f2407cb048a", + "IPY_MODEL_7b5b98be945d478bbfa847413fac7584", + "IPY_MODEL_018cbf6cd9e64ecbafbec5228d6ec298" + ], + "layout": "IPY_MODEL_153b175903ab471aa369b2994fc0bcad" + } + }, + "395a31c685e14cbda3488f2407cb048a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0b9043bff9dd4694b4711c2b57908512", + "placeholder": "​", + "style": "IPY_MODEL_a76fc577669d405c89776250da4d8dc4", + "value": "Writing model shards: 100%" + } + }, + "7b5b98be945d478bbfa847413fac7584": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_2609091a31e247e5bcac8f09a3ca90b6", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a8885ef0d73f42d3a564866437f7c8ee", + "value": 1 + } + }, + "018cbf6cd9e64ecbafbec5228d6ec298": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee3115dbccdd49de993313dd5de8eade", + "placeholder": "​", + "style": "IPY_MODEL_05d7ba0832114708ad686e7e336b90a4", + "value": " 1/1 [00:13<00:00, 13.31s/it]" + } + }, + "153b175903ab471aa369b2994fc0bcad": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0b9043bff9dd4694b4711c2b57908512": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a76fc577669d405c89776250da4d8dc4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "2609091a31e247e5bcac8f09a3ca90b6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a8885ef0d73f42d3a564866437f7c8ee": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "ee3115dbccdd49de993313dd5de8eade": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "05d7ba0832114708ad686e7e336b90a4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e4dbac584ddb4a7cbedc12aacd236911": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6e79e7cfaac342eba5daae908e4d9e3f", + "IPY_MODEL_8241bd2f60b34a09a18a963dcb7f4652", + "IPY_MODEL_25890bf169c64d13a851956e65f6e52f" + ], + "layout": "IPY_MODEL_39c2212b143240438caf42d86bb5bb2c" + } + }, + "6e79e7cfaac342eba5daae908e4d9e3f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b2db569d6f034704920632876918d140", + "placeholder": "​", + "style": "IPY_MODEL_a53a809048a54e9baa70461f239cc9a0", + "value": "Writing model shards: 100%" + } + }, + "8241bd2f60b34a09a18a963dcb7f4652": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c5bf0ea1f189427b8d18520a54cf18c1", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_987d7b3a72924423b6bcf50ddfeae34a", + "value": 1 + } + }, + "25890bf169c64d13a851956e65f6e52f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3c059600fc54411abbb75c12123ccc6d", + "placeholder": "​", + "style": "IPY_MODEL_d90727f888964e84867c871f5ff65a2e", + "value": " 1/1 [00:05<00:00,  5.04s/it]" + } + }, + "39c2212b143240438caf42d86bb5bb2c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b2db569d6f034704920632876918d140": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a53a809048a54e9baa70461f239cc9a0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c5bf0ea1f189427b8d18520a54cf18c1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "987d7b3a72924423b6bcf50ddfeae34a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3c059600fc54411abbb75c12123ccc6d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d90727f888964e84867c871f5ff65a2e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d5933e6b3c4e4724a0817e45170b12ec": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7725f1f6df82409dbcde2ed4e5052610", + "IPY_MODEL_46cd3d7b69fe48519599487b57084880", + "IPY_MODEL_ac15ebd9559b4bec814f6430e6c4c46c" + ], + "layout": "IPY_MODEL_bff6561c960a41b59d394410931ff8c2" + } + }, + "7725f1f6df82409dbcde2ed4e5052610": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_59314e4a9117415e8e9f68c7e18212b7", + "placeholder": "​", + "style": "IPY_MODEL_a26d89249fc84bab946ad89283dd89f4", + "value": "Writing model shards: 100%" + } + }, + "46cd3d7b69fe48519599487b57084880": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_32be90fe407147fab5d9290be122481b", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b6b56829ce5f42a6b5a18a1053e30972", + "value": 1 + } + }, + "ac15ebd9559b4bec814f6430e6c4c46c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f33d7930d26a4dd0871b1f36a4edf67f", + "placeholder": "​", + "style": "IPY_MODEL_c7bd95a6ba0a4558b9b12179cd9bb6dc", + "value": " 1/1 [00:08<00:00,  8.21s/it]" + } + }, + "bff6561c960a41b59d394410931ff8c2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "59314e4a9117415e8e9f68c7e18212b7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a26d89249fc84bab946ad89283dd89f4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "32be90fe407147fab5d9290be122481b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b6b56829ce5f42a6b5a18a1053e30972": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "f33d7930d26a4dd0871b1f36a4edf67f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7bd95a6ba0a4558b9b12179cd9bb6dc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3ff599c3ab1149969b5d3bbec5649e4c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_07a5180fa9404de8bc0a1e374346c4f5", + "IPY_MODEL_b06a24ed34c84f8dbcc2c375a0c9077f", + "IPY_MODEL_c09f2a173996409496beb92a4c363256" + ], + "layout": "IPY_MODEL_66242bc8d9664ef8a49d98d2dec9b181" + } + }, + "07a5180fa9404de8bc0a1e374346c4f5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_667542c24e75437587db49d463af06f7", + "placeholder": "​", + "style": "IPY_MODEL_a00b813dcbc1460cb19095d0f83e1703", + "value": "Writing model shards: 100%" + } + }, + "b06a24ed34c84f8dbcc2c375a0c9077f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_311f01363bf745de9e5041d0c2923a63", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2d21fdc160b9426ea62b4882329c02c3", + "value": 1 + } + }, + "c09f2a173996409496beb92a4c363256": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_38e31c0a94854126b797c4599d0d28dc", + "placeholder": "​", + "style": "IPY_MODEL_92c4742ecf9445eb99e9aac071f272e6", + "value": " 1/1 [00:16<00:00, 16.05s/it]" + } + }, + "66242bc8d9664ef8a49d98d2dec9b181": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "667542c24e75437587db49d463af06f7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a00b813dcbc1460cb19095d0f83e1703": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "311f01363bf745de9e5041d0c2923a63": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2d21fdc160b9426ea62b4882329c02c3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "38e31c0a94854126b797c4599d0d28dc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "92c4742ecf9445eb99e9aac071f272e6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a86f74a8a5384fcf874d98d2a237e120": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ec09d0ad0cb748d2aeb2ef39c3e701db", + "IPY_MODEL_0f78ca9c6a2e41439bdd16b89dcf1569", + "IPY_MODEL_7fdcd4f4e9924ad9920f0fc65cfc044e" + ], + "layout": "IPY_MODEL_ae6fe2d0b3bb458da7aa10253e6e4deb" + } + }, + "ec09d0ad0cb748d2aeb2ef39c3e701db": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bd9d00c9f67241b6a9c02d0e01604020", + "placeholder": "​", + "style": "IPY_MODEL_d46528e593144672a53ec0de4a7b97fe", + "value": "Writing model shards: 100%" + } + }, + "0f78ca9c6a2e41439bdd16b89dcf1569": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b2b65f2f21a748d8a4da165c4346af5b", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_a73d553bf9fa41589ba93025c71df46e", + "value": 1 + } + }, + "7fdcd4f4e9924ad9920f0fc65cfc044e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b0cc8b099d6044338ad19bd70c0e78a5", + "placeholder": "​", + "style": "IPY_MODEL_4ebe2f08e8804313844cfcf42d6a0429", + "value": " 1/1 [00:07<00:00,  7.15s/it]" + } + }, + "ae6fe2d0b3bb458da7aa10253e6e4deb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd9d00c9f67241b6a9c02d0e01604020": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d46528e593144672a53ec0de4a7b97fe": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b2b65f2f21a748d8a4da165c4346af5b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a73d553bf9fa41589ba93025c71df46e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b0cc8b099d6044338ad19bd70c0e78a5": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4ebe2f08e8804313844cfcf42d6a0429": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e8955f010958466ead5220bc5809abc9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_851640155d104c5e9806bc162c45336e", + "IPY_MODEL_91736d8a4a314d97ac429d73f19c6d8e", + "IPY_MODEL_70a96f941d2a485db90894681fe41f1d" + ], + "layout": "IPY_MODEL_7e6defbd9c0348289cdf781e0a6739b2" + } + }, + "851640155d104c5e9806bc162c45336e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_db3c0d6c76b74d2fbfa56e860b906a18", + "placeholder": "​", + "style": "IPY_MODEL_12e31e39a93848048d29ed04307a103f", + "value": "Writing model shards: 100%" + } + }, + "91736d8a4a314d97ac429d73f19c6d8e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0eec7fcaf9b940939485f55bce4211cf", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7346d75c6eaf42848d966a560e681906", + "value": 1 + } + }, + "70a96f941d2a485db90894681fe41f1d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b8939dbba45f435a8d247ca0dc7a90ea", + "placeholder": "​", + "style": "IPY_MODEL_fe6c3e02f46244a7a7482990263bc015", + "value": " 1/1 [00:09<00:00,  9.01s/it]" + } + }, + "7e6defbd9c0348289cdf781e0a6739b2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "db3c0d6c76b74d2fbfa56e860b906a18": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "12e31e39a93848048d29ed04307a103f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0eec7fcaf9b940939485f55bce4211cf": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7346d75c6eaf42848d966a560e681906": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b8939dbba45f435a8d247ca0dc7a90ea": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fe6c3e02f46244a7a7482990263bc015": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "730c93ed6f4c44c5b8551b8e80f72fad": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_de126e0538ae44c2a0ed23c4bedbb9d3", + "IPY_MODEL_488b7a9024c2470ca7a40a3bc160ec0a", + "IPY_MODEL_9ac4b2e2a12943a7a58bce0a212e5f26" + ], + "layout": "IPY_MODEL_83f8afe1a7fe4ff0ad349815285d4a39" + } + }, + "de126e0538ae44c2a0ed23c4bedbb9d3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0ecc8f4e51dc4e689d0f60f6f16baebf", + "placeholder": "​", + "style": "IPY_MODEL_52f5744c3d71460681010ebf03add1b0", + "value": "Loading weights: 100%" + } + }, + "488b7a9024c2470ca7a40a3bc160ec0a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_10df6489d10c4686a8a73a718da27da9", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_191ead5e7a424c7caba1024a4a664010", + "value": 484 + } + }, + "9ac4b2e2a12943a7a58bce0a212e5f26": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bfc4b24bf0ad439d9134469ca46088cf", + "placeholder": "​", + "style": "IPY_MODEL_39bbc5c605784db68a13601a09595425", + "value": " 484/484 [00:11<00:00, 453.73it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "83f8afe1a7fe4ff0ad349815285d4a39": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0ecc8f4e51dc4e689d0f60f6f16baebf": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "52f5744c3d71460681010ebf03add1b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "10df6489d10c4686a8a73a718da27da9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "191ead5e7a424c7caba1024a4a664010": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bfc4b24bf0ad439d9134469ca46088cf": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "39bbc5c605784db68a13601a09595425": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "419c0a5a3cca45f6919a652a58ec7227": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_eb621b102b9d4f78831e3f979bd65968", + "IPY_MODEL_348094c9f871450788d930311dd70d78", + "IPY_MODEL_695cba6be2a84a80962ef8715ad3f34e" + ], + "layout": "IPY_MODEL_c2809acd0de74dd9b6a64dafe0ffd255" + } + }, + "eb621b102b9d4f78831e3f979bd65968": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5696612d752b4b649653ff9a1d6f6828", + "placeholder": "​", + "style": "IPY_MODEL_70ebf5eb1e654cefb2ac7324cd1d0186", + "value": "Loading weights: 100%" + } + }, + "348094c9f871450788d930311dd70d78": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4fd1766998874204a640cea272aefecb", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cb12980f41484fa9958746ce31da5aad", + "value": 484 + } + }, + "695cba6be2a84a80962ef8715ad3f34e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_00ceb7fd6b614aa29c626b48fdc1957f", + "placeholder": "​", + "style": "IPY_MODEL_6ae189c5369f426c8b5b25491f722c47", + "value": " 484/484 [00:01<00:00, 535.79it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "c2809acd0de74dd9b6a64dafe0ffd255": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5696612d752b4b649653ff9a1d6f6828": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "70ebf5eb1e654cefb2ac7324cd1d0186": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4fd1766998874204a640cea272aefecb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cb12980f41484fa9958746ce31da5aad": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "00ceb7fd6b614aa29c626b48fdc1957f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6ae189c5369f426c8b5b25491f722c47": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ff9865124d7a49b29cddb534528754c8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0c411f4a10094e1589dcb6de32025cda", + "IPY_MODEL_49b6ef42d3624c3fa336e9644059b833", + "IPY_MODEL_d062cf09a8af463e89823561a1b6eb85" + ], + "layout": "IPY_MODEL_7a548218c0f544be9bf0b82ac5e35426" + } + }, + "0c411f4a10094e1589dcb6de32025cda": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_efcbdab0da804eda9af757a2cb552193", + "placeholder": "​", + "style": "IPY_MODEL_bb8836dd36864fe89930f18803f09e72", + "value": "Loading weights: 100%" + } + }, + "49b6ef42d3624c3fa336e9644059b833": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e298e588623c49d481c33fc32422ec15", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_15ef395cfd954bbab5c97fffb58c9481", + "value": 484 + } + }, + "d062cf09a8af463e89823561a1b6eb85": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1fbf8c8d56cd43f39913dd765241c1fb", + "placeholder": "​", + "style": "IPY_MODEL_9d8a3c0845184ef1bd999360e40079cb", + "value": " 484/484 [00:01<00:00, 559.15it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "7a548218c0f544be9bf0b82ac5e35426": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "efcbdab0da804eda9af757a2cb552193": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb8836dd36864fe89930f18803f09e72": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e298e588623c49d481c33fc32422ec15": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "15ef395cfd954bbab5c97fffb58c9481": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1fbf8c8d56cd43f39913dd765241c1fb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d8a3c0845184ef1bd999360e40079cb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "69a99a03db5f4d00be4b8f9e851e51ac": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_4653276755094c9c8f687c85ef071c44", + "IPY_MODEL_5dea9819d14f4552ab1f7421ce920c81", + "IPY_MODEL_b259b143f21249229776dc05c49a2667" + ], + "layout": "IPY_MODEL_4e140c762ae64731a5fccf207d61e879" + } + }, + "4653276755094c9c8f687c85ef071c44": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4212114d308444c68cd55f64bf6f2557", + "placeholder": "​", + "style": "IPY_MODEL_5d831532dacb4a8eaa5776cb41a17829", + "value": "Loading weights: 100%" + } + }, + "5dea9819d14f4552ab1f7421ce920c81": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3d662f350f34a0da037386154a601fe", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_f53beddcb3344a87a59ec35b9c71007c", + "value": 484 + } + }, + "b259b143f21249229776dc05c49a2667": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a7a4658592794880879d72a607aa86ba", + "placeholder": "​", + "style": "IPY_MODEL_87bb2458f0be457a966809e5cac6cec6", + "value": " 484/484 [00:01<00:00, 272.29it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "4e140c762ae64731a5fccf207d61e879": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4212114d308444c68cd55f64bf6f2557": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5d831532dacb4a8eaa5776cb41a17829": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e3d662f350f34a0da037386154a601fe": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f53beddcb3344a87a59ec35b9c71007c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "a7a4658592794880879d72a607aa86ba": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87bb2458f0be457a966809e5cac6cec6": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "892d92bcb1b147aab63b836c41839cf2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7f0a2fb8a241460aad862cbab5a85c01", + "IPY_MODEL_d6930ddcf80c445ab894209aae6b921f", + "IPY_MODEL_11e45ea20046473bbafaca5f8e5a2172" + ], + "layout": "IPY_MODEL_3ee352dc766f425889311b44b9e3ba9d" + } + }, + "7f0a2fb8a241460aad862cbab5a85c01": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_41870bca1d364e4d99b40296727bd062", + "placeholder": "​", + "style": "IPY_MODEL_f4f2d19723bd44c39bade420e9bb1771", + "value": "Loading weights: 100%" + } + }, + "d6930ddcf80c445ab894209aae6b921f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_b8399b4697c64c5fac530a9d86734170", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_93e320738d70471d993758189795aa45", + "value": 484 + } + }, + "11e45ea20046473bbafaca5f8e5a2172": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_40254fb4107447c8907693dc371abead", + "placeholder": "​", + "style": "IPY_MODEL_f87a9f6a8712426c92e322d27e8281b8", + "value": " 484/484 [00:01<00:00, 531.06it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "3ee352dc766f425889311b44b9e3ba9d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "41870bca1d364e4d99b40296727bd062": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f4f2d19723bd44c39bade420e9bb1771": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b8399b4697c64c5fac530a9d86734170": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "93e320738d70471d993758189795aa45": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "40254fb4107447c8907693dc371abead": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f87a9f6a8712426c92e322d27e8281b8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d5114bc2fd3a400e9d4a3243467f8a09": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c55f834fb97747c09f8f8cb524395a99", + "IPY_MODEL_02783238b4ca4a34a0790cf8fe8660c1", + "IPY_MODEL_8524e173dde8420683279c4e55cf13ce" + ], + "layout": "IPY_MODEL_bd0ee12fb3bd48cf80a0213e69651d69" + } + }, + "c55f834fb97747c09f8f8cb524395a99": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1560142dc5514fe9925eb88bf9e7faf6", + "placeholder": "​", + "style": "IPY_MODEL_75a94f247545435eb0a551ad12e0eb6d", + "value": "Loading weights: 100%" + } + }, + "02783238b4ca4a34a0790cf8fe8660c1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0bac004813ce45dbab80fd392c36012c", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1be9aeecfaff4f4c85329bdd511a2af7", + "value": 484 + } + }, + "8524e173dde8420683279c4e55cf13ce": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_bc578c1971cc48cd946e77d5d6c45340", + "placeholder": "​", + "style": "IPY_MODEL_c97d1b6bfd2d437db369f6411b379ede", + "value": " 484/484 [00:00<00:00, 694.07it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "bd0ee12fb3bd48cf80a0213e69651d69": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1560142dc5514fe9925eb88bf9e7faf6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "75a94f247545435eb0a551ad12e0eb6d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0bac004813ce45dbab80fd392c36012c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1be9aeecfaff4f4c85329bdd511a2af7": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "bc578c1971cc48cd946e77d5d6c45340": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c97d1b6bfd2d437db369f6411b379ede": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4ea6391950214171ad08afeb1c984082": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e5f53976863547e094756e528566f53d", + "IPY_MODEL_748370fe53da4d74a3888c5be249ec45", + "IPY_MODEL_f14ea589d6264e218669c2bdf859514a" + ], + "layout": "IPY_MODEL_29ec5e7f86a2472d9e96371683c7c443" + } + }, + "e5f53976863547e094756e528566f53d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f22dbec4512a4f0995cdcd3e25e0312a", + "placeholder": "​", + "style": "IPY_MODEL_9bea9703719c4a1e9c4110615c63781a", + "value": "Loading weights: 100%" + } + }, + "748370fe53da4d74a3888c5be249ec45": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1bcd825b305e4ff88e5f6a36f582a536", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cae130843a6f4120b6e6802a585dcd28", + "value": 484 + } + }, + "f14ea589d6264e218669c2bdf859514a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e2a62e12162f4dc2bdaac18a50fb8bdc", + "placeholder": "​", + "style": "IPY_MODEL_c367d05ee0904727be191dea51709b52", + "value": " 484/484 [00:01<00:00, 404.67it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "29ec5e7f86a2472d9e96371683c7c443": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f22dbec4512a4f0995cdcd3e25e0312a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9bea9703719c4a1e9c4110615c63781a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1bcd825b305e4ff88e5f6a36f582a536": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cae130843a6f4120b6e6802a585dcd28": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e2a62e12162f4dc2bdaac18a50fb8bdc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c367d05ee0904727be191dea51709b52": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "cde5d1befa924a12b40fc4b60d7d2c21": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_42b1cfa9fd8845d39fd853c3e7f76d01", + "IPY_MODEL_7a183362a7e84fb7987e8ceca323135e", + "IPY_MODEL_2adccf3cb89240c38b8a96bde8023b62" + ], + "layout": "IPY_MODEL_1e1b792610d34747a8c4cf3e20f58726" + } + }, + "42b1cfa9fd8845d39fd853c3e7f76d01": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ec9589cdeb074792b60d6bd3a9b4cbc1", + "placeholder": "​", + "style": "IPY_MODEL_c1fe3023a5a94ab0ba0a92e451462a06", + "value": "Loading weights: 100%" + } + }, + "7a183362a7e84fb7987e8ceca323135e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d67ec831f2ca4f6398dde1afe48ba329", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_64035efdd4a84803a4edc0a608f7b887", + "value": 484 + } + }, + "2adccf3cb89240c38b8a96bde8023b62": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_68dbc67be07b415fbd0c0f28ea586ddf", + "placeholder": "​", + "style": "IPY_MODEL_63eb5c73a0ba44e7bc90ff7d329af3d2", + "value": " 484/484 [00:01<00:00, 520.48it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "1e1b792610d34747a8c4cf3e20f58726": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ec9589cdeb074792b60d6bd3a9b4cbc1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c1fe3023a5a94ab0ba0a92e451462a06": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d67ec831f2ca4f6398dde1afe48ba329": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "64035efdd4a84803a4edc0a608f7b887": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "68dbc67be07b415fbd0c0f28ea586ddf": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63eb5c73a0ba44e7bc90ff7d329af3d2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4963637ee5d141d79786f021c98279c7": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_23c7633921424902bd473e6d92decd3c", + "IPY_MODEL_4200dd76953a4148947f095e5f892166", + "IPY_MODEL_b7adb5ae5d63439aaf4d90a0d477cf72" + ], + "layout": "IPY_MODEL_79fca325c5bc47c0acd0a051e26fc6c0" + } + }, + "23c7633921424902bd473e6d92decd3c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3f89926108e54e34ae212b28d1255e6e", + "placeholder": "​", + "style": "IPY_MODEL_8137ea19a2a3440ea59d8d53ba855938", + "value": "Loading weights: 100%" + } + }, + "4200dd76953a4148947f095e5f892166": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e44fb2ebb8064fbf88b995a903dddab0", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_48fee540d7724bccbb5a6212c3d2fd97", + "value": 484 + } + }, + "b7adb5ae5d63439aaf4d90a0d477cf72": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_949f291dcf494509928fa444f0433dd1", + "placeholder": "​", + "style": "IPY_MODEL_2aab06a4499f425dbc6c177d8c329de4", + "value": " 484/484 [00:02<00:00, 228.95it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "79fca325c5bc47c0acd0a051e26fc6c0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3f89926108e54e34ae212b28d1255e6e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8137ea19a2a3440ea59d8d53ba855938": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e44fb2ebb8064fbf88b995a903dddab0": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48fee540d7724bccbb5a6212c3d2fd97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "949f291dcf494509928fa444f0433dd1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2aab06a4499f425dbc6c177d8c329de4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "96ad0057a100453682822141bdf69c84": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_99afdcad72724baaaaba1d709614a381", + "IPY_MODEL_f54b6083632a4a11bba7c0924a238076", + "IPY_MODEL_915d900c008d433baa04110d0c7b6705" + ], + "layout": "IPY_MODEL_3ee3757bbca641dca1165aca94fe42e9" + } + }, + "99afdcad72724baaaaba1d709614a381": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3de9c87f6bf24268953a400ebb02588d", + "placeholder": "​", + "style": "IPY_MODEL_99fc6847bff5467db0ab190d14e6c811", + "value": "Loading weights: 100%" + } + }, + "f54b6083632a4a11bba7c0924a238076": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0ff6994c42fb4797818bb4645c51e015", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_82f62e8938c14892bfe94980835567a2", + "value": 484 + } + }, + "915d900c008d433baa04110d0c7b6705": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9238a1d71cf4404383bc07082e0611df", + "placeholder": "​", + "style": "IPY_MODEL_4445e206e7eb4131b1d0f577598b3734", + "value": " 484/484 [00:01<00:00, 507.04it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "3ee3757bbca641dca1165aca94fe42e9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3de9c87f6bf24268953a400ebb02588d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "99fc6847bff5467db0ab190d14e6c811": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "0ff6994c42fb4797818bb4645c51e015": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "82f62e8938c14892bfe94980835567a2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9238a1d71cf4404383bc07082e0611df": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4445e206e7eb4131b1d0f577598b3734": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e350505da87d4f41807d51361db4d314": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_83514ec88cfe479b9368a4521ab1c35f", + "IPY_MODEL_18ca7045b52d41269d14f8cacd8aa12a", + "IPY_MODEL_3c1906095b7845298168b0b40a60c588" + ], + "layout": "IPY_MODEL_16f67465c38745b3bc961e5f06305614" + } + }, + "83514ec88cfe479b9368a4521ab1c35f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb51764548624ebdac2b0ce16fd2f99b", + "placeholder": "​", + "style": "IPY_MODEL_5e82952c35a54af0b0f32e9cd922267c", + "value": "Loading weights: 100%" + } + }, + "18ca7045b52d41269d14f8cacd8aa12a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_4537d5ba0903464796f22a01724f1bd8", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b037333983774a3aaf057bdaa4823b6f", + "value": 484 + } + }, + "3c1906095b7845298168b0b40a60c588": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_109f5f1be45f4dc096c064a31e93de81", + "placeholder": "​", + "style": "IPY_MODEL_acb6826183bd4bea8894854d41cce24b", + "value": " 484/484 [00:01<00:00, 457.62it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "16f67465c38745b3bc961e5f06305614": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eb51764548624ebdac2b0ce16fd2f99b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e82952c35a54af0b0f32e9cd922267c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4537d5ba0903464796f22a01724f1bd8": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b037333983774a3aaf057bdaa4823b6f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "109f5f1be45f4dc096c064a31e93de81": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "acb6826183bd4bea8894854d41cce24b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d3c05968a2fa4c39b6d54b9fbbe75c66": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d72205fa1e4d41c3965c29be45623f10", + "IPY_MODEL_ca2daaefb604423aa4b179ffdb3f4085", + "IPY_MODEL_783fc6a1de1f4b56a73417fe9bbdba1b" + ], + "layout": "IPY_MODEL_733dd26363ee47558ac598520f8bbac1" + } + }, + "d72205fa1e4d41c3965c29be45623f10": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_a475cf7c3db24d1ab4cbf5ddcfbc8be3", + "placeholder": "​", + "style": "IPY_MODEL_bd05259a79e44207a8d36b073d376338", + "value": "Loading weights: 100%" + } + }, + "ca2daaefb604423aa4b179ffdb3f4085": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f651a370ad334129b81539d6a424516f", + "max": 484, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2349b16b58964c07817ad85812727c58", + "value": 484 + } + }, + "783fc6a1de1f4b56a73417fe9bbdba1b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_923084864ae44bd592061e3ecd0c4424", + "placeholder": "​", + "style": "IPY_MODEL_9ca61d1128134b16a5b3c608a38e7c20", + "value": " 484/484 [00:01<00:00, 308.26it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]" + } + }, + "733dd26363ee47558ac598520f8bbac1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a475cf7c3db24d1ab4cbf5ddcfbc8be3": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bd05259a79e44207a8d36b073d376338": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "f651a370ad334129b81539d6a424516f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2349b16b58964c07817ad85812727c58": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "923084864ae44bd592061e3ecd0c4424": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9ca61d1128134b16a5b3c608a38e7c20": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yeGtvhytBbyK", + "outputId": "1b16b75e-81ce-41bb-de16-18ce4a8921e3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n", + "✅ Extracted to /content/dataset_hbar\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "import zipfile\n", + "import os\n", + "\n", + "drive.mount('/content/drive')\n", + "\n", + "# Your specific path\n", + "zip_path = '/content/drive/MyDrive/PlotQA-Stemsight/horizontal_bars_sample.zip'\n", + "extract_path = '/content/dataset_hbar'\n", + "\n", + "with zipfile.ZipFile(zip_path, 'r') as zip_ref:\n", + " zip_ref.extractall(extract_path)\n", + "\n", + "print(f\"✅ Extracted to {extract_path}\")\n", + "!pip install -q transformers datasets sentencepiece accelerate" + ] + }, + { + "cell_type": "code", + "source": [ + "import json\n", + "from PIL import Image\n", + "from torch.utils.data import Dataset\n", + "from pathlib import Path\n", + "\n", + "class HorizontalDonutDataset(Dataset):\n", + " def __init__(self, dataset_path, processor, max_length=512, limit=10000):\n", + " self.dataset_path = Path(dataset_path) / \"train\"\n", + " self.processor = processor\n", + " self.max_length = max_length\n", + "\n", + " metadata_path = self.dataset_path / \"metadata.jsonl\"\n", + "\n", + " if not metadata_path.exists():\n", + " raise FileNotFoundError(f\"❌ Missing metadata.jsonl at: {metadata_path}\")\n", + "\n", + " with open(metadata_path, \"r\") as f:\n", + " self.lines = f.readlines()[:limit]\n", + " print(f\"📋 Loaded {len(self.lines)} samples for Horizontal Bar training.\")\n", + "\n", + " def __len__(self):\n", + " return len(self.lines)\n", + "\n", + " def __getitem__(self, idx):\n", + " line = json.loads(self.lines[idx])\n", + " image_path = self.dataset_path / line[\"file_name\"]\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + "\n", + " pixel_values = self.processor(image, return_tensors=\"pt\").pixel_values\n", + " target_sequence = f\"{line['ground_truth']}\"\n", + "\n", + " labels = self.processor.tokenizer(\n", + " target_sequence,\n", + " add_special_tokens=False,\n", + " max_length=self.max_length,\n", + " padding=\"max_length\",\n", + " truncation=True,\n", + " return_tensors=\"pt\",\n", + " ).input_ids\n", + "\n", + " labels[labels == self.processor.tokenizer.pad_token_id] = -100\n", + " return {\"pixel_values\": pixel_values.squeeze(), \"labels\": labels.squeeze()}" + ], + "metadata": { + "id": "XWwsT5q1CbVA" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel, TrainingArguments, Trainer\n", + "\n", + "# 1. Load Model & Processor (Starting from VBAR Master)\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "master_vbar_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "\n", + "processor = DonutProcessor.from_pretrained(master_vbar_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(\n", + " master_vbar_path,\n", + " tie_word_embeddings=False\n", + ").to(device)\n", + "\n", + "# 2. Prepare Dataset (10k Samples)\n", + "train_dataset = HorizontalDonutDataset(\"/content/dataset_hbar\", processor, limit=10000)\n", + "\n", + "# 🚀 CRITICAL FIX: Create a small validation subset (200 samples)\n", + "# This ensures \"Validation Loss\" appears INSTANTLY without freezing the training.\n", + "val_subset = torch.utils.data.Subset(train_dataset, range(0, 200))\n", + "\n", + "# 3. Training Arguments (Optimized for Fast Feedback)\n", + "training_args = TrainingArguments(\n", + " output_dir=\"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2\",\n", + " per_device_train_batch_size=2,\n", + " gradient_accumulation_steps=4,\n", + " learning_rate=5e-6,\n", + " num_train_epochs=3, # As requested: 3 Epochs\n", + " weight_decay=0.01,\n", + "\n", + " # --- FEEDBACK SETTINGS ---\n", + " logging_steps=10, # Update Training Loss every 10 steps\n", + " logging_first_step=True, # Show results IMMEDIATELY at Step 1\n", + " eval_strategy=\"steps\",\n", + " eval_steps=100, # Show Validation Loss every 100 steps\n", + "\n", + " # --- PERFORMANCE ---\n", + " fp16=True, # Use T4 GPU Speedup\n", + " save_steps=500, # Save every 500 steps\n", + " save_total_limit=2,\n", + " report_to=\"none\",\n", + " load_best_model_at_end=False # Keep it fast\n", + ")\n", + "\n", + "# 4. Initialize Trainer\n", + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=train_dataset,\n", + " eval_dataset=val_subset # Fast validation on subset\n", + ")\n", + "\n", + "print(\"🚀 Starting Training... Results will appear in the table in seconds.\")\n", + "trainer.train()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "8901144e21b2414c963db31530ede911", + "df8827f839654d7782aa74e175d97d06", + "e0bf5ddecf824212aa277229d40000d8", + "d27673383bc64d0f86cf2c4c7f1a4250", + "1bee1974fd1945029fa8a28b0aeaf36a", + "b32d9b7c37ab4e8281ca136bd3949fe7", + "be951e7e695044cea85d9ef5d0c90076", + "bc0ab0820fbe46c2b3bc936fc8a766d5", + "51fee30a4f9f40918a91bafc573991f0", + "3e06b3e1edc643f0ba475bc0414f5659", + "94a83d37a83c4055b575bd2d655cd6c0", + "75554232bbf14a6ba39e7bb02ed55045", + "016c07e96799464ebbd81be531987e2c", + "04966be9fd52404daf5729433449775e", + "adfd49cd1dc2423889b6d0d6f99a1afa", + "cbd48a223ad74ae0b122846bd1b13aea", + "8d6df3b8bec843e3bd7fe0d8c0f896fd", + "5f55566ff7f0426b91b39f9f88ee0a54", + "2c3dc08702b745fc8edc4c4095f5cb80", + "bdc049b7ef3847e987530e57ea1aba6e", + "9084018bde0740df8edd6995ff40c46a", + "69470ee62217487baab017ae23f50702", + "9572d41986644fd385469c2793a9b3ff", + "159a4fae03e847f5a04e7250625c4535", + "0a150c50b38444bdb76aa000183d4fa5", + "6c39b0b321c145e3a7b14df1df702254", + "7eff79ec4c564a66b61872be185ccc91", + "f66a9ce4994c4ef091fd7e43f0a64b7f", + "37772c5980b44155b81bc2058161db3e", + "7a9b0d15095d47bab4cf76ac8ba04093", + "c2ecc18a6d394373aa117eb0b9d62c22", + "7d93c19f61e44d33b84b2eb203391d7d", + "c3d80c05c9ea4474885e7c34cad272df", + "a96a2688f16045cda2c6f345b7f93598", + "395a31c685e14cbda3488f2407cb048a", + "7b5b98be945d478bbfa847413fac7584", + "018cbf6cd9e64ecbafbec5228d6ec298", + "153b175903ab471aa369b2994fc0bcad", + "0b9043bff9dd4694b4711c2b57908512", + "a76fc577669d405c89776250da4d8dc4", + "2609091a31e247e5bcac8f09a3ca90b6", + "a8885ef0d73f42d3a564866437f7c8ee", + "ee3115dbccdd49de993313dd5de8eade", + "05d7ba0832114708ad686e7e336b90a4", + "e4dbac584ddb4a7cbedc12aacd236911", + "6e79e7cfaac342eba5daae908e4d9e3f", + "8241bd2f60b34a09a18a963dcb7f4652", + "25890bf169c64d13a851956e65f6e52f", + "39c2212b143240438caf42d86bb5bb2c", + "b2db569d6f034704920632876918d140", + "a53a809048a54e9baa70461f239cc9a0", + "c5bf0ea1f189427b8d18520a54cf18c1", + "987d7b3a72924423b6bcf50ddfeae34a", + "3c059600fc54411abbb75c12123ccc6d", + "d90727f888964e84867c871f5ff65a2e", + "d5933e6b3c4e4724a0817e45170b12ec", + "7725f1f6df82409dbcde2ed4e5052610", + "46cd3d7b69fe48519599487b57084880", + "ac15ebd9559b4bec814f6430e6c4c46c", + "bff6561c960a41b59d394410931ff8c2", + "59314e4a9117415e8e9f68c7e18212b7", + "a26d89249fc84bab946ad89283dd89f4", + "32be90fe407147fab5d9290be122481b", + "b6b56829ce5f42a6b5a18a1053e30972", + "f33d7930d26a4dd0871b1f36a4edf67f", + "c7bd95a6ba0a4558b9b12179cd9bb6dc", + "3ff599c3ab1149969b5d3bbec5649e4c", + "07a5180fa9404de8bc0a1e374346c4f5", + "b06a24ed34c84f8dbcc2c375a0c9077f", + "c09f2a173996409496beb92a4c363256", + "66242bc8d9664ef8a49d98d2dec9b181", + "667542c24e75437587db49d463af06f7", + "a00b813dcbc1460cb19095d0f83e1703", + "311f01363bf745de9e5041d0c2923a63", + "2d21fdc160b9426ea62b4882329c02c3", + "38e31c0a94854126b797c4599d0d28dc", + "92c4742ecf9445eb99e9aac071f272e6", + "a86f74a8a5384fcf874d98d2a237e120", + "ec09d0ad0cb748d2aeb2ef39c3e701db", + "0f78ca9c6a2e41439bdd16b89dcf1569", + "7fdcd4f4e9924ad9920f0fc65cfc044e", + "ae6fe2d0b3bb458da7aa10253e6e4deb", + "bd9d00c9f67241b6a9c02d0e01604020", + "d46528e593144672a53ec0de4a7b97fe", + "b2b65f2f21a748d8a4da165c4346af5b", + "a73d553bf9fa41589ba93025c71df46e", + "b0cc8b099d6044338ad19bd70c0e78a5", + "4ebe2f08e8804313844cfcf42d6a0429", + "e8955f010958466ead5220bc5809abc9", + "851640155d104c5e9806bc162c45336e", + "91736d8a4a314d97ac429d73f19c6d8e", + "70a96f941d2a485db90894681fe41f1d", + "7e6defbd9c0348289cdf781e0a6739b2", + "db3c0d6c76b74d2fbfa56e860b906a18", + "12e31e39a93848048d29ed04307a103f", + "0eec7fcaf9b940939485f55bce4211cf", + "7346d75c6eaf42848d966a560e681906", + "b8939dbba45f435a8d247ca0dc7a90ea", + "fe6c3e02f46244a7a7482990263bc015" + ] + }, + "id": "XrhOLtu1Czn1", + "outputId": "7dc0e779-3f7a-480b-c8fe-7116c1fd217c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [3750/3750 1:20:36, Epoch 3/3]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining LossValidation Loss
1000.3526040.057357
2000.1724450.040945
3000.1618420.030025
4000.1356550.021378
5000.1279270.020767
6000.1306040.013847
7000.1196470.010233
8000.0911320.009002
9000.0604980.007931
10000.0931340.007778
11000.0981890.007544
12000.1035110.005904
13000.0458590.005077
14000.0503720.004408
15000.0350120.004320
16000.0790590.003753
17000.0629930.003616
18000.0675800.003355
19000.0496800.003050
20000.0462940.003265
21000.0200360.003147
22000.0335520.002867
23000.0239900.002313
24000.0285050.002105
25000.0325260.002140
26000.0305210.001822
27000.0232410.002009
28000.0257680.002115
29000.0370290.001745
30000.0244870.001795
31000.0139580.001806
32000.0179220.001866
33000.0440560.001751
34000.0200850.001671
35000.0294550.001614
36000.0221680.001614
37000.0337320.001621

" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Writing model shards: 0%| | 0/1 [00:00\"\n", + " decoder_input_ids = processor.tokenizer(\n", + " task_prompt,\n", + " add_special_tokens=False,\n", + " return_tensors=\"pt\"\n", + " ).input_ids.to(device)\n", + "\n", + " # Generate summary\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " num_beams=1,\n", + " bad_words_ids=[[processor.tokenizer.unk_token_id]],\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode and clean\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + " sequence = sequence.replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\")\n", + " clean_summary = re.sub(r\"<.*?>\", \"\", sequence, count=1).strip()\n", + "\n", + " print(\"\\n📊 --- ANALYSIS RESULT ---\")\n", + " print(clean_summary)\n", + " print(\"---------------------------\\n\")\n", + "\n", + "# --- 4. UPLOAD IMAGE FROM COMPUTER ---\n", + "print(\"📤 Upload a horizontal bar chart image to test:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " print(f'Processing file: \"{filename}\"')\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 957, + "referenced_widgets": [ + "730c93ed6f4c44c5b8551b8e80f72fad", + "de126e0538ae44c2a0ed23c4bedbb9d3", + "488b7a9024c2470ca7a40a3bc160ec0a", + "9ac4b2e2a12943a7a58bce0a212e5f26", + "83f8afe1a7fe4ff0ad349815285d4a39", + "0ecc8f4e51dc4e689d0f60f6f16baebf", + "52f5744c3d71460681010ebf03add1b0", + "10df6489d10c4686a8a73a718da27da9", + "191ead5e7a424c7caba1024a4a664010", + "bfc4b24bf0ad439d9134469ca46088cf", + "39bbc5c605784db68a13601a09595425" + ] + }, + "id": "CnyRRZezrSy1", + "outputId": "f01ab58c-4a50-4672-99ba-90cdd6c0d575" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n", + "⏳ Loading Processor from Master...\n", + "⏳ Loading Model Weights from /content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:01" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 5583.png to 5583.png\n", + "Processing file: \"5583.png\"\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "

" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApMAAAJFCAYAAACBcXzPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkvFJREFUeJzs3Xd4XOWd/v/3mRn1YnVZcpNlS+694t4LMQbTS8ICWZIQQiq7SUi+abvJZlMhhCSEAAk1EAO2sQ3GNjYY945tWZKbZEtWL6MyTTNzfn94dX4WssEMVsHcr+vyBTqameczZ47O3POUM4ZpmiYiIiIiIiGwdXUBIiIiIvLppTApIiIiIiFTmBQRERGRkClMioiIiEjIFCZFREREJGQKkyIiIiISMoVJEREREQmZwqSIiIiIhExhUkRERERCpjApIp8as2bNYtasWV1dxidWVFSEYRj8/e9/7+pSLrvNmzdjGAbLly/v6lJEpJMoTIp0gb///e8YhsGePXu6uhQAXC4XP/nJT9i8efMl3f6jAsNdd91FbGzsZaywe/nTn/7UKUGwdT+f/y8pKYnJkyfz/PPPd3j7F6rn+uuvp2fPnoSHh5OWlsY111zDq6++2um1tHrhhRd4+OGHu6x9EQFHVxcgIl3P5XLx05/+FKBb9/y99dZbXV0CcC5MpqSkcNddd3VKe1//+teZMGECADU1Nbz00kt8/vOfp76+nvvvv79Tavjxj3/Mz372M3Jycvjyl79Mv379qKmpYe3atdxwww08//zz3H777Z1Sy/leeOEFDh8+zDe/+c1Ob1tEzlGYFJFuz+VyER0dTXh4eFeX0iWmT5/OjTfeaP183333kZ2dzQsvvHBZwqRpmng8HqKioi74++XLl/Ozn/2MG2+8kRdeeIGwsDDrd//xH//BunXraGlp+cR1fBzNzc3ExMR0apsicmEa5hbpJlqHhktLS7nuuuuIjY0lNTWVBx98kEAgYN2udb7db37zG37/+9/Tr18/oqKimDlzJocPH27zmBebY3jXXXeRlZVlPV5qaioAP/3pT63h1J/85CeX/Tn+6U9/YtiwYURERJCZmcn9999PfX19u5qHDx/O3r17mTFjBtHR0Tz00EMXfD5ZWVnthoFb/50/ZL9//34WL15MfHw8sbGxzJ07lx07drRpt3XqwdatW/n2t79NamoqMTExLFu2jKqqqjZtHjlyhHfeecdqq7Wm2tpaHnzwQUaMGEFsbCzx8fEsXryYgwcPXtb9GB4eTmJiIg5H2/6Ap59+mjlz5pCWlkZERARDhw7lz3/+c7v7Z2VlsWTJEtatW8f48eOJiori8ccfv2h7/+///T+SkpJ46qmn2gTJVgsXLmTJkiVttgWDQX7+85/Tu3dvIiMjmTt3LsePH29zmy1btnDTTTfRt29fIiIi6NOnD9/61rdwu91tbtf6t3HixAmuvvpq4uLiuOOOO5g1axZr1qyhuLjYei1aj2sR6TzqmRTpRgKBAAsXLmTSpEn85je/YcOGDfz2t79lwIAB3HfffW1u+8wzz9DY2Mj999+Px+PhkUceYc6cORw6dIj09PRLbjM1NZU///nP3HfffSxbtozrr78egJEjR37kfRsbG6murm633ev1ttv2k5/8hJ/+9KfMmzeP++67j4KCAv785z+ze/dutm7d2iak1NTUsHjxYm699VY+//nPX/T5PPzwwzQ1NbXZ9vvf/54DBw6QnJwMwJEjR5g+fTrx8fH853/+J2FhYTz++OPMmjWLd955h0mTJrW5/wMPPEBiYiI//vGPKSoq4uGHH+ZrX/saL730ktXmAw88QGxsLD/4wQ8ArPpOnjzJihUruOmmm+jfvz8VFRU8/vjjzJw5k7y8PDIzMz9yn17I+fu5trbWGtp98skn29zuz3/+M8OGDWPp0qU4HA5ef/11vvrVrxIMBtv1YBYUFHDbbbfx5S9/mXvvvZdBgwZdsO1jx46Rn5/PPffcQ1xc3CXX/Mtf/hKbzcaDDz6I0+nkV7/6FXfccQc7d+60bvOvf/0Ll8vFfffdR3JyMrt27eLRRx+lpKSEf/3rX20ez+/3s3DhQqZNm8ZvfvMboqOj6dmzJ06nk5KSEn7/+98DXNFzdUW6LVNEOt3TTz9tAubu3butbf/2b/9mAubPfvazNrcdM2aMOW7cOOvnU6dOmYAZFRVllpSUWNt37txpAua3vvUta9vMmTPNmTNntmv/3/7t38x+/fpZP1dVVZmA+eMf//iS6t+0aZMJfOi/mJgY6/aVlZVmeHi4uWDBAjMQCFjb//jHP5qA+dRTT7WpGTD/8pe/tGv3Ys+n1csvv9xuH1533XVmeHi4eeLECWvb2bNnzbi4OHPGjBnWttbXZN68eWYwGLS2f+tb3zLtdrtZX19vbRs2bNgF6/B4PG2en2mee70iIiLa1NT6Gj799NMXfS6mefH9bLPZzJ///Oftbu9yudptW7hwoZmdnd1mW79+/UzAfPPNNz+0fdM0zZUrV5qA+fvf//4jb3t+zUOGDDG9Xq+1/ZFHHjEB89ChQx9a7//8z/+YhmGYxcXF1rbWv43vfe977W7/uc99rs2xLCKdT8PcIt3MV77ylTY/T58+nZMnT7a73XXXXUevXr2snydOnMikSZNYu3Zth9fY6kc/+hHr169v92/BggVtbrdhwwZ8Ph/f/OY3sdn+/9POvffeS3x8PGvWrGlz+4iICO6+++6PVUteXh733HMP1157LT/84Q+Bcz29b731Ftdddx3Z2dnWbTMyMrj99tt57733aGhoaPM4X/rSlzAMw/p5+vTpBAIBiouLP7KGiIgI6/kFAgFqamqIjY1l0KBB7Nu372M9n/Odv59feuklbrvtNn7wgx/wyCOPtLnd+XMenU4n1dXVzJw5k5MnT+J0Otvctn///ixcuPAj227dPx+nVxLg7rvvbjPHdfr06QBtjuXz621ubqa6upopU6Zgmib79+9v95gf7J0Xke5Bw9wi3UhkZKQ1f7FVYmIidXV17W6bk5PTbltubi4vv/xyh9X3QSNGjGDevHnttj/33HNtfm4NYh8cSg0PDyc7O7tdUOvVq9fHWmzT0NDA9ddfT69evXjmmWesMFhVVYXL5brgEO6QIUMIBoOcOXOGYcOGWdv79u3b5naJiYkAF3wNPigYDPLII4/wpz/9iVOnTrWZ69o67B6KD+7nm2++GafTyfe+9z1uv/1265jZunUrP/7xj9m+fTsul6vNYzidTnr06GH93L9//0tqOz4+Hjg31P5xXMp+PH36ND/60Y9YtWpVu/37wfDrcDjo3bv3x6pBRDqHeiZFuhG73X5ZH+/8HrbznR9yuqOLrSq+mLvuuouzZ8+yYsUKK/yE6mKvgWmaH3nfX/ziF3z7299mxowZPPfcc6xbt47169czbNgwgsHgJ6rrg+bOnYvH42HXrl0AnDhxgrlz51JdXc3vfvc71qxZw/r16/nWt74F0K79S93HgwcPBuDQoUMfq76P2o+BQID58+ezZs0avvvd77JixQrWr19vXb/zg/We3+srIt2LeiZFPqWOHTvWblthYWGb1ayJiYkXHCL/YE/gxULn5dKvXz/g3KKP84ebfT4fp06dumDv5qX65S9/yYoVK3j11Vet4NMqNTWV6OhoCgoK2t0vPz8fm81Gnz59PnabF9tfy5cvZ/bs2e0WxtTX15OSkvKx2/kwfr8fwFqA9Prrr+P1elm1alWbXsFNmzZ9onZyc3MZNGgQK1eu5JFHHrlsC1wOHTpEYWEh//jHP7jzzjut7evXr/9Yj9PRx66IfDR9zBP5lFqxYgWlpaXWz7t27WLnzp0sXrzY2jZgwADy8/PbXNrm4MGDbN26tc1jRUdHA7S7TM/lMm/ePMLDw/nDH/7QpofvySefxOl08rnPfS6kx92wYQM//OEP+cEPfsB1113X7vd2u50FCxawcuVKioqKrO0VFRW88MILTJs2LaSezJiYmAvuK7vd3q4H81//+leb1+lyWb16NQCjRo2y2oa2PahOp5Onn376E7f105/+lJqaGv793//dCrHne+utt6x6LtWF6jVNs9080I8SExPTbkhcRDqXeiZFPqUGDhzItGnTuO+++/B6vTz88MMkJyfzn//5n9Zt7rnnHn73u9+xcOFCvvjFL1JZWclf/vIXhg0b1mbhSVRUFEOHDuWll14iNzeXpKQkhg8fzvDhwy9LrampqXz/+9/npz/9KYsWLWLp0qUUFBTwpz/9iQkTJvD5z38+pMe97bbbSE1NJScnp908zfnz55Oens5///d/s379eqZNm8ZXv/pVHA4Hjz/+OF6vl1/96lchtTtu3Dj+/Oc/89///d8MHDiQtLQ05syZw5IlS/jZz37G3XffzZQpUzh06BDPP/98m97YUGzZsgWPxwOcuzTQqlWreOedd7j11lut3tgFCxYQHh7ONddcw5e//GWampp44oknSEtLo6ys7BO1f8stt3Do0CF+/vOfs3//fm677TbrG3DefPNNNm7cyAsvvPCxHnPw4MEMGDCABx98kNLSUuLj43nllVcuaW7q+caNG8dLL73Et7/9bSZMmEBsbCzXXHPNx3oMEfmEum4huchn18UuDXT+5XRa/fjHPzbP/1NtvazMr3/9a/O3v/2t2adPHzMiIsKcPn26efDgwXb3f+6558zs7GwzPDzcHD16tLlu3bp2lwYyTdPctm2bOW7cODM8PPwjLxPUevmXf/3rXxf8/cWeyx//+Edz8ODBZlhYmJmenm7ed999Zl1dXZvbzJw50xw2bNgFH/eDlwbiQy5NtGnTJut2+/btMxcuXGjGxsaa0dHR5uzZs81t27a1eewLvSbnP9fzH6+8vNz83Oc+Z8bFxZmAVZPH4zG/853vmBkZGWZUVJQ5depUc/v27e3q/iSXBgoPDzcHDx5s/vznPzd9Pl+b269atcocOXKkGRkZaWZlZZn/+7//az711FMmYJ46dcq6Xb9+/czPfe5zH9r2hWzcuNG89tprzbS0NNPhcJipqanmNddcY65cubJdzR88Ni70nPPy8sx58+aZsbGxZkpKinnvvfeaBw8ebHe7ix1PpmmaTU1N5u23324mJCSYgC4TJNIFDNO8hFnlItJtFBUV0b9/f37961/z4IMPdnU5IiLyGac5kyIiIiISMoVJEREREQmZwqSIiIiIhExzJkVEREQkZOqZFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRkQ5mmibBYLCry/jUMU0T0zS7ugwR+QiOri5Azp0wW1paKC0tJRgMYpomdrudYDCI3W4nJiaGxMRE7HY7hmF0dbkXZJomLpcLr9dLVFQUkZGR3bZWOFev0+nE6XRimiaGYZCWltau7rq6OgCio6OJiIjANE3OnDlDS0sLdrudtLQ0oqOjP3E9wWAQl8uFz+ez2rqU/RcMBmlubqalpYXY2FjCwsI+8n6maVJZWUlTUxOmadKzZ09iY2M/8XPoKB/c5+np6URFRX3k/bxeLy6XC8MwiI+Px2Y799nZ6XRSV1dHcnIycXFxHV0+fr+f6upqqqurGT58eIe3F4pgMEh9fT319fUA9OnTh7CwMOv3NTU11NfXtwl2hmHQr18/HI4Lv420tLTgdDpxuVzWeS0qKoqEhIQLHt+1tbXU1dXhcDhITU0lOjqaxsZGTp8+TZ8+fYiPj//E5xTTNGlubqaqqopAIEB8fDwpKSnWsSGhq6qqoqGhAYCEhASSk5M7re1AIEB5eTkOh4Pk5OSLHpMfR0tLC9XV1dY5JCMjg6ioKFwuF1VVVcTGxlrPMRAIUFdXR1NTE4Zh4HA46NGjB83NzbhcLmw2G+Hh4SQnJxMeHv6JawtF6994a6a4HPvofAqT3URTUxMvvvgie/fupaGhgWnTphEWFsaxY8dITU3l2muvZdKkSZf9ALhcgsEgmzZtYvfu3cyaNYvp06d321rhXKB47LHHOHXqFEOGDKGpqYkbbriBYcOGtbndX/7yF+x2O4sWLWLkyJGYpskbb7zB6tWriYuL4zvf+Q7jxo37xPW43W7WrVvH+++/z5IlSxg/fvwl3a+5uZnXX3+dgoIC7rjjDnJyci7pfjt27GD58uWUl5fzwx/+kJkzZ36S8jvc2rVrWbNmDfHx8Xz3u99l5MiRH3mfgoICVq9eTXR0NF/+8petAPrSSy/x1ltvcfvtt3P99dd3aN1ut5udO3fy1ltvMX369G4ZJltaWti7dy9bt27lnXfewWaz8Ze//IWePXtat1mxYgUrV67E7/db2xwOB08//fRFQ8PZs2f517/+hc1mIyoqilOnTtHc3MysWbNYtGgRsbGxVjhsamriiSeeYOPGjaSlpfHtb3+bsWPHYhgGa9asITw8nGXLltGvX79PHCjPnDnD008/zf79+1m0aBH3338/kZGRn+gxBQ4cOMDf//536uvruemmm7jrrrs6pV3TNKmuruaHP/whvXr14v777ycjI+MTP25TUxPr16/ntddew+/38z//8z8MHz6cbdu28be//Y0xY8bw3e9+F4Djx4/z7LPPcubMGSZPnozP5yMtLY1du3bhcrkYPXo0hmGwZMkSevfu/YlrC4Xb7eaRRx4hPT2dpUuXXvY69HGsGzAMg6SkJG688UaSkpIAuOaaa/jGN77BVVddxf79+3niiSdoaGjo1kM+J0+eZNu2bZw5c6Zb1wlQWFjI5s2bSUxM5I477uDuu++mV69e7W63c+dOdu/eTXV1NQA2m4077riDmJiYy1pPS0sLhYWFbNu2jfLy8ku+n8/n4+jRo2zbto26urpL2u+GYTBv3jz69u37SUruNIZhcOutt37sfV5VVcXOnTvZt29fmxAUGxtLSkrKZelR/jCBQIDdu3fz5JNPMnDgQObPn9+h7YXK5XJRVFREZmbmh97uxhtv5IEHHrD+3X///R/6mrhcLmJjY7n55pv58pe/zM0330x5eTnPP/88R44csY7VYDDIli1bqKysbPcYsbGx3HHHHRQUFPDcc89RUVHxiZ6rYRjk5OQwderUT/Q40t78+fMveA7tDDabjZSUFBISErDb7ZflMRMTE5k2bRo9evRosz0yMpKUlBTi4+OtbTt27GD//v1kZGRw7733ctNNN3H06FHy8vIYNmwYX/ziF7nmmmtITEy8LLWFoqWlhW3btnHgwAGampou++N3364jITo6mtzcXOx2O6WlpdTW1uJwOFi7di2FhYX4fD569+7NtddeS1paGi+99BI7d+7EZrMxatQooqOj2bNnD0OHDuX222/n+PHjrFu3jpqaGuLi4khOTmbGjBnk5ubi9XrZsGEDu3fvxjAMevTowdVXX82AAQM4fPgwTz31FABjxowhIiKCgwcPkpiYyDXXXMOQIUN488032b17NwDvvPMOJ06c4PbbbyczM5O1a9dSXFyM2+0mGAwyfvx45s6dS3R0NKZpWj0YZ8+eJTc3F5fLxcmTJ7HZbMyfP5/FixdTWFjI2rVrqampISIigrFjxzJnzpwL9iiYpkltbS1vvfUWBQUFBAIBUlNTmTdvHkOGDOHgwYP885//BKCoqIg//OEP3HjjjfTu3dvq9XC5XDz77LN4PB58Ph+vvPIKeXl53HrrrW3azMvLY8OGDdTV1TFx4kQWL15MVFQUpmlSVFTEmjVrqKysxOFwMGLECJYsWdJm+BDODce+8847HDp0CIA1a9Zw9OhRlixZwpAhQzhy5AgbNmygurqasLAwBg8ezMKFC4mNjbV6JQFeeOEFNm7cyN13300gEGDdunXU1tbS2NhIZGQkM2bMYOLEiZc0zNLQ0MDvfvc76urqSEhIIDs7m1OnTuH1epk8eTKLFy8mPDwc0zTZtWsXmzdvprGxkYiICEaPHs3ChQtpbm7m73//O0VFRQAsXbqUd955h0AgwNSpU5k9ezb19fU89thjNDY2MmjQIG6//XZef/119u3bR3R0NHfccQdDhw694Gt84MABNm3ahMfjweVy0bNnT6655hr69evH0aNH2bBhA16vl7q6On71q18xceJEDMNgx44dVFZWUlxcbD1eZWUlK1eu5MyZMwBkZmaydOlSMjIy2LFjBy+99BKmaTJo0CAyMjLYvXs3CQkJ3HzzzRftLauurmbDhg04nU5mzZqF3W7HNE0OHTrEhg0b8Pv9OJ1Oevbsyfz588nNzcVms+H1enn33Xd59913AZg1axarVq0CoHfv3tx5550kJSXxxhtvcPDgQXw+H8nJySxdupT+/fsTCATYu3cvmzdvxuPxEBUVRVxcHIsXLyYrK6tdnTExMSxZssT6m7uYqKgo8vLyqK+vp0+fPixYsOBDj6WsrCzS09OtKQYZGRkkJSVRVFRERUWFFSaLiorIy8tj8uTJHD16tM1jGIZBamoqY8eOZdWqVUyYMIGUlJR2ox7/+Mc/2LdvHzabjUGDBnHDDTdQWlrKyy+/zPXXX096ejrLly+nsrKS6667zrqf3+9n+fLlHD582NqHubm5wP/fM3X48GF8Ph8JCQnMnTvX6mU6X2VlJa+++ioFBQVERETwpS99ibKyMlasWIHP52PRokUsXryYpqYmNm/ezN69e3E4HISFhdG/f3/mzp1LYmIiVVVVrFq1itLSUgKBADk5OSxbtozY2FgaGxvZsGEDBw4cICIigrCwMAYMGMC8efPaBBs49/fR0NDAqlWrKCgoIDIykpiYGEaMGMG8efMwTZPCwkI2bNhAWVkZDoeDAQMGsGjRIlJSUli9ejUbNmwAYObMmVRXV3Ps2DH69+/PNddcQ58+fTBNkxMnTrBixQoqKysZMWIEXq+33XFQWFjIG2+8QVVVlVXztddeS3h4OOvWrWPjxo3AueO8srKSkydPkpuby7Jly9i4cSP79u2jZ8+eXHfddfTt27fdvjdNkz//+c+UlJTg9XppamoiPz+fV199FdM0GT16NA6Hg8OHD5OSksLSpUsZNGjQBY9Z0zTZtGkTmzdvJhgMMnDgQFpaWto8lw0bNlgf+E3TZMeOHbz99tu0tLRQVFTEz3/+cwCOHTtGMBhk3759/PnPf+Zzn/uctW/37NkDnAusV199NdnZ2ezcuZOXXnoJgAkTJhAVFcWuXbvIzMzk1ltvpaSkhA0bNuB2uwkLC2PatGlMmjQJm83GY489RlFREYZhcP3117Njxw5qa2uZMGECCxYswDRNHn74YQAqKir429/+xqBBg7jnnnvahe9gMMiZM2dYu3YtZ86coUePHlYP7IdRz2Q31vpmEwgEiIiIIDIykkcffZQVK1YwefJkbrvtNt566y1+/etf43Q6mTZtGjabjby8PLZs2YLX6yUnJ4eGhgaOHj3Kj370IwoKCrjxxhu5//778fl8bN++nZaWFv7xj3/wxBNPkJWVxec//3nOnj3LL3/5SyorKxkwYACTJk0iLy+Pt956iz59+jBlyhQ2bdrEK6+8QnV1NbNnz2b06NEATJkyhW9961sMGDCAxsZGysvLue666/jOd75DTEwMTz31FCtXriQYDOLxePiv//ov3nnnHXJycsjJyWH37t0cPXqU5ORkpk6dyqFDh/j5z3/Ovn37+OpXv0pWVhaPP/44b7zxRrtFDa1zIR999FFee+015syZwwMPPMD+/fv57W9/y549exg2bBgLFiwAzr3hfeUrX2HEiBFtTlJRUVHceeedREZGEh0dzZIlS7jnnnusnmM4N5+ytLSUiRMnUlRUxMsvv8z27dsBKCkp4aGHHiIvL4/Pf/7z9O7dm2effZbnn3++Xe9heHg4U6ZMYciQIcC5T/j3338/OTk5bN++nd/85je8//77fOMb32DKlCm88sorPPzww3i9XhYsWMDAgQMBuP766/n6179OWloapaWl2Gw27rzzTh544AEaGhp47LHH2L9//yX1XkZHR3P77beTn5/P7t27qampYf78+ZSVlfGPf/yDVatWEQwGWbNmDb/+9a+prq7mm9/8Jn379uXpp5/mscceIyYmhkmTJtHU1EReXh779++3QuZjjz3G1q1bSUlJ4ZprriEvL4/i4mL8fj+LFy+mtraWwsLCD/0EnZeXR58+ffj617/O4sWLeeedd/jf//1f6urqyMnJYcaMGYSHh9OjRw++9rWvsWDBAubPn28dl63zYSsqKnjooYd45513WLx4McuWLWPnzp18//vfp7S0lJEjR9K/f38KCwt55513SE5OZsiQIWzdupW//e1vbXo9zz8Oq6urOXr0KCkpKcTFxVnHV0FBAQMHDuQrX/kKX/jCF9ixYwd//etfKSkpwTRN9uzZwyOPPILT6eRzn/schYWFVoibPHkyiYmJPPHEE/z973+nb9++/Nu//RtHjhzhRz/6EVVVVRw9epQnn3yS2tpa7r//fu666y4Mw7CC8gc5HI6PnDMbGRmJaZrcc889XHXVVWzcuJEf/ehHFBcXX/R4ioqKIikpCYfDgWmaeL1eGhoaiI6OJisrC5vNhsvlYtu2beTk5Fww6LbW17dvX7xeLwcPHsTtdre7zY033ojb7eb48eOkpqaSlJTExo0b2b9/Pzt37iQjI4O0tDSmTZvWZorEvn37SExMJCcnh40bN/Laa69RX1+Pz+fjscce4/nnn2f06NF861vf4uTJk/zmN79h06ZN7Z5zSkoKM2fOpLy8nIKCAlwul/XBOy8vj6qqKkzTZPPmzTz11FNkZWXxwAMPcO2111JeXk5dXR3Nzc386Ec/YseOHSxatIirrrqKFStW8Mgjj9DS0sLatWv5xz/+wZAhQ3jggQdYvHgxZ86cobGxsd3+8Pl8/PSnP+W1115j0KBBPPDAA0yePJmXX34Z0zQ5ePAgv/vd79i+fTv3338/ixYtYs2aNfz+97+nrq6OSZMm0bdvX/Ly8ti0aRMTJkygX79+rFq1irVr1+JyuWhqauK//uu/2L59O8OGDSMpKandMXbgwAH+3//7fxw+fJh7772XcePGsXr1an7yk5/g9/sZMWIEYWFh5OXlsXbtWmsO7vLly/nxj39MdHQ0ffr04Y033mDVqlU0Nze3e66GYXDXXXdZ8xa9Xi9jxoxhxIgR5OXl8d5779GvXz+GDx/Oxo0beeGFF3A6nRc81rZu3cof//hHTpw4wYwZM3C5XNY8UIDs7GzGjRtHMBi0esnHjx/P+PHjsdvt5OTk8J3vfIfvfOc71oeSiRMncu+999K7d2+eeuopnnjiCfr3788dd9zBmTNn+OUvf0l1dTUDBw5kyJAh5OXlsWbNGurr65k5cyZNTU28/fbbPPzww5SVlXH//feTlpbG7373O/bs2YPdbmfhwoW0tLRw5MgR9uzZw+LFi3G73Tz33HPs3buXmJgYvvSlLwGQmprKHXfcwec///l2Hx5N06SiooL/+q//4r333uPqq6/m/vvvv+C++iCFyW7q7Nmz7Ny5k3Xr1pGcnMwNN9xAfX09mzdvxuFw4Pf7cTgcBINBiouL2bVrF3369LG65FNTU7n11lu59dZbufrqq3nttddwOp0MGDCA3NxcYmJiWLZsGbm5uRQVFbFv3z6am5uJj4+noaGBqKgoSkpK2LJlC5GRkVb3/IABAxg1ahTjx48nKirKOpm1flIGCAsLsyb4pqamcuONNxIWFkZ5eTm9e/emqamJY8eO0dTUxM6dOzl9+jTx8fFMnTqVGTNmkJmZiWEYREdHExsby9tvv015eTlxcXE0NjZiGAY2m43ly5cTCATa7bvjx4+zdetWUlNT6dOnD8nJyQwdOpTTp0+zc+dOfD4fERERANjtdqKjo9stXDEMw5pjZxgGERERREdHt/nji4yMZPr06cyaNYthw4bhdDopLS0FYNWqVdTU1GAYBi0tLURFRREMBq3ewvMZhkFYWJjV2xIeHk50dDQ+n4+tW7dSWlrK0KFDSUlJoW/fviQlJbF161YKCwuJiIiwPlm2Bl+73c7w4cOZP38+zc3N1NTUkJGRQXV1NSdPnmzzSfti7Ha71QsQHx/PhAkTmDJlCpMnT6axsZGdO3dy6tQp1q9fT2NjI8OGDSM5OZmBAwcSERHB+vXrKS0tJSUlxeq9uuaaa5g4cSJXXXUVPp+PNWvWEAgE2vUuR0REXNKCiKuvvpoJEyZQUVFhLc5ofTN3OByEh4dbx0rroqbzj9NWb775JqWlpURGRjJixAiGDh1KTEwMFRUVrFq1iujoaCsM9uzZk+nTpzNkyBDi4+PJy8u76CrtpqYm6uvriYmJafN85s+fz6hRo6iqqsLtdpOSkkJBQQHV1dUEAgFef/11vF4vI0eOZMyYMSxZsgQ4F6oSEhKorq7mrbfewjRNwsLCCAQCGIZBbW0t69ato6mpCafTSVFREVu2bKG2tpaZM2detDfmUtx+++3cdNNNJCQkMH78eAYNGkRZWRmvvfYapmlSU1NDfn4++fn5FBQUtHkDhnPztVp7e26++WYGDhyIaZoUFBRQVVXFpEmT2r0urQzDsBZKlZeX4/P52t0mOjqa2bNn4/F4KCoq4uzZsxQWFuL3+zlx4gRnz57l9OnTjB8/vk07ubm5zJ49m7lz5xIREUFxcTHNzc0UFxezceNGevToQVZWFklJSYwYMYLKykree++9ds+vdYHF+a9zWFhYm16fYDCI0+mkubmZvXv3smfPHmv0JS0tjXfffZcTJ05gt9tpaWkhIiKCQCDA4cOHOXz4MPX19bjdbnbv3s2+ffuIiIhg4cKFFxw63b59O/n5+cTFxTFu3Dji4+OZPHky8+fPx+v1smvXLk6ePMmgQYNITU2lV69e9OzZk927d3PkyBHi4uKsDxijRo1i8ODBTJkyhUAgQGlpKU1NTWzZsoWzZ8+SkZHBjBkzuPrqq9vMnw0Gg1Y4z8zMpG/fvgwZMoSoqCjy8/PZtm0bPXv2JCEhATgXyubPn8/IkSPx+/3ExsayYMECq5OkdWTkQsdHdHR0m/N3TEyM9V44cOBARowYwcyZMwkEAlRVVVnTls4XDAZ58803aW5upn///syfP7/dMHfreeX8tsPCwqxjqvWDWWxsrHU+DwsLIzo6muLiYvbv34/b7SY+Pt4aMTpz5gxbtmwhKSnJmseYkpLCzTffzLx587juuusoKCigvLyclJQU6urqiIiIwO12s3btWlpaWkhKSrLqmjVrFoMGDWL48OE0NTVRVlZGIBCwpvW0zmGOioq64IjK22+/TXFxMdnZ2eTk5Fzy4kwNc3dT77//PsnJyUyePJmBAwcyevRoaxjZ5XKxd+9eiouLmTdvHg6Hg5SUFOvAsNls9OzZ0zrIY2NjrW75iIgI6002IyODjIwM9u7di8vlAuDgwYNUVFSQlpbG0qVLSUtLa1NX6xujYRjY7XZ8Pt8FAx2c+5RTVVXFc889x9mzZxkwYIAVpDweD16vl5qaGmv1eutK6vMn5vt8Purr6wkGg9TV1bFx40ZM02Tu3LnYbLYLvpG3BrrzT+atf0h1dXV4PJ7QX5jzREZGWqE0PDycQCBgvdGVlZVhmiZ1dXVs3rzZmqcYFRV10f31Qc3NzdabVmv9rUNjrc/zQvMeg8EgJ06c4OWXX8blcpGTk8Pp06eBcwHnUto//yQTFhZmrb5tPbF4PB5KS0utXqLWk3lruG2dvpCammo9TlxcnPU6w7lh4NaV9B90Kb2nmzZt4p133iEhIYGMjAy8Xi+GYVywp+bDVFRUEAwGsdlsVths/aBWVlbWpr7WUGmz2bDZbBfsJWvVup/Pv3/rG/nrr79OcnIyqampVk+Y1+u1ejTh3PF1oV7DyspKgsEgwWCQw4cP43Q6GTVqFKNGjSIzM5OsrCymTZvG7t27efzxx4mIiGDMmDHccsstIa1cDgaD+P1+6wNXZGSkVdPp06fx+/28/fbbPPHEE8C5Y/Q//uM/mD17NnBu7ur69espKCjgi1/8IpMnTyYsLAyfz8frr7+O3W5n//79nD59mmAwaAWmyMhIcnJy2lzF4sMurzR+/HhefPFFjh07xptvvsnkyZNpaGigvLycDRs2kJ6e3m5ftg7Bt67AbT2ftZ5Dzv97a/0bbGxspKmpqd1cuo9it9sZOXIkEydOpKCggF/+8pckJyczbdo0br75Zs6ePQucWxy4fft2YmNjmTdvnjVEPX78eIqKijh27Bi/+MUvSElJYcaMGdx8883t5v+Wl5dbVwM5PzTcdNNN1NfXW73yrb+z2+1WGDl79mybv7+YmBjsdrsVjlr3Uesc1/PPDz169LCeR+sUk9ZV/K3nh9bzdut7Umttra9Fazut7wOt27xeb0iX12r9O2p93EAgcMEP1K0jgaZpWm1fzlXPTqcTt9tt9QyXl5eTkZHB0qVL25wn4dw0m9bXJCUlxRr9KCkpsd4Dly5dSmJiYru/55iYGOt4Bj7WfjNNk7KyMoALfvD+MAqT3dSiRYsYM2ZMmzei1k99MTExXH311YwbN86aH5Went7m/h/8A0hJSeHEiRN4vV7rEisVFRXU1NRYvTYAM2bMYO7cuQDs3r273UH+YSspz/9dMBikqamJ999/n40bNzJ37lzuvPNODhw4wNatW4FzB26PHj0wDINAIGC9mbpcLutk1trLabPZ6NGjB1/5ylcwDIOKigry8/MveLC31uz3+60/otYAGR8f/7EuzfDBIPDB3ssLzd8BSEpKwjAM0tPT+cIXvkB8fDxNTU28++67bYbKL9RO6/4zTdNa4NBa//knwtagf/59A4GA9Wa0a9cu7rzzTm644QZeffVV3n///TY1Xiq/32+F5NZhpoiICFJTU63jprW+lpYWq6fsg8eOy+UiEAhYt01ISLDeyGw2W5u6LtQDcT6Px8Pzzz9PREQEN910E2PGjGHLli00Nzdbj3P+fjFNE4/Hc8E3huTkZKt9n8+HaZoXfQ4fZyVxTEwM0dHReDwe6zisqalhw4YNFBQU8Nvf/pY+ffpw9uxZ6w3cMAwSEhIoLi7G6/Xi9/vbDe0lJCRYb7DTpk3j6quvBmDPnj306NEDh8PB3LlzmTp1KiUlJbz99tts27aN/v37079//4+9crmhoYHt27czY8YMYmJiaGlpsV7D5ORk7HY748aNs4KaYRgMGjSIQCDAkSNH2LRpEwkJCXzpS18iKyuL999/n5aWFkaNGsWMGTOs47n1g9/5xwSce+1aQ3vrsPkHtV7aa8iQIRw+fBi3281DDz1EQ0MDb7zxBm+//Tb33HOPdby2uliwbn3dA4GA9Ube+pxjYmIueGmq1g/prTX7/f42H9xM0yQ+Pp5bbrmFxsZGTp48ydq1a1m7di0TJkywzgutI1HZ2dkEAgE2bdpEamoqdrudL3zhC9TX11NYWMi6det4/fXXmTZtmvW31Kr1mA4EAta+8/v9bN++nREjRlhzLFvPueefV1JTU9ud5y6ktUf0/H10/t9tWFiY9eGrdXtLSwvBYBDDMEhJSbH2S0e61L9Zu91uhcjW811rvZdDTEyMdYzMmDGDOXPmAOcWeZ5/5QQ49/7dWndkZKR1vLVOyzIMg6KiIurq6tocwx/n/OR2u9t8WGq9f+vr0poVLpWGubuJS/mD6t+/P0OHDqW2tpYTJ07g8/k4ffo0q1atsnqDPviYrduWLFlCeHg4xcXFnD17lkAgwGuvvUZJSQn9+vVj4MCB2O12tm3bhs/no6SkhHXr1l0wMF1M6wnK5/ORn5/P3//+dwzDsE5WrcNa5xs3bhzJycnU19ezc+dOtm/fbvUKwLk/8IkTJxIXF0dVVRX5+fm0tLSwfv166xPUB+Xk5DB8+HArLHu9XvLz80lOTmb06NEXXIF6sf0fHx9vBd033niDPXv2fOTJxTRNa3FCdXU1hYWF1hD3iRMnLvgGFhYWZr3Ju91uTpw4wcqVKxkzZgwJCQkUFBTg8XisIZrhw4czaNAga5gezr3Z7d27l9dee82qIxAIEAgEOHnyZLvnebH//6CGhgYOHjzIoUOH2LdvH+Hh4QwbNowBAwZYvUyFhYV4PB7OnDlDc3MzEyZMaDcHbt26dRw9epQDBw4AMGfOHGsIKC0tjdraWrxeLydPnrR6Ti5Wm91uJxAIWD10p0+fbjP82dq70NoLUlFRwYoVKygpKWn3Ws2ePZuEhARcLhenTp2iuLiYpqYma5jtQn9XH/TBbYZhkJiYSFZWFjU1Ne3mVbZexNzlclk9OXAu3MydOxfDMKzhzTfffLPNfXv16sXo0aNxuVzk5+fT3NxMZWUlL774Ig6Hg5MnT/LOO+/Qr18/Fi5cyKhRo6yhwIutdP2w5+TxeNi8eTN5eXkEAgFOnTrFsWPHiIqK4uqrr8Zms5Gdnc3ixYtZvHgxixYtIjMzk2PHjvG3v/2Nd999l127dvGXv/yF733ve9acNLvdzqxZs5g/fz7z5s1j3Lhx2Gw2IiMjGTt2LIMGDcLhcBAIBKz5aYMHD77oNUajoqIYN24cPp+PxMRE0tPTmT59uhVeWnt7Pkzrc+7fvz/jxo2jtraWyspKfD4feXl5xMXFMXbs2Av2SrZet7S1166kpKTNcGrrYrWjR48yduxYFi9eTO/eva3RoqlTp5KUlERlZSUnTpwgEAiwZ88e3n33XSIiIqxh8IkTJ7Jw4UIyMjIu2ns0YcIEMjMzcTqd5OfnW1cWePfdd4mLi2PUqFGkpaVx7NgxPB4PdXV1lJWVMWjQoAsueLuQq666ih49elBTU0NJSQlFRUVtrkTROpcvPDycsrIyamtrKSoqorm5md69ezN58uRLaudShBJIP3gfu91uXdKupKSEsrIyjh071mak48PeYz9qW1ZWFgMHDsRms7F9+3Z8Ph9nzpxh3bp1H3pcxsXFMWLECGJjYzl06BA1NTU0Nzezfv16ayrVpTzP1pGllpYW/H4/Tz75JKdOnWp3+2nTplkL5crKyi45TBtmd7+Gy2eAaZqUl5fz05/+lLq6Ovx+PykpKQwcOJD/+I//aHe7l156iSNHjpCYmEhKSgrXXnstubm5LF++nJUrV+J2u4mJiWHevHncfPPNRERE4Pf72bt3LytXrqS+vp7ExETGjRvH0qVLcTgcOJ1OXn31VbZv305kZCS9e/dmzpw5jB49mry8PP7whz9QX19PVFQUt99+O7t27eLIkSPYbDYGDhzI97//fWpqavjDH/6A0+kkOTmZW265hX79+vH0009z6NAhcnNz6dOnDytXriQyMpL58+dz4403cvr0aZ555hnKysoYMWIEpaWl5Ofns3jxYr7+9a8TCATYtWsXr732GnV1daSlpTFs2DCWLFnSZmHD+fuppKSEFStWWEEuISGBa665hgkTJnDgwAGeeuopysvLiYiIYNCgQdx7770XvDTKxo0befHFF7Hb7QwYMIAvfOELPPLII5w4cQLDMBg1ahQDBw5k7dq1VgD58pe/zMSJEzl48CDLly+ntraWpKQkcnJyuPnmmy84B6V14cXzzz9PQ0MDWVlZLFmyhJEjR7Jr1y5Wr16N0+nEbrdbq1XT09MJBoPs3r2bZ555BtM0SUtL4wtf+AKBQIBnnnmGkpISxowZg8PhYNOmTcTGxnLLLbdw4sQJtm/fjtfrJSkpie9///v079+/zb70eDxcd911JCYmMnbsWE6fPk1jYyMzZ87k5ptvtnqp3n77bd566y2r52/MmDHccMMNxMbGcuzYMX7/+99z/PhxvvKVr7Bx40a8Xi+zZ89m6dKlxMXF4fP5ePvtt1mxYgXR0dFMmDCBrVu3UllZSWZmJg899BC//vWvKS4uxjAMsrKy+O53v8v+/ft56aWXrLmra9eupbm5mX79+nHnnXeSm5vLY489xoEDB0hNTWXy5MkEAgHWr1+P0+kkKiqKz3/+88ydO5eSkhJefPFF64NMz549ueWWWxg4cCA7d+7kr3/9Kw0NDcTExDB37lwqKirYs2ePteL2Jz/5Sbsev5aWFlasWMGzzz7L1772NebNm2ddBqd1IUTr0GXrgrPvfe97pKWl8frrr/P2229jt9uZN28ejz/+OP369eOb3/wmw4cPp7Gx0boubXR0NCkpKSxevJjRo0dz4sQJXn31VWsY0uVyMX78eK699lqSk5Mv+Pfywx/+kOrqampqaoBzvd69evXiBz/4AS6Xi7feeotdu3ZZQ5eZmZksW7aMUaNGXfTLFA4ePMhjjz3W7g3PNE1uueUWrr/+equX8V//+hdvv/02VVVV2Gw2EhIS+MIXvsCUKVOshR4ej4dvfvObDBgw4KJTIw4fPszvfvc7Fi9ezHXXXUdDQwP/9V//Ra9evfjiF79IUlIS+/bt47HHHsPpdFpXDNi2bRtHjx7FZrORm5vLQw89RFNTEytWrODQoUMEAgFrRGjatGkX7B1tHb588skn8Xg8TJ48mcLCQo4fP05ycjI33XQTUVFR1lxht9uNzWZj4cKFzJ49m8jISI4fP84///lPTp8+TXJyMr179+bGG28kLS2Nt99+m/Xr11s9tWFhYVx99dVMnz69XY9r60KKF198kYKCAmJjY+nVqxe333476enpBAIB9u/fz+uvv051dbX1geD666+nT58+rF69muXLl1vz6O+77z6efvppKisriYiIYNq0afzbv/0bhYWFPP/889TW1jJ06FDKysooLi4mLi6Oe+65hylTprB//37r3G2z2cjJyeG2224jPj6eN998k+XLl1tzhz/3uc+xZs0aqquriYqKYtmyZezevZvjx4/jcDgYPnw43//+99vNRX3wwQc5c+YMhmGQnZ3N1KlTrXUC0dHR3Hnnnaxfv54TJ04QFhbG2LFjueuuu9pN4/L7/axcuZI33ngDh8PB4MGDOXToEE6nk+zsbKZMmcKWLVusaUNXXXUVI0aM4Pnnn7fmQA4fPpzMzEzWr1+P2+0mNjaWCRMmcO+99+JyuXjllVfYuXOn9T47d+5cRo0axeHDh/njH/9IfX090dHRZGdn85Of/MTqKd28eTNr1qzB7XaTmZnJmDFjmDNnDhERETzyyCPs27cPn89H3759ueGGG3jiiSdoamoiLi6OL3zhC0ydOpUVK1awbt064uLiGDBgAPfdd1+bkbrWD7n5+fm88sorlJaWkpyczC9+8Yt2x/sHKUxKl2q9FMPEiROJjY21hqeOHz/OF7/4xTaX8ZDO1RomU1NT+frXv86ECRM+9mMUFhZaYfLZZ58lPT29W38z0uXmdDp58cUXyc/P52tf+5q18v5iWudMlpSUMHLkSGw2G4cOHeLBBx9k5MiRfPOb3+yyix53BZ/Px+rVq3n77be57bbbuOqqq/RtNSLdkOZMSpfbvHkzJSUlZGRkUFFRgc/nY86cOUyfPr2rS/vM8nq9bNmyxVoQceTIEQYOHPixLrrrdrs5evSotYjovffeY968edbqzc+CHj16cOedd7Jt2zby8/M/MkzCuQUrr732GmfPnsXhcLB7926GDx/OokWL2s2tutK1LkJ74IEHyM3N/Ux9EBH5NFHPpHQp0zQ5fvw4NTU11qKT2NhYsrOzO+V7k+XCfD4fBw4coKGhwVrVOHTo0HYXR/4wHo+Ho0ePUltba63oHDly5GfydW29zuJHLX5p/e7owsJCaxVm6wW/e/Xq9bFWV14J/H6/dQkkEem+FCZFREREJGSafCIiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZLo0UDfg9/t56qmnuOWWW7q6FBEREfmMav0O9Q9eCP8j76fV3F3P7XYzduxY9u7d29WliIiIyGeUaZp4PB6Sk5M/1v3UM9lNBINB6zuWRURERDqb3+/H4/F87PtpzqSIiIiIhExhUkRERERCpjApIiIiIiFTmBQRERGRkClMioiIiEjIFCZFREREJGQKkyIiIiISMoVJEREREQmZwqSIiIiIhExhUkRERERCpjApIiIiIiFTmBQRERGRkClMioiIiEjIFCZFREREJGQKkyIiIiISMoVJEREREQmZwqSIiIiIhMzR1QXIOUVFxfTtO7CryxCRj5CSksJPfvIjli69uqtLERHpFhQmuwnTjMbnm9/VZYjIhzI5e/Y0hw4dUpgUEfk/CpPdhGEY2GyRXV2GiHwI0wwCDgyjqysREek+NGdSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQddvv5jZNE9M022wz/u8LcU3TxDAM6+fWbR/8f5vN1ma78TG+ULe1/db7fJz7ioiIiHxWdNswuX79ep555hnGjx9PWFgYgUCAm2++mby8PN59913uvPNOsrOzrdsfO3aMgoICrrrqKpYvX05tbS0PPfQQmzdvJjo6mvHjx2O32y+5fb/fz/Lly5kyZQp9+/btiKcoIiIi8qnXbcPk/PnzWbNmDddeey39+vXj8ccf57333mP+/Pnk5eVRXl6Oy+UiLS2N5ORkwsPDGTBgAHFxccyZM4d//etfeL1e0tPTiYqKoqWlhRMnThAIBIiIiKClpYW+ffsSDAY5c+YMNpsNu92O3+8nOzsbn8/HwIEDiYmJwel0cubMGetxIiMj6devH6ZpUldXR1NTE4FAgLS0NKKjo6mtraW5uRm/309SUhJJSUldvTtFREREOkS3DZPnCwaDmKaJzXZuiqfb7ebMmTMEAgEaGhq45557OHXqFIWFhaSlpVn38/v9HDx4ELvdzvz589m6dSsnT55kwYIFHDt2jBMnTjBu3DjWrl1LREQEI0eO5NChQ1RXVzNkyBDWr1/PggULSE9PZ/Xq1cTHx9O/f392797Nd77zHVwuF++++y4ZGRm43W7effddli5dypYtW4iPj8c0TcrKypg+ffpHPkfTDNDSUt1h+1BELocghtHUbgqOiMhnWbcOky0tLWzatIm4uDiio6OZNGkSNpuNiIgIhg0bRmZmJv/93/+NzWajT58+lJSUtLl/TEwMmZmZ1NbWEhUVRU5ODm63m6lTp5KWlsaf/vQn5syZQ9++fYmLi2PatGlERESwZs0apk6dSnp6OjabjfT0dAYOHEhkZCSLFi1i69at1NXVUV5ezq5du7jqqqsIBoMcOXKE2bNnU11dTV1dHZMmTSI9Pb1NTcFgkKeffpqVK1da2wKBAH5/E87Gjdij4zHs4Z2yfwEwgyRGR9AnMwOHI6zz2hX5VDJJSOjJ5MmTuroQEZFuo1uHSYfDwYQJE+jbty8Oh4OoqCiam5sJCwsjKirKGq6+VK1B1DAMoqOjaW5uBsButxMefi7AxcTEWNvPZ7fbiYmJsR7D5/Ph9Xrp2bMns2fPxmazMWXKFJKTk7nhhhvIy8vj5ZdfZsSIEdx0003W4xiGwbJly5g7d661zePx8OaBfFp++zYtNht04mIfR/ERpp58kx999d9JS0vttHZFPq1sNjvx8fFdXYaISLfRbcNkc3MzgUAAwzCIiYnB4XBgmiZerxev14vP58PlchEIBGhubsbj8eDxePB6vTQ3N9PS0kJzczNerxe3201LSwt+v5/y8nKqq6s5fPgwY8eOBc4Nm7vdbmpqajh06BBjx461wmJTUxMtLS14PB6rTb/fj8vlIjMzk4iICGpra4mPj+ell17i1ltv5eTJkwwdOpTY2Fg2btzY5nkZhtFuHqXb7Qa7A3r269R9DICziojoGFJSkttMERARERG5FN02TB49epQBAwZw5swZMjIySE5OBqCsrIzIyEicTicNDQ0MHDiQI0eO0NLSgmEYVFZWcvr0adLS0igsLLTCZ319PQ6HA5vNxo4dO2hsbLR6DKOjoykvL+e9997DNE2uvfZaa2j87NmzZGVl4fV68fv9nDx5koyMDIqKiliwYAFXXXUVhw8fxjAMbrjhBmJiYvB4POzYsQOv19umV1JERETkSmOYn5GZ5M3Nzbz00ktUV1fzxS9+keTkZEzTpKKighdffJHU1FSuv/56oqOjO702t9tN7KDRBJ8p6PS2Hcf3c2v+K/z6wa/Rs2fPTm9fREREuge/34/T6bQ68C5Vt+2ZvNzCwsKYPn06wWCQqKgoa3tcXByLFy8mIiICh+MzsztERERELovPTHoKDw8nJyenzbbW+ZiDBw/uoqpEREREPt303dwiIiIiEjKFSREREREJmcKkiIiIiIRMYVJEREREQqYwKSIiIiIhU5gUERERkZApTIqIiIhIyBQmRURERCRkCpMiIiIiEjKFSREREREJ2Wfm6xS7O8Pvw37qUKe3ays/iR0TwzA6vW0RERH59FOY7CZivQ1cs+/vnd6uzYCZk8YTFxfX6W2LiIjIp5/CZDeRmpTE73/8/U5v1zAMoqOjiYqK6vS2RURE5NNPYbKbsNlspKSkdHUZIiIiIh+LFuCIiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIXN0dQFyjmmaNDQ0dHUZIiIi0g3FxsZiGAaGYXR1Ke0oTHYTNTW1/OQnP+/qMkRERKSbCQYDXH/9dUyfPrWrS7kghcluorGxheefL+rqMkRERKSb8XpLsNsdCpPy4QzDgd2e2dVliIiISDdjGM24XK6uLuOitABHREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQ6bu5P6C0tJSTJ08SFRVFWFgYwWCQIUOGEBkZ2dWliYiIiHQ76pn8gJaWFjZs2MDx48cJBAK89957vPfee5im2dWliYiIiHQ76pn8gMzMTJKTk8nKymLMmDGUlJSwa9cuhg0bxrZt2wgEAiQnJzN16lTefPNNzpw5Q0JCAoWFhUyaNInTp0+zYMECmpqaePnll/nZz36Gw6HdLCIiIlcmpZwLME2TlpYW3G43xcXF9OnTh9WrVzNq1CgGDRrEI488Qq9evRg1ahT5+fnMmDGDMWPGYLfbKSsrw+VyMXz4cB599NF2PZqmaeJ2u/F6vdY2j8eDaZoEg14MwwCMTn7GIiIi0n0F6M7ZQGHyAjweDzt27KC4uJjs7GymTJnCQw89hGmanDp1itTUVNxuNzExMaSlpZGWlkbPnj1xu91s27YN0zSx2+3/FwzbMk2Tv/3tb7z44ovWtmAwSEuggUrfSsLDU7HbND9T5EpkBv3EGEF6piQRFhbe1eWIyKeE3+8iN3dAV5dxUQqTFxAVFcXEiROZPHkyAG63m4yMDKZOncqwYcPIy8sjMzOTxsZGbDYbhmFY/xwOBy0tLbhcLgKBQLvHttlsfP3rX+frX/+6tc3tdhPbZwDBe/8Hb7t7iMgVo66cQWUH+M9br6Fv375dXY2IfIqMGzeuq0u4KIXJDzh27BilpaXk5+czcOBAUlJSCA8PZ9asWezZs4eysjKqq6vp2bMnRUVFnDp1iuPHj5OUlERYWBh9+vRh//79NDY24vV62bVrF1OnTv3ohqPjYOGdHf8ERaTrnCkkfq+LsWPHMmjQoK6uRkTksjBMLVNuo7Gxkbq6OsLDw0lMTCQiIgLTNPH5fNTX12MYBuHh4cTHx9PQ0EBjYyNxcXHEx8djGAZutxun00lERAROp5MePXqQlJT0oW263W5iB40m+ExBJz1LEekSZwqZsfcF/nrfbQqTItLt+P1+nE4nycnJH+t+6pn8gLi4OOLi4tpsMwyDiIgI0tPT22xPSEggISGhzbbo6Giio6MBPjJEioiIiHza6TqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSRERERELm6OoC5P+YJniau7oKEelIPjcEA11dhYjIZaUw2U3YqkuI/sbUri5DRDqQ6W8hZ/FckpOTu7oUEZHLRmGym8ju24e8vL1dXYaIdDDDMDAMo6vLEBG5bBQmuxG73d7VJYiIiIh8LFqAIyIiIiIhU5gUERERkZApTIqIiIhIyBQmRURERCRkCpMiIiIiEjKFSREREREJmcKkiIiIiIRMYVJEREREQqYwKSIiIiIhU5gUERERkZApTIqIiIhIyDrku7l9Ph+maRIeHm5tMwyjI5oSERERkS7UIWFyx44dPPnkkwwYMIDRo0czfvx4kpOTCQsLw2ZTZ6iIiIjIlaJDwmRiYiI33ngjycnJFBYW8uijj5Kdnc2kSZMYOHAgUVFR6qkUERERuQIYpmmal/tBTdPENE1sNhumaeJ2uzl48CCHDh0iNjaWGTNm0KtXLwXK/+N2uxk9ejQFBQVdXYqIiIh8Rvn9fpxOJ8nJyR/rfh0y5mwYhjWc7fV6KSkpoampifr6el555RUeffRR8vLyOqJpEREREelEl32Y2zRNqqqq2LFjB/n5+Zw6dYqmpiaCwSBpaWnMmjWLrKwsVq1aRY8ePejdu/flLkFEREREOkmHhMkDBw7wwgsvkJWVxeTJkxk2bBgDBgwgOjoau92OaZpER0ezf/9+hUkRERGRT7EOWYCTkpLCAw88wFVXXXXB1dvBYJDY2FgqKio6onkRERER6SSXfc5kMBjE6/WSn59PdXU1F1rf4/f7yc/PJz09/XI3LyIiIiKd6LL3TAYCAYqLi/F4PERERFy4UYeDBQsWEBMTc7mbFxEREZFOdNnDpMPhID09nYSEBOLj4y94G5vNRkZGxuVuWkREREQ62WUf5rbZbGRnZ1NZWUlhYSEulwufz0cwGLzcTYmIiIhIF+uQ1dz5+fmsXr2ad999lwEDBtC/f3/69OlDYmIivXr1Ij4+XhcsFxEREbkCdNjXKV577bWkpqZSUVFBaWkphw8fxu/3s3TpUiZNmoTdbu+IpkVERESkE132MGkYBhkZGaSlpZGVlYVpmrhcLhoaGmhoaCApKemClwsSERERkU+fy5rqWr+T++zZs5SUlADnwmVMTIzVE9mjR4/L2aSIiIiIdKHLGiZPnz5NSUkJtbW1NDY24vF4CAaDmKZJMBjkjTfeYP/+/Re89qSIiIiIfPpc1mHu3bt3s3HjRlpaWoiPj6e8vJy+ffuSnJxMXFwcY8aMobS0lDFjxhAeHn45mxYRERGRLnBZw+SCBQsYOnQo27dv5+zZs7hcLrZs2YLH48EwDDweD/PmzdOcSREREZErxGUNk/Hx8QwZMoS0tDQCgQDx8fE0NjbS2NhIU1MTfr+f7OxsreQWERERuUJ0yGrupKQk6yLlycnJpKSkWD2TCpIiIiIiV44OuWh5QUEBzzzzDPX19dYlggYMGEB5eTmpqalMnz4dh6NDLnEpIiIiIp3osie6lpYWjhw5gsPhYN68eTQ0NHD27FmOHDlCY2MjN9xwg779RkREROQK0SHD3DExMUyfPp0FCxZYlwWqq6ujqqpKFy0XERERuYJc9lTncDjIzc2lpaWF+vp6AOx2OykpKQwZMoT09HT1TIqIiIhcITpkzuSpU6d46qmnePPNN5k0aRJDhw6lf//+xMTE4HA4MAxDgVJERETkCtAhq2DCw8OZNGkSERER7N69mw0bNhAMBklOTua2225j/PjxCpMiIiIiV4AOmTM5YMAA+vXrR79+/QgGg1RXV1NSUkJJSQlxcXGXu0kRERER6SIdEiZ79epl/Wyz2UhLSyMtLY2xY8de7uZEREREpAtd9gU4pmnS0tJCS0tLu98Fg0FM07zcTYqIiIhIF+mQBThbtmzhueeeo2/fvuTk5JCbm0tWVhZ5eXmEh4czceJEfROOiIiIyBWgQ4a5R4wYwS233MLx48fZv38/GzduxOVyYRgGX/jCF9Q7KSIiInKF6JAwmZqaysKFC1m4cCHBYJDKykr279/P3r176dmzpy5aLiIiInKF6PAvyLbZbPTs2dP6NpyWlhb1TIqIiIhcIS57mAwGg+zbt4/NmzeTnZ1t/YuLi8Pj8VBQUMCYMWM0Z1JERETkCtAhPZNOp5OioiKOHz9OXV0dhmHgcDjweDzcddddCpIiIiIiV4gOmTPZp08fvvrVrzJkyBBqamo4deoUFRUVxMbGMn78eIVJERERkStEh30DzpkzZ9i8eTN+v5+UlBSmTp1KQkKCvkZRRERE5ArSIcPcp06d4rnnnqOmpgav14tpmgwYMIDrrruO3NxcreYWERERuUJc9jDZ0tLCiRMnGDx4MFOnTsUwDOrr69m2bRsvvfQS9957LxkZGeqhFBEREbkCXPYwGQgEcDgcDBo0iN69ewPQq1cvcnNzWblyJfn5+aSnp2vepIiIiMgV4LKPN4eFhREWFsbp06fxeDzAuXmU4eHhDB06lPr6egKBwOVuVkRERES6wGXvmbTb7fTt25c9e/bwz3/+k8GDB5OamorNZuPAgQPExcVpiFtERETkCtEhC3D69OnD1VdfzcqVK3nvvfeIiIjAZrMRFxfH3XffjcPR4V+8IyIiIiKdoENSnd1uJzc3l6985StUVVVx8uRJIiIiGDBgAD179lTPpIiIiMgV4rKGycbGRkzTJCIigvDwcHr06EF8fDzZ2dnAubmTCpIiIiIiV47LFiZ9Ph+/+MUvAJg3bx6zZs3CbrdjGAaBQACXy0VcXNzlak5EREREuoHLtpq7uLiYuro6rrrqKvr169emB7Kuro6VK1dSXFyMaZqXq0kRERER6WKXLUyePHmS2bNns2TJEgYOHNjmW25iYmKIjY3lrbfeora29nI1KSIiIiJd7LKFSbfbTXZ29gXnREZFRbFo0SIcDgdnzpwhGAxermZFREREpAtdtjCZlJRETU3NBX9nGAaRkZEMHz6csrIyXbRcRERE5Apx2cLk0KFD2bNnDxUVFRf8vWEYREVF4XK5NG9SRERE5Apx2cJkSkoKI0eO5Mknn2T37t00Nze3CY1+v58TJ04QGxvbZj6liIiIiHx6XdbrTM6bN4/m5maefPJJUlJSyM7OJjMzE7vdTnFxMcXFxdx5553Y7fbL2ayIiIiIdJHLGiajoqJYtmwZubm5rFy5krVr1xIMBrHZbPTq1Ys77riD/v3768LlIiIiIleIyxomDcMgIiKCsWPHMmbMGJqbm6mqqiIsLIz09HTCwsIuZ3MiIiIi0sUu+3dzt/Y6GoZBXFycvvVGRERE5AqmlTAiIiIiEjKFSREREREJmcKkiIiIiIRMYVJEREREQqYwKSIiIiIhU5gUERERkZApTIqIiIhIyBQmRURERCRkCpMiIiIiEjKFSREREREJmcKkiIiIiITssn83t4TONM2uLkFERES6EcMwurqEj6Qw2U3U1zt5+OE/dHUZIiIi0g0YhsHgwYOYN28uDkf3jmvdu7rPkLq6Zn7+81VdXYaIiIh0A6bZwtChcfTsmc7o0aO7upwPpTDZTRhGOOHhI7u6DBEREekGgkEXhlFLMBjs6lI+khbgiIiIiEjIFCZFREREJGQKkyIiIiISMoVJEREREQmZwqSIiIiIhExhUkRERERCpjApIiIiIiFTmBQRERGRkClMioiIiEjIFCZFREREJGQKkyIiIiISsiv2u7lN08Q0TQAMw2izvXWbaZoYhtHm95+krcvxWCIiIiKfJldsz2RTUxO//e1v+cEPfkBRURGmaVJSUsJvfvMbnnzySZxOJ3/84x+prKz8xG3t3LmTDRs2fCq+jF1ERETkcrpieybj4uJYuHAhTz31FG+99Ra33normZmZLFiwgGAwiGEYjBs3jrCwMILBIOXl5TQ2NuJwOHC5XCQmJpKenk5FRQV+v59gMEhycjKmaVJcXEx8fDwulwubzUZcXBxxcXEA1NXVUVNTg2EYxMfHk5KSot5KERERuWJdsWESICwsjNmzZ3Pq1CnWrVvHsmXLrN+53W7Wr19PWFgYffr0YcOGDaSmphIVFcUrr7zCTTfdRGNjI++//z7Z2dnU1tZy+PBhRo4cyapVq0hISCA7O5umpiZM06SyspKBAwdSVlbG2bNniYmJYf369Xzxi18kLCysC/eCiIiISMe5osMkQFJSEhMmTOBPf/oTaWlpJCQkANCzZ09SUlIAKC4uxuv1MmXKFMLDw3n77bfp1asXe/fu5eTJk4SHh9PU1ERDQwOTJ0+md+/eJCQksHDhQjweD4WFhdTV1WEYBjExMTQ1NeF2u9m9ezc33XQTycnJVj3BYJCnnnqK1157rc22lpZGamtXYbM5APVkSkczCA8Pw2a7Yme6iIh8qplmgKiogdbIZ3d2xYdJgIyMDO6++27+8Ic/MHPmTLKystr83u/3Y7PZsNvt2Gw2IiMjgXO9lzk5OcyePRvDMAgEAtaLmpiYiMPhIDY2FrvdDoDP52Pz5s307duX8ePH8+6779LS0tKmLcMwuOGGG1iwYIG1zePxMGTqHLxf/zUKktIZwvdv5JZMO3d//vauLkVERC4iKSmR/v37d3UZH+mKDZOBQICmpiZcLhd+v5/+/ftzww038Morr5CVlYXH48Hn8+FyuejZsydHjx6ltLSU6OhoKioqMAyDQYMGcfDgQbxeLw0NDRQUFDBt2jS8Xi8ulwuv14vD4cDtduP1eq3/wrmA2NjYSENDA+np6da8ScMwSExMJDEx0arV7XZDVAxMW3bB5yJyuRmN1fRJcTJp0sSuLkVERD7Ep2HdxRUbJr1eL2fOnCEQCNDY2EhSUhLjx48nGAySkJBAeXk58fHxOJ1Ohg0bRm5uLgcPHiQ6OpqkpCSioqIYP348Ho+HPXv2EBERwciRI/F4PMTExNDQ0EB1dTUJCQk0NTURHR1NbW0tM2bM4MCBA/h8PoYPH87JkyfJycm5tKI/BQeMXAH+7/JY8Ok4SYmISPdmmOZ57yyfUU6nk4MHD2IYBj6fj/Lycm666SbCw8M7pX23203soNEEnynolPbkM840iXjjb/wwxckP//PBrq5GRES6Cb/fj9PpbLPW41JcsT2TH0d0dDQ5OTnWJYDGjx/faUFSRERE5NNMYZJzlxDKyMjo6jJEREREPnV0XRARERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETF+n2F0Eg9BQ29VVyGeCCV4XptnVdYiIyJVAYbKbcLidpKz/a1eXIZ8FJkSWH2fgtMVdXYmIiFwBFCa7ibSYSJ64dmJXlyGfEXb7ZCaNG9fVZYiIyBVAYbKbiI6KYtG8OV1dhoiIiMjHogU4IiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZI6uLkDOaWho5Mknn+7qMkRERLqNyMhIJk6cQE7OwK4uRT6EYZqm2dVFfNa53W4SE9NJT5/R1aWIiIh0Gzabiy9/eSHf+953u7qUzwS/34/T6SQ5Oflj3U89k92EaYbh8/Xv6jJERES6DZ+vhNramq4uQz6CwmQ3Yhh6OURERM4xMQx7Vxchl0ALcEREREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCdln7sugm5qaOHToEE6nE5vNhs/nY8SIESQlJbFt2zbCwsKYPXs2hmF0dakiIiIi3d5nqmfS4/GwadMmqqqqGDFiBCNGjCAiIoJ3332XyMhIbDYbBQUFAJimiWmabf4/lH8iIiIiV7LPTM+kaZrU1tayf/9+7rrrLjIzMwGIj4+nsrKSsLAw4uLicDqd/PGPf6SpqYlrr72WIUOG8Morr9DY2IhpmowaNYrRo0fz5JNPcuDAASZOnMixY8e4/vrrGTVqFO+//z67du0iLCyMvn37MnfuXGy2S8vsphnsyF0gIiLyqaJOmU+Hz0yYBGhoaMDj8dCjRw8Mw6C5uZm6ujoiIyMJBAIAOJ1OHnzwQTZu3EhhYSG5ubn07duXXr16UVpayuHDh8nKyuK2224jPz+fWbNmMXToUHbv3s2IESNISUlh1qxZxMXF8atf/YopU6YQExNj1WCaJkVFRZSWllrbvF4vwaAPj/c4BgagIXaRzmYYBna7Hc1wEek+7HYn0dHRXV2GfITPVJgMDw/Hbrfj8/mAc+Fyz549FBcXc/fddwPQp08f7HY7UVFRuFwuvF4vR44coba2Fo/HQ11dHX6/n/DwcKKiokhJScHtduPxeAgEApw6dYqKigp69uyJ1+ulsbGxTZgEOHDgAJs2bbJ+9vv9BCId1M8eCIZd8zVFOlsgQNrRzVwzbTJpaWldXY2I/J+oqCjmz5/X1WXIR/jMhEnDMEhKSiIjI4Njx46RnJxMz549GTVqFHl5eQSD54aY7Xa7dXsAl8vFpk2b+Mtf/kJ5eTnl5eXtHtcwDEzTxOfzcejQIcaPH8+ECRN45ZVX2nXRG4bBsmXLWLZsmbXN7Xbz+OqNmA88AoA69UU6mc9D+l+/wv33f4XRo0d3dTUiIp8qn5kwCefmRy5atIht27aRn59PREQETqeTiRMn4vf7OXjwIIWFhRw+fJgjR45QWlrKhAkTmDx5Mn/729+Ijo7m+PHjHDlyBJfLRXl5Ofv376eiooKTJ09y7NgxBg8ezJYtWygqKqKhoYGNGzdyxx13qLdRRERErkiG+Rmb3WqaJoFAoE2Poc1mw2az4ff7MU0Tu91OMBjENE0cDof1/633t9vt1uM4HA5M0yQYDFq9msFgEMMwCAQC2Gw2HA7Hh4ZJt9tN7KDRBJ8p6NgnLyIX5vMw8q9f4R8//KZ6JkXkM8vv9+N0OklOTv5Y9/tM9UzCuWFmh+PCTzssLMz6/9ZgCFx0NfbFHqf1vhf7vYiIiMiV4jN1nUkRERERubwUJkVEREQkZAqTIiIiIhIyhUkRERERCZnCpIiIiIiETGFSREREREKmMCkiIiIiIVOYFBEREZGQKUyKiIiISMgUJkVEREQkZAqTIiIiIhIyhUkRERERCZmjqwuQc2yNtUT+40ddXYbIZ5IRDGBrdhIWFtbVpYiIfOooTHYTqdHh/GruoK4uQ+QzyTCgX7/FDB06tKtLERH51FGY7CbiYmP5/Ofv6OoyRERERD4WzZkUERERkZApTIqIiIhIyBQmRURERCRkCpMiIiIiEjKFSREREREJmcKkiIiIiIRMYVJEREREQqYwKSIiIiIhU5gUERERkZApTIqIiIhIyBQmRURERCRkCpMiIiIiEjKFSREREREJmcKkiIiIiIRMYVJEREREQqYwKdJNHDlyhIqKiq4uQ7pQMBhkw4YNXV2GdLHDhw9TWVnZ1WVIFwoEAmzcuLGry7hkjq4uQP5/pml2dQnShVasWMGUKVNIS0vr6lKki7S0tPCzn/2MuXPndnUp0oVee+01Zs6cSWpqaleXIl3E5/Pxs5/9jDlz5nR1KZfEMJVgupzH4yEhIYGMjIwObaelpQWPx0NcXFyHttPY2EhkZCRhYWEd2k5NTQ3Jyckd2gZ03n6rq6sjMjKSqKioDm2npqaGpKQkDMPosDZM06S2trbDXx+fz4fP5yM2NrZD2wGora0lMTGxw/fb2bNn6dWrV4e1AZ233zrrXFBdXU1KSkqHtgGdey6IiooiMjKyQ9vpjHOoaZrU1dWRlJTUoe14vV78fj8xMTEd2g503jm0K84FsbGx/OAHP+DWW2/9WI+jnsluwGaz0a9fP/Ly8jq0nXfffZcVK1bwu9/9rkPbefDBB7nmmmuYOXNmh7YzbNgw9u/fT3h4eIe2s2vXLv7xj3/w2GOPdWg7P/jBD5g5cyYLFizo0HZGjx7N9u3bOzS0Njc3M336dPbt29dhbQC88cYb7Nixg5/+9Kcd2g7ApEmT2LBhQ4cGCZ/Px7hx4zh06FCHtQGwadMm3njjDX71q191aDvf+MY3uOmmm5g2bVqHtjNkyBAOHTqEw9Gxb2nbt2/nhRde4NFHH+3Qdr7//e8zb968Du+hHjlyJLt37yYiIqLD2mhqamL27Nns3r27w9oAWL16Nfv27eNHP/pRh7YDMH78eDZv3tyhH8Y8Hg8TJ07k/fff77A2ADZs2MDbb7/NL37xC2tbKCFZYbKbMAwDu93eoW3Y7fZOaccwDGw2W4e3A+eeU0e3Y7PZrqj91hnttD72lXJMw///N9qRbdls56axd8Yx3VnHWmf8jQKd8nyutHMBdPw5tLP+RjvrmG7VGeeCztpvl6MdLcD5DElJSWH06NEd3s6oUaM6Za7PokWLrDffjpSUlMTYsWM7vJ3OMn/+/A4/QTkcDubPn9+hbQD07NmTYcOGdXg7AHPnzu3wnq/OkpaWxsiRIzu8nTFjxnTK8HNnnQuSk5MZM2ZMh7fTWRYuXNjh+81utzNv3rwObQMgIyODoUOHdng7cO4c2tHngo4cQj9feno6I0aM+MSPozmT3YDP52PkyJHk5+d3aDstLS14vd4OnyfV1NREREREh8+TqqurIyEhocP/6Dprvz300EPMnDmThQsXdmg7nbHfTNOkvr6exMTEDmsDzv3ttLS0dMo8qfr6enr06NGh+83r9TJ27FiOHDnSYW1A5+23zjoXdMZ8Vui8c8H3vvc95s2b1+Eh7Eo7F/j9fqKjozu0Heic/ebxeJgwYUKHT3m5XOeCK+Nj9qec3W7nP/7jPzq8nbCwsA4/qQOdshgC6PCTU6vO2m+LFy+md+/eHd5OZ+w3wzA6pZ3w8PAOnzPbKiEhocPbcDgcPPjggx3eTmftt846F3T04o5WnXkuyMrK6vB2dC4ITWc8H4fDwbe//e0Ob+dy7Tf1TIqIiIhIyDRnUkRERERCpjApIiIiIiFTmBQRERGRkClMioiIiEjItJq7i/l8PoqLi4Fzq6p69ep1xVzLTj6cx+Ph5MmTxMbG0rdvX2t7WVkZDQ0NOBwO0tLSOvyr26RrmKZJZWUlTqcTwzCIjIwkMzMTu92Oy+WivLyclpYWoqOj6d27d6ddd046l8fj4ezZswD4/X7i4+NJT0/HMAzOnj1LY2OjzgWfEcFgkDNnzhAIBOjXr1+7c0FMTAy9evXqlucC9Ux2sT179rBnzx4qKirYvn07x48f7+qSpBO0tLRw9OhRVq9ezbvvvmttr6+v59VXX6WyspJDhw6xe/dufD5fF1YqHcU0TTZu3MjZs2eprKzktddeo6ysDL/fb732VVVVvPbaa9TU1HR1udJBampqyMvLo7q6mqKiItauXUtDQwN1dXW8+uqrVFVV8f7777Nnzx6dC65w1dXVLF++nPXr19PS0oLf77de+6qqKl599VVqa2u7uswLUpjsQl6vl7fffpsJEyZw1VVXkZ6ezsGDB/H7/V1dmnQwm81G7969ycjIaLN937592Gw2pk2bxrBhwzh16lS3PXnIJ2MYBlOnTmXatGlcddVVuN1uzpw5Q3NzM0eOHGHgwIFMnTqVHj16sH379q4uVzpIUlISM2bMYPz48QwaNIjq6moCgQD79u3D4XAwdepUhg0bxsmTJ6mrq+vqcqWDeL1eCgsLCQsLIzIyEjh30f+8vDxycnKYOnUq8fHx3fZcoDDZhRobG/F4PPTo0QObzUZMTIy1Ta5sdrud1NTUdhdAPnPmDOnp6QDExMTg8Xhobm7uihKlE/Tt2xe73U5jYyOGYdC/f398Ph9Op9P6tp3MzExOnTrV1aVKB4mKiiI+Pp61a9fy9NNPM336dHr06HHBc4HL5eriaqUjmKZJeXk5VVVVDBkyxPqKS5/PR0NDA/Hx8d3+XKAw2YUMw+D8a8a3/n93nA8hneODx4RhGDoerlCtr6vH42H79u3MmTOnzXfaf/A4kCuTaZqYpsnnPvc57r33XrZt22bNo5fPhpaWFlavXs2YMWPwer243e42vdCt5wLTNLvtuUBhsgvFxcURGxtLbW0twWCQpqYmevToQURERFeXJl2kX79+lJWVYZomTU1NREZGdsr3TkvnM00Tt9vN7t27SUxMJCcnh6qqKiIiIkhMTKS+vh7TNDlz5gwDBgzo6nKlg5SXl1NdXQ2c64GMioqipqaGrKwsa2FOY2MjUVFROhdcobxeLykpKRw9epTjx49TWlrK/v37iYiIICEhAafTiWmalJSUdNtzgZYNd6Hw8HDmzp3Lrl27KC0tpaKiggkTJmg192dEQUEBxcXFBAIBCgoKGDRoEKNHj+bo0aNs3LgRp9NJdnZ2p30HuXQu0zR588032b59O4MGDWLfvn1kZGSwZMkShg8fTmFhIU6nE5fLxeTJk7u6XOkglZWVHD16lF69etHU1ERMTAx9+/YlMjKSo0ePsmHDBurr6xkwYIDOBVeouLg4brnlFmpqaigpKaG5uZmMjAxiYmIYOnQohYWF1NXV4Xa7u+25QN/N3cVaWlooKysDICwsjNTUVIXJz4ja2lpqamowTZOUlBSSkpIAqKqqorm5GbvdTlJSknojrlCmaVJUVERTU5M1dJWamkpaWhper5fq6mr8fj9RUVGkpaV12+Et+WTcbjdVVVXYbDaCwSBRUVGkpKRgGIbOBZ8xbrfbuqJDYmIiKSkpn5pzgcKkiIiIiIRMcyZFREREJGQKkyIiIiISMoVJEREREQmZwqSIiIiIhExhUkRERERCpjApIiIiIiFTmBQRERGRkClMioiIiEjI9FUrIp9xl/K9BR39jQsul4sVK1awa9cuJk6cyO233/6R9/lg3YZhXHBbRzFNk5aWFrZs2cKcOXMueJvW9s+v65PUZJom5eXlvPrqq9TX1xMTE8PSpUvJzs5uc5uP21Yo93nppZfYvXs3vXv35pvf/OalPYFO5vf72bVrF6+99hp9+vTh3//934mOjv7I+7Xuj/P3xeV6Dc+v7dSpU0RHR5OZmdktv9VE5FIpTIp8xvn9fv73f/+XQ4cOYbPZSElJwefzERYWxsyZM1m6dCkREREdWkNUVBTLli3jvffeu+S2gsEgeXl5NDQ0MGHCBMLDwzFNk127drFt2zbuuOMO0tPTO6Re0zSprq7mySefZMaMGQCUlZWxevVqSktLCQ8P58tf/jIpKSkANDc38/DDD7N06VJGjhwZcrtNTU08+uijTJ06lcmTJ/Pee+/hcrna3KakpIT8/HwmTZpEfHz8JT2u3+9n586dxMXFMWrUqEu6z7Jly8jPz//Yz6Ez2e12xo8fz+HDh3G73Zcc2N5//33KyspYtGgR8P+/3r/97W+54447GDFixCeuzWazUVdXxxtvvMGtt95KamqqAqV8ammYW+QzLiwsjIceeoi0tDSmTZvGo48+yl/+8heuv/56XnjhBTZu3NjhNRiGgdPpxO12M3DgwEu6j8/nY/PmzRQUFGC3263t0dHR5ObmEhsb21Hl0tDQwAsvvMCYMWOYPHkyjY2NrFmzhn79+vHDH/4Qm83Ge++9B0BjYyPPPvsso0eP/kRBEiAvL4/6+nqmTZtGUlISS5YsYejQodbvTdPkyJEjbN++HZ/Pd8mP6/F4WLduHWfOnLnk+9jtdkpKStr0inY3hmHg9XpxOp307t0bh+PS+k/efPNNjhw50u6xcnNzL9sHFJvNRm5uLi0tLeTl5V3SCIFId6WeSRHB5XJRUVHB/PnzgXNvnGPHjiUQCFBVVQVAXV0dR48epampCbvdTm5uLr169QJgx44dVFVV0bdvXwKBAOXl5URGRjJixAjS09N5//33KS4uJiEhgenTpwNQWVnJnj17mDNnDpGRkZSVlREIBOjbt2+b2qqqqigsLKS5uZlgMMiYMWNISUlh/fr15Ofnk5mZyVtvvUVubi7l5eVUV1eTk5NDVFQUgFXP8ePHcbvdREdHM3r0aOLj4ykqKuLw4cMEAgEmTZpEfn4+LpeLwYMHk5WVhc3W/vN2IBBg7969+P1+xo8fj81mo7q6GqfTSW5uLg6HA5/PR3h4OG63m7feeou4uDirl+vDBINBCgoKKC0tJRAIkJKSwsiRIzEMgxMnTrBp0yZaWlrYvHkzvXv3Zty4cW3qOnToELt27aK+vp4tW7aQkpLC9OnTMU2TyspKCgoK8Hq9OBwOhgwZQnp6OvX19WzatInTp0+TlpbGG2+8wcSJE0lKSiIYDFJRUcHJkydxuVyYpsm4ceNISUmhurqaxsbGi4bJ6upqDh48SENDA+PHj+f48eM0NTWRkZHB8OHDiYyMxDRNGhoaOHr0KI2NjZimSU5ODllZWRiGwaFDhygqKrKGgouLiwkEAgwZMoTs7GzOnDnDkSNHCAQCLF68GJvNRkNDA3v27GH06NEkJibS2NhIfX09vXr1sj50tPY0ttYUCAQYOnQoSUlJ7Nu3j7y8PLKzs3njjTfIycmhubmZ06dPk52dTXJysvUYZWVlFBYW4vF4iImJYeTIkcTHx+N0Otm9ezeNjY1MnjyZoqIiamtr6d27N4MHDyYyMhKA+Ph4EhMTOXbsGJMnT7a2i3zaqGdSRDh9+jSmabYJcgUFBYSFhTFgwADKysp44YUXOHPmDNHR0Zw9e5Z//vOflJeXA+feWN966y1eeOEFKioqcDgcbN68mVdffZXGxkYiIyPZuHEjW7ZssR7/8OHDvPjii1ZgO3v2LElJSdactmAwyN69e/nnP/9JU1MTPp+PTZs2UVZWBoDD4aC+vp4+ffoQExNDeHg4hmGwceNGjhw5Ys2hPH78OC+++CJOp5OYmBi2bt3KCy+8QEtLC8FgkPz8fJ566ineffddampq2Lp1K88888xFe/Zaw8rAgQPp0aMHcC7Ieb1eTNPk/fffp66ujhEjRrBr1y4aGxu5+uqr2/SeXsz69etZtWqVNdz56quvsmXLFgzDwG63W883Pj6+XfAwDINAIEB1dTV9+/YlOTnZ2penTp3ipZdeoqamhsjISE6ePMm//vUvqqursdlsNDY2AtCvXz9iYmKw2+1WaH799ddxu93Y7XaeeeYZ6uvrAaxezKysrAs+F7vdTmlpKc8//zyvv/46wWCQ+vp6XnzxRQ4ePEgwGKSuro7ly5dz7NgxIiMjqa+v5+9//ztFRUUAREREsHPnTp5++mkOHTqE3W7n0KFD/PWvf6WqqoqwsDAOHjzImjVrrJ69kpISXn75ZWv4v7GxkUAgQI8ePbDZbASDQY4ePcprr71GXV0d4eHhvP766xQVFWGz2XC73TidToYMGWIdV5GRkezcuZP169dbr01BQQFPPfUUTU1NREVFsWPHDl5++WWCwSBwbtrDyy+/zOrVq6msrOT48eM8++yzbXp/DcPAZrNRX19v3U/k00g9kyLC8ePHsdvt9OnTh0AgwMmTJ3nuueeYOHEiQ4cOZcWKFbhcLubNm0dSUhIZGRk89thjnDx5kp49e5Kbm4vdbmfo0KHMnDmTqKgo4uLiePbZZ5k9ezaDBg3C7/e3CR5FRUVkZmZacx3LysrIyMjAZrNhmiYFBQUsX76ca6+9ljFjxlBSUsLBgweJjo7GZrORnZ1NfHw806dPp3///gDExMQQHR1NSkoKhmHgcrl44oknGD58OAsXLiQ8PJzw8HD++Mc/MnfuXAYMGEDPnj2Jiopi0qRJpKenExkZyYoVKwgEAu32k2ma1NXVUV5ezty5c62A2LNnT/r3789TTz1Fjx49+Pd//3dcLheHDx/mqquuYsWKFZSWljJlyhRmz559wR7PgwcP8uKLL/KNb3yDkSNHYpomx44d4/XXX2f27NmkpqYSGxvL6NGjmT59ershW5vNRmZmJvHx8YwdO5bp06djGAb19fWsXLmSuLg45s6dS1xcHCkpKfz5z3/m9OnTjB07lsTERFJTU5k/fz5RUVFW28uXL2fZsmWMGzeO4uJi7Ha7Ncx7+vRpUlNTL7qgJTExkeTkZCIiIpg1axa5ubm43W6Ki4vZtm0bI0aMYN26dZSWlvKlL33J6iXdunUre/fupX///uTk5FjPa86cOSQmJjJkyBC+8Y1v8P7771u92q09mXCuJ7v1OIBz4d9utxMTE4NpmlRUVPDiiy8ydepUZs2aRTAY5Nlnn7WeS3JyMuHh4SxatMiac2qaJna7nczMTGw2GzU1Nfztb39j1KhRzJ8/n/DwcAKBAE8++STLli0jOTmZgQMHWr3zo0ePpqioiL/+9a80NDRY+6ilpQW3233Jw+8i3ZWOYBGxhoD/+7//G9M0iY2NZeHChcyfP5+SkhL27dvHrbfeSmJiIoZhEBYWZg1RBoNBPB4PgUCAUaNGERMTA0BcXBxerxePx0NTUxNVVVVW6DNNk1OnTllDpD6fj8rKSvr372/1Dr3zzjv079+fkSNHEh4eTlNTE8Fg0OoNPHHiBLGxsaSmplqP6fV6aWhosBa+7Nq1i7KyMr761a9aC3uio6Px+Xw0NDRgGAZnzpxh9OjR9O3b1wokrb1YH2SaJqWlpZimSXJysnX72NhYbrnlFgKBgDX/84UXXmDkyJGsX7+eUaNGMW/ePP7617/Su3dvBg0a1OZxg8EgGzZsICkpiVGjRllth4WFWdMMnE4nDQ0N9O7d+4K9nKZp4na78Xq91uvUuvq7oKCAe+65h7i4OOv183g8uN1uAE6ePGkF6dZ6nnvuObKzs5k0aRI2m43jx4+TlpZGbGwspmly+vRp+vXrd9FFI63BbfDgwfTv3x+Hw0FERATh4eHW/NiNGzeycOFC0tPTMQyD8PBwgsGgFbhM06SkpIQlS5ZY+zs+Pt66jdfrpaKigtGjR1u3r6qqIikpibCwMILBILW1tURHRxMbG0swGGT16tVERUUxY8YMIiMjKSwsBCAzMxM414ubkpJCXFxcm+dSVFTElClTANi9ezclJSX84Ac/sI6r8PBw67hKTk6mrq6OjIwMcnNziYyMxG63ExER0WaBWXNzM/X19R9rPqdId6SjV+QzLhAIcOrUKWbMmMF3vvOdNr8zTZOamho8Hg/JyclWyGlubsbtdpOSkmL11ISHh1uhIBgMcubMGeLi4ujRowfFxcUEg0H69esHnFuVXFlZycyZMwGor6/H6XRaPUyt89muu+46oqKiCAQClJaWEhsba73Jnzx5kpSUlDYLbc6ePUtYWJgVJvfs2UNMTIzVLkBxcTERERGkpqbi8XgoLy9nwYIF1vOtrKwkPT39ovMlT58+TUJCghVqAWsY2m6309zczIoVK8jKyiIyMhLDMJg4cSI2m43Y2FicTme7x62vr+f06dOMGDHCCmeBQICKigp69+4NYIXf2NjYiwa41sdOSEgAzoXC4uJiwsPDrd5a0zRpbm4GsPZdUVERV111lfW45eXl5Ofnc+2111r7oaCggAEDBliLWsrKypg4ceIF6wDwer3U1tYycOBAKyg1NDTQ0NBAVlYWJSUlNDc3W4H0Qh8G6uvraWpqIjc316rt9OnTVi9h67zN/v37YxgGPp+Pqqoq0tLSCAsLw+fzUVpaavU6+nw+du7cydKlS62ey4KCApKTk61eyKKionbzQCsqKnC73WRlZWGaJoWFhaSnp1sfnODcHODWY8/v91NdXU2vXr2sgN7U1GS9fq0aGhqoq6u7YE+zyKeJ5kyKfMbV1tZSX1/frresVSAQICwsjPDwcODcZWSKi4vp0aMHGRkZwLnenIiICGvRS0tLC7t376Z///707NmTs2fP4nA4SEtLA7AWPgwYMAA4t7jH5/NZYdTlctHS0mL1sPl8Pg4fPkxKSoo1DHv69Gn69OmDz+fD6XRaw/NxcXEkJiYC5wJNbGys1ZPX0tLCrl27GDRoEL169aKiogKXy2WtIPd4PFRVVX1o75/T6SQ2NvaCw7ter5c1a9ZYw6TV1dUkJiYSERFBS0sLzc3NVm3na52/2RoCAUpLSykvL2fWrFnAueARFhZm7eMPag2OPXr0ICEhgerqavx+Pz6fj8jISKtHzO/3c/ToUTIzM8nMzMTj8VBZWUmfPn1wu900NjZy4sQJHA6HFcJbF8m0hqyampo2r9+FOJ1O6urqrF7e1l7G+vp6xowZg9/vx+FwtAlkhw4dIiIigmHDhgHnjivACu7BYJBt27aRlpbGkCFDqK+vx+v10rNnT+DcsXz69Gmrp6+lpYXKykpSUlKIiIiwwmmfPn2sfbFnz542YbSsrIzs7GwCgQBOpxO/309RURF2u91acNbS0tKm59LlclFYWMjYsWOJjo6mubmZyspKevXqZfW2VldXEx0dbd2vdcqEaZoX/fAi8mmho1fkM+7MmTP4fD4GDx7c7neGYZCYmEhkZCRVVVVWz9zOnTuZOXMm6enpmKZJcXExLpeLs2fP4na7efPNNykvL2fhwoVERUXh9/sJBoO4XC7q6urYvn07gDVEXVtbS1RUFFFRURiGgcPhsBZotLS0sG3bNo4dO0ZaWprVQ1VdXU1ycjJHjhxh586d+Hw+iouLSUtLs4LTyJEjqa+vp6ysDL/fz6ZNm6irq+O2227j/2vv3qOjKs/Fj39n9lyTAJNAIrkSkkAgckkhJERBLuEm5RLbhVD1VJaiS1vbao8ej+1ZrnPaupatrq5lPb9fqz9+pUvBC2IRq9KKEECFoBIgF5IYQm4kmSTkzkwys+dy/uDs3SQEiBEC4vP5RzKz9+x3v+92zTPP+z57K4pCU1NTv3WAWgA0YcKEi365K4qC2WzGbDb3e93v95OXl0dXVxe5ublYLBYURSEQCBAMBikoKGDcuHF6prEvh8NBdHQ05eXl+P1+uru72bNnDykpKWRlZel9ERoaeslgsqWlhbCwMDweD2+++SZ+v5/4+Hh6e3s5e/YswWCQkydPUlBQwNKlSxk7dixtbW34/X7Gjh3LkSNHKC4uJiwsDJ/PR0NDAy6Xiw8//JCmpiY9eGxubiYQCOhTw4Pp6urSg6yenh6ampr46KOPSE1NJSUlhfj4eGw2G3V1dQQCAWpra9m1axff/e539UKw6upqLBYLpaWleDwejhw5wmeffcaGDRv06e5AIIDL5UJVVQoKCnA6nURGRqIoiv5DQ8vKWq1WjEYjTU1NeDwePv74Y8rKyvTlF+fOncPtdnPTTTdx5swZ/vGPf+D1eqmuriYyMpLQ0FAMBgMTJ06ktbWVrq4uVFUlPz8fl8vFqlWr9Ox0V1cXUVFRelBbV1fXL5OuqiqVlZXEx8frwbAQ31SSVxfiW8rr9bJnzx527dpFd3c3L7/8MosWLeL222/vt93EiRNZsWIFf/3rX3n33Xex2+0sXLiQrKwsLBYLqqridDpJTk5m9+7d+pqzH//4x3q2MyMjgwMHDvDLX/6SmTNn4vF48Hq9/Pa3v+Xpp5+ms7OTU6dOsWXLFp544gliYmJYuHAhb7zxBu+99x6zZs3C6/Vy4MABUlNTSUhIYObMmfztb38jISGB1atXY7FYqKys1NdbLly4kMWLF9PY2Mjzzz+P1Wrlpptu4tFHH9WDBy1rpVWCd3Z20tHRwbZt2/Ssat8pZaPRSGxsLKWlpXrGT1NSUkJlZSW5ubl69mnGjBmUlpbywgsvEBERwYYNGwa9/YvFYuHuu+9m69atPPnkk4SEhJCamspdd92Fw+Ggt7eXpqYmPTM7GKPRSGpqKtu3b+cPf/gD8+bNw2q1MmnSJBYuXMjWrVtRFIXw8HDWr1/P9OnTURSFiIgIEhMTefnll0lOTmb16tVERUWxdOlS/vjHPxIZGanfJmnbtm385Cc/oaWlhc7OTp577jl+/etfD3pOWgY3PDycX/3qV7hcLtLT01m9erUeCN5zzz188MEH7Nu3j7CwMNasWcPcuXP1QL2qqoqbb76ZmpoaHn/8cWw2G3fffTfZ2dnA+Ury9PR0XnjhBZKSkoiLiyMQCLBlyxYmTJiA1+uloqICv99PYmIisbGxrF+/nnfffZe8vDyysrJQVZW9e/cyceJEEhMTmTp1Km+99ZZe9GOz2aitrcXpdLJ582YeeOABlixZQltbG8888wyhoaFERkZy1113MWnSJD2z7vf7cTgcGAwGfD4fZ86cobKyklmzZpGRkUF3dzclJSUsW7bsqt4TVYiRYAjKnVKF+FYKBoN6ZkdjNBovmN4NBoP6tsFgUL+diZa56+3t5aGHHuLhhx9m9uzZ+jaKovR7nKDf7ycYDOr7BQIBfTvtfe3vvvto7eq7vbb/wNe0YyiKok+t9j3Hvu3WbqWjba+t9dTO02QyXbA2USsc2r59O+vWrSMpKUnfRtvPaDT2O++B/XapghWtPQaDod/2HR0d/OlPf2Lq1KmsWbNm0M/oO07auV6sHZcam77jo/Wv1jcDxwu4aD/l5eVx+PBhHnzwQX36Xvt8bY3kpa6rQCDAo48+Sk5ODqtWrdKPr+2vfcZg7dTaBeensodyXWmf2/fztPb4fD69jSaTadDjDuxvv9+v79+3jxVFoaenhx07dmA0GvnBD34g6yXFN55cwUJ8S/UtGrncdtqX5WC0KeTo6OiLfilqX8J99T3uYJ8/8LWB7Rys7QOPcblzHPh632DmYucRGxtLeno6dXV1JCQk6Fm0wfbrG8RczmB9BOcDk46ODlwuV7+K88H2v9g4XWr8Lnbcgf12ufHqS1ur6HA4CAkJuWBJwOXaC+eXPmjFOhcbw8HGd+B2A489EtfVwD4d+PfHH3+M3W4nNzdXAklxQ5CrWAjxtZw+fRqbzaavf7zRafdN7O3tHZGiibq6Og4ePMiUKVOG/KjJa83j8eB0OomJiRn2U10aGhrw+Xx6scyNZNq0acTGxsqzuMUNQ6a5hRBfS0NDAy0tLfpj/8SV1draitPp1J98802gqipVVVWMGjXqgnWnQ9XW1kZVVRXp6elDzu4KIa4NCSaFEEKMmL7rUoUQ17/BlqkMJNPcQgghRsy2bdt4/vnn6e3tvdZNEUIMQXl5+WW3kWBSCCHEiKmpqeHpp58mNzdXpq+FuEHITcuFEEIIIcSwSTAphBBCCCGGTYJJIYQQI0qq/oW4sUgwKYQQYkRJJbcQNxYJJoUQQgghxLBJMCmEEGJEyTS3EDcWCSaFEEKMKJnmFuLGIveZFEIIcd1RfT5Ur/crBZ4GgwGz2YzJZJLs53VIVVVUVZUxvQFJMCmEEOK6898v/3/+88U/0aUOPfCwKwb+/b67eOKnj2C3269i68RwPPvs73juuf9Lb6865H3sdgu/+MWj/Nu//etVbJn4uiSYFEIIcd2pra2l595fQ+ZKMA5tRZZaeID2lv2oqirB5HWosbEei2UeYWHRwNCyjF7vGVpanASDQclMXsckmBRCCHHDKyoqoqCgAIvFwujRowFwu91MmzaNKVOmXNFApa2tjX379pGYmEh6ejom07X/qg0Gg+zbt4/29naWLVum98FQ9nvnnXfIyckZ8j4jpbCwkOPHjxMWFsYdd9yhj2EwGOTzzz+nuLiYzMxMpkyZMugYHDx4kPr6elasWEF4ePhIN39Qp06d4tChQ8yfP5/ExMQhXZeqqlJSUkJYWBgpKSkj0MoLSQGOEEKIG15sbCynT59GVVWmT5/O9OnTCQkJwel0XvFjhYSE4PV6qa6uxu/3X/HPH674+HiOHTuGy+W66DaBQIBnn32Wzs5O/TWbzXZdBMQDxcXFUV1dzXvvvUdtba3+ut/vZ/v27ZSWljJ+/HiMF8lsJyYm8sUXX1yyP0ZaVFQU1dXVNDc3X3K7Xbt2ceLECQKBAEajEavVek2fdX/9XR1CCCFuaNdiujIiIoLQ0FDCw8NJSEjA5/MRGhoKnM9kef+32MdoNGI2m/H5fKiqiqIoBAIBvRDE6/ViMBiwWCwYDAYCgQCqqurnZLFYsNlsOBwOent79c/3+Xx6YKnt2zeT5vV68fv9mEwm/H4/iqJgNpuB8wGez+cjGAyiKIq+jdfrRVEUvaDFbDZjMBj6tVEreDGbzYwfP14POLRjahRFQVEUvF4vp06dwu12ExISAsC8efOwWCwEg0G9LfDP4hitLVq7tHO82sFNREQEYWFhTJs2jby8PO69914MBgNFRUVERkbidrsJDw/HYDDg8Xj0/UwmE0ajkfHjx/cLkv1+vz6WRqOxX9FPMBi8aJ9rf/ftT20sPB6Pfl0FAgFMJhMmk0nfVus/n8+nZ81DQkL04/a9brT+DgQCNDQ0MHr0aDweDxaLhYSEBEwmk94uVVX7XbcGg4He3l79uvP7/ZjNZv0a+7okmBRCCDGirtWtgYLBIG1tbdTU1FBYWEhUVBSzZs2isLCQTz75BKvVislkIjc3l5KSEl577TVSUlLwer10dnaycuVK8vPz6e7uZtOmTcTFxVFRUcH+/fsJCQmhp6eHdevWERER0e+43d3dvP/++3R3d9Pb28stt9zC7Nmz9ffdbjevvfYae/bsYfXq1TQ0NBAREcH69eux2Wzk5+dTWlqqB7q5ublUVlby0ksvMWPGDADOnTvHwoULiY+P59VXX8VqtfLAAw/wzjvvUF9fz6ZNm/oFDj09Pbz55puYTCZUVSU5OZns7Gw+/PBD2tvbeeutt5g1axaBQIBXX32VBx98kPT0dI4cOcLJkyf1IGjNmjVUVVWxefNmZs+eTVdXF+fOneOOO+4gPT19wA+HK/8jwmAwkJOTw9atW3E6nYwbN478/HxuvfVW9uzZo/fvtm3bsNvtqKpKWloaGRkZ+jUB54O2Tz75hJKSEmw2GyEhISxfvlwfS7/fT0FBAS+99BJz5sxBVVXcbjeLFi0iIyODhoYGdu7cSVhYGD6fj+zsbOLi4ti8eTOlpaXMnz+fhoYG4uLiWLt2LTt37qSlpYV7772XEydO8Pbbb/P444/3m6YOBAIUFhbyxRdfYLPZ8Hg8bNiwgZaWFsrLy3E6nVRVVXHrrbfy5z//maysLNauXUtbWxu7du0CwOv1cssttzB58mRefPFFzp49S2JiInV1dSQnJ3P//fdfNHP7Vcg0txBCiG+N6upqPvvsM7788ku8Xi+qqrJjxw7mzp3LfffdR1dXF0eOHOE73/kOs2fPJi4ujp///OdERERw7NgxHnnkEWJjY6moqCAYDOJwOLj55puZOnUqbrebjz/++IJjHj16lLq6OjZu3MjKlSt5/fXX+2XKQkNDyc3NxWw2M3/+fH7605/S2NhIYWEhZ8+e5dChQyxZsoRNmzbR3t7OgQMHmDZtGpMmTSI+Pp6HHnqI22+/nQMHDmC1WsnMzERRFMLCwpg5c+ag6wEVRWHKlCmkpqYSExNDcXExzc3NrFq1ioiICO6++27mzZvHbbfdRkJCAgaDgYaGBo4ePcrixYv54Q9/SFhYGLt37yYzM5P09HT8fj+PPfYYc+bMobS0VM9g/tPV+RERFxfH+PHjOXHiBF9++SUTJ07EZrPp75tMJtLS0khNTSUyMpLjx4/T1tYG/DNLXl9fz+7du1m3bh0bNmzA5/NRUFBAIBDQP2PGjBkkJSWRkJDAww8/TE5ODgcPHqS9vZ1t27aRkpLCxo0bufnmmzl48CAGg4G1a9dit9tZvnw5P/vZzzh69Cg1NTXMnTsXh8MBwKJFiwYdI4PBwLhx40hLS2Pq1Km0t7dz+PBhkpKSSEtLY+nSpWzcuJHJkyczb948fb8PPvgAk8nE/fffT3Z2Nm+//TaKovD973+f0NBQcnJyePLJJzl06BBdXV1XZAwkmBRCCDGirlVVrsFgYNasWaxbt47169eTnJyMy+WioqKCiooK/v73v6OqKqdPnwbOT9VGRUVhNpuJjo4mKioKu93OmDFjcLlc+Hw+ysrKOHXqFMCgazCDwSDFxcV0d3ezZ88eSkpK6Orqor29/YL2Wa1W4uPjsdvtREdHU15eTnt7Oy6Xi3HjxmEwGEhJSaG4uFg/n6SkJBRFISIigkAgQGtr65D6oqWlhcOHD6OqKiaTCY/Hg9vtvuQ+bW1t+Hw+Ro0ahdFoZMKECVRXV6Oq52/1M3nyZEwmE2PGjEFV1UGCyasz7iEhIaSnp1NcXMynn37KzJkz+73f2NjI4cOH9aldt9vdL5iH83cP8Hq9fPrpp+Tl5dHc3ExHR8cF52AwGEhOTtb73Ofz0djYSEVFBZMnT8ZgMBAZGUlzc7M+rTx69GiioqIIDQ0lNjaW0tLSIZ2X1+ulpKSEuro6/Tybmpouu19RURFJSUkYDAbi4uJoaGjg3LlzAIwdO5bw8HAcDgdWq/WKrReVaW4hhBAj6np4Ak5MTAxwfnrYbrczffp0xo4dy/Tp0/Vg12g06lOARqNRXwNoMBgIBoOoqkpxcTFTpkwhIyODlpYWampqLjhWSEgIMTExzJo1C4C0tLRBM1Haujyj0YjP5yMsLKzfWkXtmFartd/22r+1NZWKouD3+/X3BysCKisrw+/3k5mZydmzZzl9+vQF4zLwb0VR9HWigL6mVOsXbf2hti7vwnG+OuOuKAopKSns3buXiIgIHA4H9fX1+vvFxcUYjUaysrKoq6ujqqrqgraZzWbGjBlDeno6NptNL9AaWHg0sM/h/I8Ao9Gor0/V1rxqfRAIBPRCGW38tPe0zxgY3ML56fmKigqysrLIyMigtraW7u7uy/aHzWbT19hqwbDFYgEuvKav1P+LkpkUQghxw/N6vXpRjdfr1b9U7XY7GRkZtLa2MmbMGMrKyigvL9eLMbQMm/Zf7XO0gp3Q0FDa2tpwu92Ul5ejqioej0c/TiAQIDs7m46ODmw2GzabjR07dgy6Tq2np4eSkhKcTie1tbVkZmYSHh7O+PHjqaqqwuVyUVRUxG233abvc+LECTo7O6msrNQzmlFRUTQ3N+NyuWhsbKStrQ1VVent7dXPa/To0XR0dOByuWhtbaWhoUEPhkJDQ6mvryc/P5/m5ma98ETLzDqdTs6dO0dZWRmzZ8/WgxatiEjrNy2gvZpj6vf76enpITo6mrVr15KTk4PZbMbj8ejtdjgctLa24nK5aG5uprm5GVVV6enp0bdJTU3Vg+RRo0Zx6tQpKioqBs2iHzt2jK6uLk6fPk1YWBixsbHMnz+fzz//HLfbTXV1NUlJSXqBV3t7O5WVlZw5c4YzZ86QmZmJ3W4nGAzS0dHBmTNnaG1txev16ufk8XgwGo1YLBY6Ojpwu92UlZXh8/nw+XzY7XZ6e3s5cuQIJ06c0PcNBAIsWLCAoqIiXC4XJ0+eJD09HavVql+7Pp8Pj8dDIBDQr+OvSzKTQgghbnhffPEFgUCAmpoajh07RlZWFnA+m7Zu3To++ugjqqurGTVqFCtXrqS6upqmpiYCgQDFxcW0tLRgt9spKCigs7MTt9tNa2srS5Ys4f333+f1119n9OjRtLa2cvjwYWpra/F4PNTX15OSksJtt93Gzp07MRgMfO973xu0ilZRFBobGzlw4ACLFy/Wp7CXL1/OkSNHOHbsGPPnz2fOnDl6xbbNZmP79u0EAgF9TVxqaippaWm8/vrrOBwORo8eTWlpKU6nE7PZTFlZGdnZ2dTV1fHKK68wZswYHA4HlZWVJCcns2LFCj755BNmzJhBZWUliqJw8uRJUlJSWLZsGfn5+RQWFhITE0NOTg6VlZWoqkp5eTkpKSmcPn2as2fP4nQ6SU5OvmrLGo4dO4bX62X37t2sWbOGzMxM4Py0dkFBAYqiUFRUxOzZs6mrq+Mvf/kLo0aNYtSoUZSXl1NQUEBISAglJSUsXryY++67j71792KxWIiMjCQzM/OCtmt9/sYbb+hrIkNCQrjzzjvZtWsXb731FqGhoSxZskSvyjaZTJSWllJVVcU999xDdHQ0qqoyadIk9u/fT1xcHDNnzqS0tJT29nb8fj+FhYWkpqayaNEi9u7dS319PVFRUXR3d1NTU8OcOXM4dOgQwWCQBQsW6NnW5uZmFixYgKqqbN++HavVyp133qkvtzh37hy1tbUUFRUxduxYjh8/TkxMTL81psNhCF4P8w1CCCG+FX7zm98wdepUcnNzL3nrmMf+/Zf8H0c26ld4Ao6p8ACPtOznv5547Lq7wfbltLS08NRTT7F58+Yhbe/xeHjxxRdZuXIlaWlpV7l1V8aPfvQjtm9vxWL5ak/A2bhxAr/73e+uSNXx19Hb28vvf/977rzzziHdHDwYDFJZWcmWLVt45plnRqCF145McwshhBhR8li8/np6esjLy9MryS/H7/dz6tQpampq2L9/f7/7G4qrw+/3U1FRQV1dHfv27RukuOhCbrebvLw8nE4nJSUlI9DKa0emuYUQQoyooUyIJUxIwP7Cf+D7f78ADBeUbmjhaPB//x0EzAqE3/8vV+xGzCPFYrGwcOFCMjMz9dvFXIrRaCQxMZEnnnhCvwn2N0F0dBxe7y66uoYe/NrtVqKisq75DxCj0cjEiRN56qmnMJvNQ8qS2mw2Vq1axbJlyxg7duwItPLakWluIYQQI2ao09xa0ctX+YrS1qf1fXKJuH5oRUxfdUy1p8zImF6/vhk/Z4QQQnyrfJMybmJoruTj+8T1RdZMCiGEGFGSYRLixiLBpBBCiBElq6uEuLFIMCmEEEIIIYZNgkkhhBBCCDFsEkwKIYQQQohhk2BSCCGEEEIMmwSTQgghhBBi2OSm5UIIIUbMK6+8wrPPPktPT8+1booQYgiqqqouu40Ek0IIIYQQYthkmlsIIYQQQgybBJNCCCGEEGLYJJgUQgghhBDDJsGkEEIIIYQYNgkmhRBCCCHEsEkwKYQQQgghhk2CSSGEEEIIMWwSTAohhBBCiGGTYFIIIYQQQgzb/wC3DvsGN8dlXQAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "The following generation flags are not valid and may be ignored: ['early_stopping']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- ANALYSIS RESULT ---\n", + "{\"gt_parse\": \"This is a hbar categorical titled 'Percentage of the total population (ages 15-24) who uses condom in different countries'. The x-axis shows Population (% of total population) and the y-axis shows Country.\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{{{\"\n", + " decoder_input_ids = processor.tokenizer(\n", + " task_prompt,\n", + " add_special_tokens=False,\n", + " return_tensors=\"pt\"\n", + " ).input_ids.to(device)\n", + "\n", + " # Generate summary\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " num_beams=1,\n", + " bad_words_ids=[[processor.tokenizer.unk_token_id]],\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode and clean\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + " sequence = sequence.replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\")\n", + " clean_summary = re.sub(r\"<.*?>\", \"\", sequence, count=1).strip()\n", + "\n", + " print(\"\\n📊 --- ANALYSIS RESULT ---\")\n", + " print(clean_summary)\n", + " print(\"---------------------------\\n\")\n", + "\n", + "# --- 4. UPLOAD IMAGE FROM COMPUTER ---\n", + "print(\"📤 Upload a horizontal bar chart image to test:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " print(f'Processing file: \"{filename}\"')\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 921, + "referenced_widgets": [ + "419c0a5a3cca45f6919a652a58ec7227", + "eb621b102b9d4f78831e3f979bd65968", + "348094c9f871450788d930311dd70d78", + "695cba6be2a84a80962ef8715ad3f34e", + "c2809acd0de74dd9b6a64dafe0ffd255", + "5696612d752b4b649653ff9a1d6f6828", + "70ebf5eb1e654cefb2ac7324cd1d0186", + "4fd1766998874204a640cea272aefecb", + "cb12980f41484fa9958746ce31da5aad", + "00ceb7fd6b614aa29c626b48fdc1957f", + "6ae189c5369f426c8b5b25491f722c47" + ] + }, + "id": "Qoa3uyK-tIDm", + "outputId": "7812533d-3842-421c-e416-3b6636cde785" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Processor from Master...\n", + "⏳ Loading Model Weights from /content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 5578.png to 5578.png\n", + "Processing file: \"5578.png\"\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- ANALYSIS RESULT ---\n", + "{\"gt_parse\": \"This is a hbar categorical titled 'Percentage of value added in manufacturing machinery etc. in countries'. The x-axis shows Value added (in %) and the y-axis shows Manufacturing industries.\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}\"\n", + " decoder_input_ids = processor.tokenizer(\n", + " task_prompt,\n", + " add_special_tokens=False,\n", + " return_tensors=\"pt\"\n", + " ).input_ids.to(device)\n", + "\n", + " # Generate summary\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " num_beams=1,\n", + " bad_words_ids=[[processor.tokenizer.unk_token_id]],\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode and clean\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + " sequence = sequence.replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\")\n", + " clean_summary = re.sub(r\"<.*?>\", \"\", sequence, count=1).strip()\n", + "\n", + " print(\"\\n📊 --- ANALYSIS RESULT ---\")\n", + " print(clean_summary)\n", + " print(\"---------------------------\\n\")\n", + "\n", + "# --- 4. UPLOAD IMAGE FROM COMPUTER ---\n", + "print(\"📤 Upload a horizontal bar chart image to test:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " print(f'Processing file: \"{filename}\"')\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 921, + "referenced_widgets": [ + "ff9865124d7a49b29cddb534528754c8", + "0c411f4a10094e1589dcb6de32025cda", + "49b6ef42d3624c3fa336e9644059b833", + "d062cf09a8af463e89823561a1b6eb85", + "7a548218c0f544be9bf0b82ac5e35426", + "efcbdab0da804eda9af757a2cb552193", + "bb8836dd36864fe89930f18803f09e72", + "e298e588623c49d481c33fc32422ec15", + "15ef395cfd954bbab5c97fffb58c9481", + "1fbf8c8d56cd43f39913dd765241c1fb", + "9d8a3c0845184ef1bd999360e40079cb" + ] + }, + "id": "j-BxZHyttPuK", + "outputId": "644801e8-2f2d-4be5-e73d-f77c3e4e1240" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Processor from Master...\n", + "⏳ Loading Model Weights from /content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 5664.png to 5664.png\n", + "Processing file: \"5664.png\"\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- ANALYSIS RESULT ---\n", + "{\"gt_parse\": \"This is a hbar categorical titled 'Net savings as percentage of gross national income of Denmark'. The x-axis shows Savings(% of GNI) and the y-axis shows Year.\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>chartqa>\n", + "---------------------------\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import os\n", + "from google.colab import files, drive\n", + "\n", + "# --- 0. DRIVE MOUNT CHECK ---\n", + "if not os.path.exists('/content/drive'):\n", + " drive.mount('/content/drive')\n", + "\n", + "# --- 1. CONFIGURATION & PATHS ---\n", + "# Absolute paths ensure the library knows these are local folders\n", + "master_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_VBAR_Final\")\n", + "checkpoint_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750\")\n", + "\n", + "# --- 2. LOAD PROCESSOR & MODEL ---\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "print(\"⏳ Loading Processor from Master...\")\n", + "# local_files_only=True ensures it doesn't look for a repo online\n", + "processor = DonutProcessor.from_pretrained(\n", + " master_path,\n", + " local_files_only=True\n", + ")\n", + "\n", + "print(f\"⏳ Loading Model Weights from {checkpoint_path}...\")\n", + "model = VisionEncoderDecoderModel.from_pretrained(\n", + " checkpoint_path,\n", + " local_files_only=True\n", + ").to(device)\n", + "\n", + "print(f\"✅ STEM Sight Horizontal Expert ready on {device.upper()}\")\n", + "\n", + "# --- 3. INFERENCE & VISUALIZATION FUNCTION ---\n", + "def run_hbar_prediction(image_path):\n", + " # Load and display the image\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + " plt.figure(figsize=(12, 7))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(\"Input Horizontal Bar Chart\")\n", + " plt.show()\n", + "\n", + " # Prepare inputs\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(\n", + " task_prompt,\n", + " add_special_tokens=False,\n", + " return_tensors=\"pt\"\n", + " ).input_ids.to(device)\n", + "\n", + " # Generate summary\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " num_beams=1,\n", + " bad_words_ids=[[processor.tokenizer.unk_token_id]],\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode and clean\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + " sequence = sequence.replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\")\n", + " clean_summary = re.sub(r\"<.*?>\", \"\", sequence, count=1).strip()\n", + "\n", + " print(\"\\n📊 --- ANALYSIS RESULT ---\")\n", + " print(clean_summary)\n", + " print(\"---------------------------\\n\")\n", + "\n", + "# --- 4. UPLOAD IMAGE FROM COMPUTER ---\n", + "print(\"📤 Upload a horizontal bar chart image to test:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " print(f'Processing file: \"{filename}\"')\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 921, + "referenced_widgets": [ + "69a99a03db5f4d00be4b8f9e851e51ac", + "4653276755094c9c8f687c85ef071c44", + "5dea9819d14f4552ab1f7421ce920c81", + "b259b143f21249229776dc05c49a2667", + "4e140c762ae64731a5fccf207d61e879", + "4212114d308444c68cd55f64bf6f2557", + "5d831532dacb4a8eaa5776cb41a17829", + "e3d662f350f34a0da037386154a601fe", + "f53beddcb3344a87a59ec35b9c71007c", + "a7a4658592794880879d72a607aa86ba", + "87bb2458f0be457a966809e5cac6cec6" + ] + }, + "id": "bWYNmvHstYia", + "outputId": "23874f3a-7f29-4c57-c383-4e1a8a4829d5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Processor from Master...\n", + "⏳ Loading Model Weights from /content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 5737.png to 5737.png\n", + "Processing file: \"5737.png\"\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- ANALYSIS RESULT ---\n", + "{\"gt_parse\": \"This is a hbar categorical titled 'Balance of payments as percentage of service imports in Lao PDR'. The x-axis shows Balance of Payment (as % of service imports) and the y-axis shows Year.\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_\n", + "---------------------------\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import os\n", + "from google.colab import files, drive\n", + "\n", + "# --- 0. DRIVE MOUNT CHECK ---\n", + "if not os.path.exists('/content/drive'):\n", + " drive.mount('/content/drive')\n", + "\n", + "# --- 1. CONFIGURATION & PATHS ---\n", + "# Absolute paths ensure the library knows these are local folders\n", + "master_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_VBAR_Final\")\n", + "checkpoint_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750\")\n", + "\n", + "# --- 2. LOAD PROCESSOR & MODEL ---\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "print(\"⏳ Loading Processor from Master...\")\n", + "# local_files_only=True ensures it doesn't look for a repo online\n", + "processor = DonutProcessor.from_pretrained(\n", + " master_path,\n", + " local_files_only=True\n", + ")\n", + "\n", + "print(f\"⏳ Loading Model Weights from {checkpoint_path}...\")\n", + "model = VisionEncoderDecoderModel.from_pretrained(\n", + " checkpoint_path,\n", + " local_files_only=True\n", + ").to(device)\n", + "\n", + "print(f\"✅ STEM Sight Horizontal Expert ready on {device.upper()}\")\n", + "\n", + "# --- 3. INFERENCE & VISUALIZATION FUNCTION ---\n", + "def run_hbar_prediction(image_path):\n", + " # Load and display the image\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + " plt.figure(figsize=(12, 7))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(\"Input Horizontal Bar Chart\")\n", + " plt.show()\n", + "\n", + " # Prepare inputs\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(\n", + " task_prompt,\n", + " add_special_tokens=False,\n", + " return_tensors=\"pt\"\n", + " ).input_ids.to(device)\n", + "\n", + " # Generate summary\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " num_beams=1,\n", + " bad_words_ids=[[processor.tokenizer.unk_token_id]],\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode and clean\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + " sequence = sequence.replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\")\n", + " clean_summary = re.sub(r\"<.*?>\", \"\", sequence, count=1).strip()\n", + "\n", + " print(\"\\n📊 --- ANALYSIS RESULT ---\")\n", + " print(clean_summary)\n", + " print(\"---------------------------\\n\")\n", + "\n", + "# --- 4. UPLOAD IMAGE FROM COMPUTER ---\n", + "print(\"📤 Upload a horizontal bar chart image to test:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " print(f'Processing file: \"{filename}\"')\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 921, + "referenced_widgets": [ + "892d92bcb1b147aab63b836c41839cf2", + "7f0a2fb8a241460aad862cbab5a85c01", + "d6930ddcf80c445ab894209aae6b921f", + "11e45ea20046473bbafaca5f8e5a2172", + "3ee352dc766f425889311b44b9e3ba9d", + "41870bca1d364e4d99b40296727bd062", + "f4f2d19723bd44c39bade420e9bb1771", + "b8399b4697c64c5fac530a9d86734170", + "93e320738d70471d993758189795aa45", + "40254fb4107447c8907693dc371abead", + "f87a9f6a8712426c92e322d27e8281b8" + ] + }, + "id": "Y5isZZpdtjft", + "outputId": "20b5dc65-53cf-41e7-e59f-ce54f1802474" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Processor from Master...\n", + "⏳ Loading Model Weights from /content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 5802.png to 5802.png\n", + "Processing file: \"5802.png\"\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- ANALYSIS RESULT ---\n", + "{\"gt_parse\": \"This is a hbar categorical titled 'Net bilateral aid flow in an economy from Luxembourg'. The x-axis shows Aid flow (current US$) and the y-axis shows Country.\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_chart_char\n", + "---------------------------\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import os\n", + "from google.colab import files, drive\n", + "\n", + "# --- 0. DRIVE MOUNT CHECK ---\n", + "if not os.path.exists('/content/drive'):\n", + " drive.mount('/content/drive')\n", + "\n", + "# --- 1. CONFIGURATION & PATHS ---\n", + "# Absolute paths ensure the library knows these are local folders\n", + "master_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_VBAR_Final\")\n", + "checkpoint_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750\")\n", + "\n", + "# --- 2. LOAD PROCESSOR & MODEL ---\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "print(\"⏳ Loading Processor from Master...\")\n", + "# local_files_only=True ensures it doesn't look for a repo online\n", + "processor = DonutProcessor.from_pretrained(\n", + " master_path,\n", + " local_files_only=True\n", + ")\n", + "\n", + "print(f\"⏳ Loading Model Weights from {checkpoint_path}...\")\n", + "model = VisionEncoderDecoderModel.from_pretrained(\n", + " checkpoint_path,\n", + " local_files_only=True\n", + ").to(device)\n", + "\n", + "print(f\"✅ STEM Sight Horizontal Expert ready on {device.upper()}\")\n", + "\n", + "# --- 3. INFERENCE & VISUALIZATION FUNCTION ---\n", + "def run_hbar_prediction(image_path):\n", + " # Load and display the image\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + " plt.figure(figsize=(12, 7))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(\"Input Horizontal Bar Chart\")\n", + " plt.show()\n", + "\n", + " # Prepare inputs\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(\n", + " task_prompt,\n", + " add_special_tokens=False,\n", + " return_tensors=\"pt\"\n", + " ).input_ids.to(device)\n", + "\n", + " # Generate summary\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " num_beams=1,\n", + " bad_words_ids=[[processor.tokenizer.unk_token_id]],\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode and clean\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + " sequence = sequence.replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\")\n", + " clean_summary = re.sub(r\"<.*?>\", \"\", sequence, count=1).strip()\n", + "\n", + " print(\"\\n📊 --- ANALYSIS RESULT ---\")\n", + " print(clean_summary)\n", + " print(\"---------------------------\\n\")\n", + "\n", + "# --- 4. UPLOAD IMAGE FROM COMPUTER ---\n", + "print(\"📤 Upload a horizontal bar chart image to test:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " print(f'Processing file: \"{filename}\"')\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 847, + "referenced_widgets": [ + "d5114bc2fd3a400e9d4a3243467f8a09", + "c55f834fb97747c09f8f8cb524395a99", + "02783238b4ca4a34a0790cf8fe8660c1", + "8524e173dde8420683279c4e55cf13ce", + "bd0ee12fb3bd48cf80a0213e69651d69", + "1560142dc5514fe9925eb88bf9e7faf6", + "75a94f247545435eb0a551ad12e0eb6d", + "0bac004813ce45dbab80fd392c36012c", + "1be9aeecfaff4f4c85329bdd511a2af7", + "bc578c1971cc48cd946e77d5d6c45340", + "c97d1b6bfd2d437db369f6411b379ede" + ] + }, + "id": "9e4FVb6OtsoE", + "outputId": "5dd90773-4411-48ce-ba08-49d98ea390d9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Processor from Master...\n", + "⏳ Loading Model Weights from /content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving Example-of-Simple-Horizontal-Bar-Graph.png to Example-of-Simple-Horizontal-Bar-Graph.png\n", + "Processing file: \"Example-of-Simple-Horizontal-Bar-Graph.png\"\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- ANALYSIS RESULT ---\n", + "{\"gt_parse\": \"This is a hbar categorical titled 'Value added by the y-axis shows Years.\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}{\"}_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa>_chartqa\n", + "---------------------------\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import os\n", + "from google.colab import files, drive\n", + "\n", + "# --- 0. DRIVE MOUNT CHECK ---\n", + "if not os.path.exists('/content/drive'):\n", + " drive.mount('/content/drive')\n", + "\n", + "# --- 1. CONFIGURATION & PATHS ---\n", + "# Absolute paths ensure the library knows these are local folders\n", + "master_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_VBAR_Final\")\n", + "checkpoint_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750\")\n", + "\n", + "# --- 2. LOAD PROCESSOR & MODEL ---\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "print(\"⏳ Loading Processor from Master...\")\n", + "# local_files_only=True ensures it doesn't look for a repo online\n", + "processor = DonutProcessor.from_pretrained(\n", + " master_path,\n", + " local_files_only=True\n", + ")\n", + "\n", + "print(f\"⏳ Loading Model Weights from {checkpoint_path}...\")\n", + "model = VisionEncoderDecoderModel.from_pretrained(\n", + " checkpoint_path,\n", + " local_files_only=True\n", + ").to(device)\n", + "\n", + "print(f\"✅ STEM Sight Horizontal Expert ready on {device.upper()}\")\n", + "\n", + "# --- 3. INFERENCE & VISUALIZATION FUNCTION ---\n", + "def run_hbar_prediction(image_path):\n", + " # Load and display the image\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + " plt.figure(figsize=(12, 7))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(\"Input Horizontal Bar Chart\")\n", + " plt.show()\n", + "\n", + " # Prepare inputs\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(\n", + " task_prompt,\n", + " add_special_tokens=False,\n", + " return_tensors=\"pt\"\n", + " ).input_ids.to(device)\n", + "\n", + " # Generate summary\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " early_stopping=True,\n", + " repetition_penalty=1.5,\n", + " no_repeat_ngram_size=3,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " num_beams=1,\n", + " bad_words_ids=[[processor.tokenizer.unk_token_id]],\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode and clean\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + " sequence = sequence.replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\")\n", + " clean_summary = re.sub(r\"<.*?>\", \"\", sequence, count=1).strip()\n", + "\n", + " print(\"\\n📊 --- ANALYSIS RESULT ---\")\n", + " print(clean_summary)\n", + " print(\"---------------------------\\n\")\n", + "\n", + "# --- 4. UPLOAD IMAGE FROM COMPUTER ---\n", + "print(\"📤 Upload a horizontal bar chart image to test:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " print(f'Processing file: \"{filename}\"')\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 905, + "referenced_widgets": [ + "4ea6391950214171ad08afeb1c984082", + "e5f53976863547e094756e528566f53d", + "748370fe53da4d74a3888c5be249ec45", + "f14ea589d6264e218669c2bdf859514a", + "29ec5e7f86a2472d9e96371683c7c443", + "f22dbec4512a4f0995cdcd3e25e0312a", + "9bea9703719c4a1e9c4110615c63781a", + "1bcd825b305e4ff88e5f6a36f582a536", + "cae130843a6f4120b6e6802a585dcd28", + "e2a62e12162f4dc2bdaac18a50fb8bdc", + "c367d05ee0904727be191dea51709b52" + ] + }, + "id": "2896F-cRuHPd", + "outputId": "d91b6b19-625b-4a74-d10b-21476a620651" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Processor from Master...\n", + "⏳ Loading Model Weights from /content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving Increasing-Efficiency-Drivers-With-Horizontal-Bar-Chart.png to Increasing-Efficiency-Drivers-With-Horizontal-Bar-Chart (1).png\n", + "Processing file: \"Increasing-Efficiency-Drivers-With-Horizontal-Bar-Chart (1).png\"\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- ANALYSIS RESULT ---\n", + "{\"gt-parse\">: \"This is a hbar categorical titled 'Increasing in efficiency. ship/savings within Herzovofficial Bar % of cohori.\"}\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=150, # Chhota limit taaki loop na kare\n", + " early_stopping=True,\n", + " no_repeat_ngram_size=3, # Repetition control\n", + " repetition_penalty=1.5, # Loop breaker\n", + " num_beams=2, # Better quality\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + "\n", + " # --- DYNAMITE CLEANING LOGIC ---\n", + " # Sirf \"gt_parse\" ke andar wali string nikalne ke liye\n", + " match = re.search(r'\"gt_parse\":\\s*\"(.*?)\"', sequence)\n", + "\n", + " if match:\n", + " clean_summary = match.group(1)\n", + " else:\n", + " # Fallback agar regex fail ho\n", + " clean_summary = re.sub(r'<.*?>', '', sequence).strip()\n", + " clean_summary = clean_summary.replace('{\"gt_parse\": \"', '').replace('\"}', '')\n", + "\n", + " # Final \"Human-Friendly\" touch\n", + " clean_summary = clean_summary.replace(\"hbar categorical\", \"Horizontal Bar Chart\")\n", + "\n", + " print(\"\\n📊 --- SPECTRA FINAL ANALYSIS ---\")\n", + " print(clean_summary)\n", + " print(\"----------------------------------\\n\")\n", + "\n", + "# --- 4. INTERACTIVE UPLOAD ---\n", + "print(\"📤 Upload your chart to get the summary:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 759, + "referenced_widgets": [ + "cde5d1befa924a12b40fc4b60d7d2c21", + "42b1cfa9fd8845d39fd853c3e7f76d01", + "7a183362a7e84fb7987e8ceca323135e", + "2adccf3cb89240c38b8a96bde8023b62", + "1e1b792610d34747a8c4cf3e20f58726", + "ec9589cdeb074792b60d6bd3a9b4cbc1", + "c1fe3023a5a94ab0ba0a92e451462a06", + "d67ec831f2ca4f6398dde1afe48ba329", + "64035efdd4a84803a4edc0a608f7b887", + "68dbc67be07b415fbd0c0f28ea586ddf", + "63eb5c73a0ba44e7bc90ff7d329af3d2" + ] + }, + "id": "mqex_eMtveql", + "outputId": "2f720af5-8914-4f54-fa75-fdb47d2260fe" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Models...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving Increasing-Efficiency-Drivers-With-Horizontal-Bar-Chart.png to Increasing-Efficiency-Drivers-With-Horizontal-Bar-Chart (2).png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxoAAAHHCAYAAAA4fy6KAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA3w5JREFUeJzs3Xd0VNXawOHfmZbeCz2EFgi9V5HeBBQRFEXxKopcL+pnwYaKiopiverViwXFimChSe8ISO8dQkIq6b3NzNnfH3HOJSSBgANY3metrAUzp+w5db+7akophRBCCCGEEEK4kelqJ0AIIYQQQgjx1yOBhhBCCCGEEMLtJNAQQgghhBBCuJ0EGkIIIYQQQgi3k0BDCCGEEEII4XYSaAghhBBCCCHcTgINIYQQQgghhNtJoCGEEEIIIYRwOwk0hBBCCCGEEG4ngYYQQgghhBDC7STQEEIIIYQQQridBBpCCCGEEEIIt7NUd8EHH3yw0s/btWvHXXfd5bYECSGEEEIIIa6+WbNmsWfPnkq/e/fddy+4frUDjf3791f6eUhISHU3IYQQQgghhPiTOH36dJUxQHVI0ykhhBBCCCGE20mgIYQQQgghhHA7CTSEEEIIIYQQbieBhhBCCCGEEMLtqt0Z/I9IKcWSJUuIjY3Fx8eHkSNH4u/vf7WT9ZenlGLXrl38+uuvWCwWxowZQ0BAwNVOVrUVFBSwZMkSUlNTL3pdq9XK8OHDqVWrVrnPS0tL2bx5MwsXLuTIkSOYzWYaNWrE+PHjadGiBUeOHOHHH39k+/btOBwOatSowfDhw7FarcTFxVGjRg1uuOEGrFbr7/pt6enpzJs3D13X6dWrFy1atEDTtN+1zb+6jRs3sm/fvvMu4+HhQZMmTYiMjCQkJAQfH5/ffVyLioqYM2cOhYWFtG7dmh49emAy/X3LfkpKSli6dCmJiYl4eXlx66234uXlVeXyCQkJ/PzzzzgcDkwmE9dddx3169evcvmCggK+//578vPziYiIYODAgXh4eKCUIi4ujp9//hmA4cOHU69evXLnVylFcXExnp6exudKKY4ePcrq1asBGDVqFDVq1HDHoQAgPz+fn3/+mfT0dGrWrMn1119frefD0aNHWbVqFZqm0adPH6Kjo92WpurKzMzku+++Q9d1evbsSatWrf4yzyGlFHa7HZPJhMXiviyU3W5n1apVxMTEEBgYyG233VbtY7Zt2zZ27NiBUqrKZcLCwqhTpw4NGzYkODgYDw8PdyX9ilBKkZ+fz4kTJ1i1ahWxsbHEx8fj6elJ48aNady4Mb169SIiIqLK+yQxMZH58+cDMGjQIBo1avSHvi4v17V2xalq6t27d6V/zz//fHU34Xa6rqvrr79eaZqm6tWrp06ePHnV0vJ34nA41PTp05WmacrX11edOHHiaifpoiQnJ6vOnTsrTdMu+s/f319t3Lix3PacTqf68ssvlZ+fnwKMv7CwMLV582a1Y8cOFRUVpTRNM74zmUxqxowZaujQoUrTNNWlSxeVl5f3u3/bnj17lM1mU5qmqQ8++EDpuv67t/lX93//93/VOvcmk0mFhYWpm266Sa1atUqVlpb+rv2mpqaq2rVrK03T1IMPPvi7t/dnV1RUpO6++26laZoKDg5WO3bsqHJZXdfVe++9Z1zrFotFvf766+e93rds2aLCwsKUyWRSkyZNMo63rutq0aJFxnletmyZsR1d15XD4VDr169XU6dOLbd9XdfVF198oTRNU2azWf36669uOhJl4uPjVfv27ZWmaapHjx4qPz+/Wut99dVXStM0ZbVa1axZs9yapuo6ePCg8vDwUJqmqffee085nc6rkg5303VdJSYmqqlTp6pDhw65ddt5eXnqpptuUpqmqWbNml3UMXvhhReUxWK54PPLZDKphg0bqsmTJ6vTp0//Kd4PrntwzZo1asSIEcrPz6/cuxQwfmODBg3U888/r+Lj4yv9bevWrVMmk0lpmqbmzZv3h/79l/Nau1hTp06tMgaojj9xiFRGKWX8iSvHdcx1Xb/aSbloZ18zVquVevXqVbsk2cfHB09Pz3KfJSQk8Prrr5OXl4efnx/dunWjcePGOBwO6tevz6OPPsqxY8ewWCx06NCB1q1bU1BQQJcuXVi7dq3br19d1+V+uAhnH/86deqUK0VXSlFQUEBxcTF5eXmkpaXxww8/sHr1ah5++GEee+wxvL29f9d+5flVxsPDg27duvH1119TUFDArl276NChQ6XLFhcXs2nTJkpLS9E0DYfDwcaNG5k4cSK+vr4Vlle/1cJmZ2djs9no2rVrhVJP1zk4+1yUlJTw5ptv8s477xAVFcVzzz1Xoabjcj4HL+X6+CM8m/+q1/aWLVu47777iI+PZ8iQIW7f/qWeu7PXqVmzJj4+PuW+dz3DcnJyiImJ4a233mLPnj18/PHHRERE/KFL9QsKCpg5cyZvvfUWSUlJRmuBOnXqEB4ejsPhICUlhaNHj3Lq1CleeuklNm/ezCeffELdunUr/DbXcfqjX5eX+1q7kv70gYa48kwmE3369OG1117DarUSHBx8tZN0yWrVqsW3336Ln59ftZY3mUzUq1ev3GcZGRkcOXIEgHHjxjFjxgwj81lSUsLWrVsB6Ny5M998843RvMPhcHD33XfTu3dvatWqhc1mc8vvmT59Orqu07Vr19+9vb+b1157jfbt25f7LC8vj+LiYpKTk1mwYAELFy4kOzubN954A39/fyZNmnRJ1dq+vr5MmTKFgoIC2rdvj9lsdtfP+FPSNI0OHTrg7+9PWloaO3fu5M4776z0vkhNTTWau3Xq1Ilt27Zx8OBBEhMTadq0aYXlS0tL2bNnD3a7ncDAQLp3717u++joaF577TWAcusXFhaybt060tPTadKkiTt/7l9ajRo1eOWVV3A6nXTv3v0PnZG9GPv27ePAgQMVMvJ/FN7e3kydOpVrr7223Of5+fkUFxcTGxvLBx98wNatW1mzZg3vvfcer7322h/22WO325k5cybPPfcchYWFNGzYkPvvv5/rrruOiIgIfHx8UEqRnZ3Njh07ePPNN1m5ciWrV6/mX//6F7NnzyYoKOhq/4xL8ke/1i6GBBriknTp0oXOnTsD/KlfIlarlaioKAIDAy95G4WFhZSWlgLQs2fPciXipaWlFBYWAtCmTZtyfTvMZjMjR440/u+O4xgWFsYjjzzitu393dSvX7/KNu1KKYYPH84333zDww8/TF5eHi+99BI9e/akffv2F328vby8+Oc//wnIuXKJjo6mdu3apKWlcejQIfLy8ipMCquU4sSJExw7doygoCDuuece9u/fT2xsLEePHiUqKqrC8czPzzdmto2OjqZOnTrlvm/YsCGPPfYYUHYu5Hz8PiEhITz88MOAXNtXktlspm7dulU+w6655ho6d+7M9ddfz7Fjx5g7dy7/93//R926da9wSi9MKcWWLVt47bXXKCwspFmzZnz22Wd07ty5XAsETdMICgqif//+NG3alNtvv52NGzeyYsUKFi5cyLhx4+QavMr+VoGG0+nkzJkzFBcXYzKZCAoKwt/fv1oXoa7r5OXlkZmZCZSVHAQGBlarQ5XT6SQlJQWHw0FQUBB+fn4V9ulqopGRkYHT6cRsNhMWFoaXl1e1b5KioiLS0tJwOBxA2UMnJCSk0qYE5yotLSU3N5f8/Hx0XcfDw4Pw8PBKO1W50lPddNntdlJSUoxOTWFhYdWK0pVSlJSUkJGRQUlJCVarlZo1a/7uDtPuVlBQYPz73N9VWFhoVNV6eXlVeEBW5xgqpSgsLCQjIwOHw4GHhweBgYF4e3tXWL+629R1nYyMDPLy8oCy6zksLOyiSrbUb53z0tPTUUrh6elJWFhYtc9PaWkp6enpFBcXYzabCQwMxM/P7w/bIVrTNLy9vbnjjjtITk7mpZdeIjMzk5kzZ/Lvf//7vB2Xi4uLOXPmjHH9uzoVX+4XoFLKeG7puo7FYiE8PLxC87/zcTVNcDqdlXaEdzqd5OXlkZOTU+7ZdSlNymw2G71792bv3r3s37+fzMzMCoEGwJo1a3A4HERHR9O5c2datGjBjh07WL16NcOHD6+wfGpqKocOHQKgb9++5WqgLvZ5diG6rpOamkphYSFms5ng4OBq15heabquk5OTQ25uLk6nE29vb0JDQy+qhq6goIC0tDRsNptx/1/ua1v91kk2KyuLwsJCNE0jMDCQgICAi9qv0+kkNTWVoqIiI8N6sds437bT09MpLCxEKYWmafj6+hISEnLVnnGaptGwYUP69evHsWPHyM/P59SpU+cNNIqLi0lLS8NutwP/y1dczIAY2dnZZGVl4ePjQ0hISLXeM0VFRbz++uukpaXh4+PDCy+8QJcuXarcp6Zp1KtXj6effpqxY8eSmZnJl19+ydChQwkNDa1yP2e/C00m00VdR6518/PzjXN8Mb8R/pc/UkoRGhp6yU1x/8j+soHG3r17mT59OoGBgTz99NMUFxfz8ccfs379egoLCzGZTNSuXZuBAwcybtw4QkJCKr2wdF0nLi6O7777jlWrVnHmzBkA/Pz8iIqK4p577qFz585G9b5SirVr1/LRRx/RoEEDHnnkEebMmcOXX35JSUkJdevW5Z///CeDBw/GYrGglCIrK4sff/yRn376iYSEBJxOJxaLhcjISG644QZuvPHGKi98XdeNkYZWr17NqVOnyj0Q6tWrx8CBAxk7dizBwcEVtmG329m7dy8ff/wxhw8fJjs7G13X8fT0pFmzZtx0003079+/3ItS13UWLlzInDlz8PDwYMaMGdSoUQOlFCtWrOCzzz6jVq1aTJ06lZMnT/LRRx+xfft2SktLMZvNxu+65ZZbKs0sQ9lDZsOGDXzxxRccPXqU4uJiPDw8aNOmDffffz+BgYG89dZbZGVl8eSTT9KmTZtLv1gu0ZdffsmSJUtITk42PpsxYwZfffWV8f/i4mJyc3MB+Pnnn0lISEDTNG688UZuvPFGo61s48aNeeaZZ8plAJVSZGRksGjRIn766SdOnz6Nw+HAy8uLunXrcvvttzNw4MBy5yYuLo6nn34ap9PJ+PHj6d+/f7lRcpxOJydOnODjjz9m69atZGdnA2XNeNq2bcudd95Jhw4djMyCS2lpKW+++SZ79+6lf//+3HrrrSxdupQvv/ySmJgYlFJ4e3vTokUL7r77brp164bZbK40oC4pKWHdunV8++23HD58mMLCQiMDPGTIEMaMGUPNmjXRNI34+HieffZZiouLGTx4MLfffnuVmaDjx48bbegnTZpEt27dLktmx8PDg/Hjx/PFF19w4sQJli9fTnJyMg0bNgTK7qkPP/yQzZs3M2DAAK6//nqef/55Nm3ahNlspmXLlkyePJmIiAgef/xxsrOzGTx4MHfccQe7du3inXfeQdd1JkyYQO/evav8DStWrGDWrFnYbDaeeuopmjVrVu5cp6Wl8d1337F48WKSk5PRdR2r1Urjxo256aabGDZsWIXMglKKpUuX8sUXX9C0aVMefPBBZs2axXfffYfdbqd+/fpMmjSJfv36oWkacXFxzJ49m40bNxqBsNlspkGDBgwYMIDRo0cTFhZW7fOgaRo9evTg/fffJzs7m8OHD1doslRaWsr69evRNI327dvTtGlTOnTowI4dO4zn+7kB/7Zt2ygqKsLPz69CZkUpxe7du5kxYwYATz31FC1btmT27NksXryY/fv3A3Ds2DFuvfVWNE3jgQceqND8yul0cvjwYT788EO2b99OXl4eFouFunXrMnLkSEaPHo2vr+9VL11VSuFwONi/fz+ffPIJR44cITMzE4fDga+vLx07duSuu+6iVatWFZqtFRcX8/LLL3Py5EluvfVWmjdvzrPPPsuBAwfw9PSkU6dOPPnkk2iaxpNPPonD4eAf//gHgwYNIi8vj7feestoZlodo0aNYtSoUeXSnp+fz6JFi5g/fz4JCQnk5uZiMpmoWbMm1113HTfffDM1a9askJl3PR98fX2ZPHkyVquVTz/9lFWrVpGfn4+madSoUYN+/fpx1113UaNGDeNcHThwgBkzZhjBanFxMc888wwhISG0bduWRx55xDhWBQUFbN68mblz53Lo0CFycnIAjGCoQ4cO3H333bRo0eKqNFmyWCxG4aOmaZUWDCmlSE9P54cffmDlypWcOnXKqLV31ZoMGDCAsWPHEhoaWu6azs3N5fHHH6eoqIj7778fgJdffpmYmBgCAgLo27cvjz322HlHqlRKsX//fnbt2gVAt27dyr3LqqJpGr1796Z///44HA769etXZZNkpRSnT5/mo48+YsOGDWRlZRnX0dChQxk7dmyV+cLi4mK2b9/OnDlz2LdvH9nZ2Uafj4CAAFq1asX48eNp27ZtuePrdDqZO3cuCxYsoH379kyYMIE333yTn3/+GV3XadKkCQMGDGDjxo0cPnzY2FdV19qfRrW6jKs/7qhTw4cPV4CqW7duuVGnli1bpgBVs2ZN9eGHH6rmzZsrk8lUbqQCQJnNZjVixAiVnJxcYQQCu92uFi9eXOW6mqapwMBA9cYbb6iSkhIjTR9//LECVLt27dTLL7+sfHx8yo029MwzzyiHw6F0XVeHDh1SQ4YMUWazucL2AWW1WtWwYcPU8ePHK6RP13W1efNm1b59e2WxWCpdH1AWi0UNGzZMJScnl1vf6XSqr7/+WoWHh1cYxeHs/Y8fP16lp6cb+3c4HOqVV15RgPL29jZGnXI6ner9999XgGrSpIn673//q+rVq1fptj08PNR9992ncnNzK/ym3Nxc9eSTTyovL69Kj3nNmjXV008/rWrVqqVMJpNatmzZRV03SUlJqlOnTgpQjRo1UllZWRe1vssjjzxS5XG70N+UKVNUYWGhGjJkiAJU586dy406peu62rt3rxo0aFCV59Zms6l7771XZWRkGOdmz549xvLnjjplt9vV7NmzVURERKXp1jRNBQUFqenTp6uioqJy6xYUFKhBgwYpQI0dO1Y98cQTlZ4fQIWGhqovvvii0hE9zpw5ox544IFy98S592OXLl3U4cOHjWuha9euClAtW7as8lzpuq5eeuklpWmaioyMVPv27av2iCIPPfSQsf9zRxSritPpVP/85z+N4zZ//nzju+LiYjVmzBgFqDvuuEPdfffd5e5vb29vtXLlSnXmzBlVq1YtBagHHnhAlZaWqtOnT6u6desqQI0ZM6bKkahKS0vVqFGjFKDat29fbgQZXdfVjh07VM+ePat8rnh4eKhbbrmlwugsTqdTvfXWWwpQXbt2Vc8//3y582w2m9Wrr76qnE6n2rlzp4qOjq702ehatnv37sa5rA5d19W+fftU/fr1FaAee+yxCuvu3r1b1a5dW3l4eBgjx3z55ZfKw8NDhYaGqk2bNlU4V+PHj1eAio6OrjA6oWvUKVe6ly5dqkpLS9X9999f5f379ddfK13X1ezZs41r4Mknn6zy3nLdqxfzrImPj1ft2rVTgOrevXu1R5368ssvjeN/7qhTuq6rgoICNW3aNFWzZs0qnwOBgYHq5ZdfVoWFheWOf15enuratasymUxq8uTJavDgweW2ERQUpA4fPqwOHDigbDabAtS7776rnE6nSk1NVT179ryo5+QLL7xQLu2HDh1So0aNMrZd2TXXunVrtW7dugqjNm3ZskVpmqZCQkLUf/7zH9W2bdtKr12TyaQGDBig4uLijN++atUq5e3tXek+hwwZYhyn1NRUNXHiROXp6Vnlu0HTNBUREaFWrFhR4diOHDlSASoqKuqiRp16/vnnlclkUv7+/mrx4sXnXTYrK0sNHDjQuB/OvSZ1XVdbt25VnTp1umC+YsiQISoxMbHc+q7nmo+Pj3r99ddVy5Yty63XpEkTlZ2dfd40Op1ONWPGDGO0rOnTp1/UM6SkpESVlpYqp9NZbr1169YZ6XjooYeqfH658oWJiYkV9pudna0mT56sfH19z3uOw8LC1HfffVfhHfzkk08qQA0aNEg9/vjj5a5lm82mbr/99irfra5r7Ur72486dSE5OTk8++yzOJ1OxowZw/DhwwkMDOSXX37hxx9/5PDhwyxevJjBgwczYcIEYz2lFFu3buVf//oXcXFx1KpVizvvvJMBAwYQGhrKoUOHePPNN9m5cyfTpk0jIiKiXMkLlI3Z/Pbbb+Pt7U2PHj2w2WwkJSUxbNgwzGYzSUlJTJw4kV9++QVvb29GjhzJqFGjiIyM5NSpU/z444/MmzePJUuWoJRi9uzZ5ZoRJCQkMHnyZHbt2kV4eDh33303N910E56enkapyqxZszhw4ABLly5l6dKl/OMf/zAi9EOHDvH000+TkZFBz549mTRpktG2MzY2lrfffpu1a9fy1Vdf0b59eyZOnFjt0riUlBSefPJJvL29ue+++xg0aBCaprFu3Tp++OEH4uPj+fzzz7nxxhsZNGiQsZ7T6eQ///kP77zzDiUlJXTu3JmJEyfStm1bkpOTmTt3Lt9//z1vv/22UcJytdx555306NGDPXv2MG3aNKCsNLRjx47GMtnZ2Tz88MPk5uYyfPhw7rjjDsxmc6UdVs+WkpLCxIkT+fXXX/Hx8eGmm25i5MiRNGzYkMTERP773/+yaNEiZs+eTWhoKNOmTTtv6Ziu6yxYsIDHH3+cM2fO0LBhQyZMmEDPnj2xWq3s3LmTWbNmsXPnTqZPn46fnx/33XdfpbUHK1asoKCggCZNmnDzzTfTuXNnEhISWLp0KUuWLCE9PZ3XX3+dgQMHlptXoLi4mJdeeokPP/wQTdPo1asX48ePp2XLlpSUlDB37lxmzZrFtm3b+L//+z+++OILQkJCuOmmm9i+fTsnTpxg69at5a4Xl6ysLJYtW4ZSio4dO1baTt+dNE2ja9eufPjhhyil2LlzJzfccEOF5TZs2EB6ejr169enVatW5Ofn4+XlRYsWLSrdblhYGEOHDmXmzJmsXbuWpKSkSueGOHLkCNu3b8dkMtGvXz9q165t/N4TJ04wYcIEdu/eTWBgILfccgs33HADtWvX5vjx48yZM4fFixczb948LBYLH3zwQaXzD8XGxvLuu+/i7+9Pr169MJvNpKWlMWjQIDIyMnjqqac4fPgwUVFR/Otf/6J3796YTCZyc3OZOXMmc+fOZcuWLbz++uu899571WoSoGka9evXp0mTJsTFxbFz505KS0uNJqpKKfbs2UN6ejr+/v507doVTdPo1q0bvr6+ZGVl8euvv9K1a1ejRDs9PZ2DBw8C0Lx5cyIiIi6YDrPZzL333kuXLl1466232Lt3L02bNuXll19G0zQ6depUbnmlFP/+97+N+2bgwIH4+Piwbds2PvvsM2JiYpg9ezbXXHMNd9xxx0VfmyUlJcTHx1frGGZkZJx3OzNmzOC1116jpKSE6Ohoxo8fT/fu3XE6naxfv55Zs2Zx8uRJXnnlFTw9PXnwwQcrPAeUUvzwww+kpKTQrFkzoqOjSUtLo2HDhtSpU4fTp09X2Le/vz/Tpk07b/oOHz7MjBkzyM3NpUmTJuWawcXHxzNx4kQ2bNiAp6cnN9xwA7feeivR0dHExsby008/8cMPP7Bv3z7uuecevv/++0pruvPz83n++ecpKSnhxhtvZMSIEYSHh7NlyxZ++ukn9u3bx5o1a/j222957LHHMJvNtGrVim+++YalS5cyc+ZMPDw8eOGFF2jSpAk1atTAZrOhlOLdd9/l008/RSnF9ddfz3333Ue9evVwOBzGNbB8+XJOnz7NBx98QOfOna/IHFTqt+a3Z86c4fPPP2f9+vV4eXlx3333Vbj3k5KSePzxx9m+fTuhoaHcfffdjB49Gk9PTwoLC9myZQuzZs1i3759rFixgsWLF3PvvfdWuKZLS0v58MMPSUlJoV27djRq1Ii4uDjj3jgfp9PJ/v37UUphNpsvqnZa07Rqlfh/9NFH2Gw2brvtNoYOHUp4eDh79uzh888/Z//+/SxevJhOnTrxxBNPGO9WVz7s3//+t1FjMmnSJBo2bGjUkHz11VcsWrSItLQ0/vOf/9CnTx/CwsIq7P/AgQNs2bKF8PBw2rRpg9PppLCwkH/+85+MGjXqvNfan051I5o/a40GoHx8fNQ777xj1Dq4bN68WYWEhChA9ezZU9ntduO7kpISY9vBwcHqxx9/VA6Ho9y+9+7dqxo1amREp1lZWeVqNAAVEBCgPv/8cyO6jouLUw6HQzkcDjV16lRlNpuVl5eXmjZtWoVINT8/X7322mvKy8tL2Ww29c477xhp0HVdffbZZ8psNiuTyaTee++9cul3LbNx40YVFhZmpPHs6PrDDz9UNptN1ahRQx0+fLjC8T127JiKjo5WVqtVDR06VBUXFyulqlejAaiQkBA1b968ciUzuq6rOXPmKF9fX6PE92xHjhxRderUUYDq0aOHOnr0aLnvXaVxnp6eRunT76nR8PPzU2PGjFHjxo2r1t/KlSsrlHCcfa0tWrSo3PfJycnG8X/kkUfKnaOqajQcDod68cUXldlsVp6enmratGmqqKio3D5TU1PVgAEDjGv/1KlTSqmqazRSU1NVmzZtFKAaNGigtmzZUuG8HD9+3Ki1qFevnjp+/Hi54+76DlAdO3ZUJ06cqFDrMWHCBGUymZSXl5f67rvvym1/xYoVKigoSAFq5MiRFWoR7Xa7mjJlilGK9eOPPyqlykqwXTVjEydOrFDKr+u6Wr16tQoMDFRms1nNmTOnGlfB/1xKjYau62rp0qXGehMnTjS+O7tGA1CNGzdWu3fvVk6n06i10HW90hoNpZRatGiR8vf3VzabrdK5UJxOp3rvvfeUxWJR3t7eauvWreWO4aRJkxSgfH191XvvvVfuuafrusrKylJTpkwx1v/iiy+Ma+HsGg3Xs2/u3LnKbreXe379+uuvKiwsTGmapubOnVvh+OTk5KiRI0cqs9msoqOjy11L1fHYY48pTdNUkyZNyj0DiouLjdqJIUOGqIKCAuPzXr16KUDdeOON5Ur/d+7cqerUqaM0TVPvvvtupefy3BoN1zHPyMhQ/fv3V4Dq1q1bhXvGVaMBqPDwcPXNN99UWMZ1PgF16623Vrtk9uwaDW9vb9WqVSvVunXrC/5FRERUWaOxc+dO4x689tpr1aFDhyrUaG3fvl21b99eAap27drlzp2rRsP1m7t166ZiY2OVruuqsLDQKAGurEbjfHRdV3FxcWrw4MEKUDVq1FA//PCDkbbS0lL1/PPPK4vFomw2m3rmmWcqlIoXFRWpd999VwUGBipN09S4ceOM60Op/9VoQFmN3ksvvVThnbt3715Vu3ZtBag2bdqUW1+psnemK09x7rwp8fHxxrEfNGiQSk1NrfA7c3NzjWd+UFCQ2r9/f7lj+3trNKxWq+rbt2+F99Ydd9yhhg8frpo1a6bMZrPy9/dXzz77bKUtCr788ktjTo633nqrQr7CdSxr1KihANW3b99y19DZzzVN09Qtt9yiUlNTjWfP2a0jqlJcXGzUunh4eKi4uLhqH4vzObtGw8/PT/373/+ukC/cvn278dt69uxZ7vu0tDTVunVr49o/u9bLJT8/X91+++3GPtavX298d3aNhus6X7FihZEnjI2NNc77+a61K01qNKqhR48e3HvvvRUiwZYtW3Lttdfy008/cerUKUpKSoySmz179rB161Y0TeOGG25g0KBB5UqMNU2jVatWjB07ls8//xxPT09ycnIqlE4MGzaMm2++2Win5ypNO3HiBN999x1Op5MePXrwwAMPVOig6ePjw/3338+CBQvYvHkzX3/9NXfccQfBwcHGTLW9e/fG09OTm266qUKpk6ZpREdH07JlS9auXVuuLwGUtecvLS012uyq3zozuURGRvLiiy+SmJhIVFTURXUQ1DSNkSNHcv3111foAH3ttdfSvHlztm3bxsmTJ7Hb7VitVpRS/PTTT6SkpODn58cjjzxSoX22t7c3DzzwAAsXLmT79u3VTk9V8vLymDNnTrWX79SpE3379r2speVnzpxh0aJFOJ1O2rZty4QJEypcG6GhoUycOJGYmBjCw8M5ffo0kZGRVW5z/vz5HDp0CA8PDyZPnkynTp0qnJdGjRrx8MMPs23bNhITE5k3bx5PPfVUhW35+vryxBNP0LBhw3LHwdvbm1tvvZWvvvqKwsJCTp8+bVxTTqeTH3/8kaysLPz8/Hj00UepWbNmue2azWbuuOMOo8YkISEBKLtPu3btyrx589i4cSOJiYnlfquu6yxevJjs7GyioqIqDO14OWiahp+fH97e3hQWFpKVlVXpch4eHjzyyCO0atUKk8lU6fDI57r22mtp3Lgxu3btYvny5YwdO7ZcqWNJSQnff/89DoeDvn370rx5c+O7AwcOsHDhQgCuu+46/vGPf5RrI+xqJ/7QQw8xf/58Dh48yBdffMGoUaMqdGbXNI1Ro0Zx/fXXG/e+6/mVmZlplEzb7fYKzw4/Pz/jOmvSpEmlHbrPp1+/frzzzjskJycTExNDVFQUUNZ3y9U/o1evXkZNh8VioU+fPqxfv57NmzeTk5NjDH154sQJUlJS8PDwuKzXxnXXXcfo0aMr3FfdunWjY8eOrFmzhsOHD6Pr+kW3zS8sLDT6ilwq9VtpbFZWFv7+/jz66KPl+vVA2fDd7du356GHHuKf//wnKSkpzJ49mxdeeKFCnwc/Pz+mTJlizMPg5eV13gERzsfVrn/58uV4eXnxwgsvcP311xtpy8rK4ssvv8ThcNCuXTseeeSRCu9aT09P7r33XtasWcP8+fP5+eefOXjwIB07dqzwvG7Xrh0PPPBAhfRGRUUxYMAAZs+eTVxcHIWFhdXunJuamkqnTp2oX78+EyZMqLQDsq+vLwMHDmTp0qVkZWVRVFR0MYfpgux2O2vWrLngcu3ataN///6VDmZTVFRE7969sdlsjB49utL3flRUFK1ateLMmTMV8hVnCwsL45lnnjFK9Ks7uqNSyugPGxQUdFGDV1RX586due+++yrkC5s3b07//v35+uuvOXbsGHa73VgmIyODVq1a4efnx9133029evUqXFs+Pj4MHjyYr7/+mry8PPLz8yvdv9lsNoa3dz0PKqu9/iv4WwQa/fv3r/QB6OnpaQxz6Kq28vHxQdd1Nm/eTEZGBp6enlx//fWVPmw0TeP//u//GDduHH5+fhXmk3Blqs/dt1KKmJgYjh8/DsDAgQOrrD718vKif//+bN68mQMHDpCammp06r777ru5+eab0XW9wljRrkDkzJkzVU7+07RpUzw8PEhPT+fuu+/mySefpHXr1tSoUQNfX1+sVmuF5mDVZTKZGDhwYKXVfAEBAcaxstvtxohSubm5bNy4EafTSf369avs/OXn58dtt93mlkDDw8OD5s2bVzuICg8Pv+yjqcTGxhqZiiFDhlRa7appGoMHD6ZNmzZ4eXmdNyNnt9tZv349drudevXqcc0111Sa0dE0jdatW1O/fn327NnDli1bKCkpqfAyqlu3Lu3atav0ONSvX9/YdkFBgZGpKioqYtWqVQDGKEGV7b9hw4bMmzcPTdOMa8RisXDLLbfw008/cfToUXbu3En9+vWN/WdnZ7No0SI0TWPYsGEXnam9VOqsyciquiaCg4Pp3LnzRWUs/fz8GDVqFLt27WL9+vXExsbSunVr4/uDBw+ya9cubDYbI0aMMJ5NSikOHjxIQkICJpOJQYMGVTniXEBAAL169eLgwYPs3r2b7OzsCs8ps9nMtddeW2lmJDw8nBo1apCcnMyUKVNIT0+nX79+1KpVi8DAQEwmE127dr3kuVxat25NWFgYycnJ7N+/n4EDB2Iymdi3bx+JiYkEBQXRqVMn47iaTCa6dOmCv78/GRkZbN++nRtuuMF4ljudTtq1a0ft2rUvKT0XomlahdGsXPz9/Y1hre12O4WFhRc9ClVoaCj9+vWr1nPq1KlTbN68ucLnubm5xhC/zZs355prrqn0ujWZTAwePJiIiAiOHDnCli1byM7OrvB+i4iIIDo6+nc/D/Py8njhhRf48ccfjcB83Lhx5X7ryZMnjeZYt956a5XvS09PT+68807mz59PRkYGW7duLdeU1aVv376V3hsWi8UIpnVdN4Ymr462bdsya9YsiouLKx3N0uFwkJGRQXFxcbW3ebFMJhONGjWqNEPvdDrJzs4mOTmZ9evXM2bMGB588EEeeOCBck2Z7rzzTm666aYL5itcz77zadmy5SUPnesKLlyjaLpbnz59Ks2feHh40KBBA2Pf+fn5xvFp0qQJ//3vfyksLKx0YAen00lmZma5kSir4unpaTRd/qv7WwQa52uTW9lD0ul0GqM/Wa1WYzSZygQFBZW7Gc+++TRNq7KU+dChQzidTgCWLVtmBB3nUkpx9OhRoKzN4+nTp41SKJvNRlBQELquGyXAMTExxMbGEhMTQ3x8PAcPHuTkyZOVbvu6666jY8eObN68me3btzN69GgiIiJo3bo1Xbp0oW/fvrRq1arCsKzV4RpqrqrvKjvueXl5RulI7dq1q3wZuzKkFovld89+W7duXdasWfO75tFwt8TERONl5CrJrYy3tzeNGjW64Pays7OJj48Hyo7xa6+9VmUpnWsoU4C0tDRyc3MrBDqVBdUuVWU6MjIyjFL/+vXrVzkstNVqrbRUp3PnzkRHR7N//36+++47brzxRjRNQynFmjVrSEpKIjAwkGHDhl2RNqyuF67rPFUV3Hh7e5frp1JdgwYN4t///jdnzpxhyZIltGrVCk3T0HWdn376iYKCAiIiIujfv79xb+q6bpSYa5rGDz/8wK+//lpl+l2ZzqKiIhISEsrN8QJlmZaqnl/R0dGMGDGCjz/+mNjYWB566CHCw8Np1aoV7du3p2/fvnTu3Bl/f/9KRx+7EH9/fzp06MDixYvZvHkzDz30EFarlXXr1lFSUkLDhg3LBauu2ts6depw5MgRNmzYwPXXX4/T6WTTpk0Al709fFUZKqvVamSazg5OL0ZUVBSffvpptYYF/+qrryoNNNLS0khLSwPKZo8+3zMvNDTUKJFPTk4mNze3wj0fHBz8u4+n3W7ngw8+4IMPPsDpdHLbbbfxxBNPVAh6jx49aozGeG5N6rkaNGiAzWajtLTUeHeeq6rZsKt6N1WHyWTC398fPz8/iouLiY+P58SJE8TFxREXF8epU6c4fvy4MXLV5eDr68vbb7/N0KFDK3znyj9s3LiRGTNmcOTIEV588UVq1arFHXfcgclkqjRfkZiYyMmTJ4mLiyuXrzhx4sQF01OnTp1qTQFwLpPJZFx/ubm5lJSUXPQ2LqSq+9VsNpd7P56dxzCZTPj6+uLj40NJSQlJSUkcP36c06dPc/r0aU6cOEFMTAyHDh264H1utVovWLv9V/G3CDQudlxiV1QKZSUc507udDGqyoCc3dRizZo11aruBIyhUl1iYmKYN28en332GUlJSTgcDpxOp9EUKjQ0FE9Pz0o7ToeFhTFr1ixeffVVFi9eTFpaGrGxscTGxvLzzz8zffp0o7PgLbfcclGZcU3TLvq4l5SUGNWM52Z6zt12QEAAvr6+FY7HX8HZnSWr03H1QkpKSoySuezsbL7++utqr1fZA95isVx0KUxWVpYRWF/KLOi1atVi4MCBHDx4kK1bt3L8+HGaNm1KUVERixYtorCwkDZt2tCtW7eL2u7vcfToUeNlUtV5stlsF116rWkaUVFRdOvWjfnz57No0SL++c9/EhAQQEpKCitXrkTXda699toKgabruaKUYsmSJdXan/ptro3K0lFVQOnt7c20adMIDQ3lm2++4dSpU6SmprJ69WrWrl3Le++9R0REBKNHj2bChAkXfR27BtBYsmQJe/fupaioiOLiYrZu3Yqu63To0IHw8PBy69SrV48WLVpw+PBh9uzZQ25uLsnJycTFxeHl5UWPHj0ua+nhH338+8LCQuM5EB4eft7CI5PJZDyDS0tLKy1V9vHxueSmUlD2nv3qq6+YMWMGpaWlDBkyhJdffrnSmgbXM9HLy+uCc195eXkRHBxMSkpKlU2TLte5ys3NZdmyZXz66ads27aNkpISnE6n8efl5UVgYKAxrPiVZLPZaNy4MQ0bNiQyMpKbbrqJrKwsZs6cWaEmODY21shXJCQkVMhXhISE4OXldcEBWQICAi6qybWLpmnG9eeq5b+YTLmu60ZH8qpc6jVQWFjIqlWrmDVrFhs2bKC4uLjcOfbw8DjvvB0urrnc/g7+FoHG76nadZVcXq59m0wm7rzzzgrt1atatlmzZka6Tpw4wT//+U/WrVtnBBVBQUE0atSIpk2b0q5dOxo2bMjUqVNZvXp1pWmLiori3Xff5cEHH2Tt2rWsXr2agwcPkpaWRn5+Ptu3b+fAgQPs3buXN95447K+TK1Wq7H9qtq8u9jtdmO+kL8yd1ezu+bfqM49caFapUtVUlKCrusXVUtmsVgYMWIEH330ESkpKaxdu5YmTZqQnJzM2rVr0TSN0aNHX1Lp2aVQv41KB2X3ZWXNM1wu5Vj5+vpyww03sHjxYqO5WJ8+fYx70cPDg9GjR1e5bYvFwoQJE6pV4lxVLdKF0h4SEsIzzzzD7bffztatW1m2bBm7du0iJSWF7Oxsjh07xvTp09m2bRsfffRRueZuF2IymejQoYPRFOrIkSMEBARw4MABAAYMGFBhWyaTiQEDBvD9998TExNDQkIC+/fvp6CgAH9//0rb6v+duEqsoXrNUVxBic1mqzLDdqnH0+l0snLlSp555hkyMzNp164db775ZpWFemeP+nOhWmyn02kUkPyeQOhiFRUV8cYbb/D222+Tn5+Pv78/NWvWpHbt2kRFRdG6dWs6dOjA1q1bmTx58hVL17lMJhPdu3enXbt2rFmzhl27dpGWlkZISIjRrPv+++9n9erV5fIVDRs2NPIVjRs35sUXX2T58uXn3delXh9ms5kuXbrw+eefG6OhVdXU71zqtxHRZs+eTc+ePbn55puJjIx0y71fWlrKRx99xPPPP09OTg6+vr7UqFGDGjVqGP1WOnbsSExMDPfee+95azV+T+3Zn83fItC4WGaz2XhBOxwOEhISqnwAlpSUkJaWRnBwMB4eHtXOPLkiWV3XGTlyZKVVnefjdDp55plnWL16NSaTibvuuot77rmHpk2blqt5yMnJOW+JglIKHx8f2rRpQ5s2bXjwwQc5ffo027dvZ8WKFcydO5e8vDxmz57N8OHDGTJkyEWl82K4Hsx79+4lMTHRqCqvLM1paWkUFBT8YWeR/j3OPn9xcXFVLqfrutFe3cPDo8rz7OHhYQRwgYGBTJ48+YqXpLia0EDZ8ImlpaVVntszZ87g6emJl5cXNpvNeBi3a9eONm3a8Msvv7B06VLuuOMONm3aREJCAnXr1jUmkbvclFLEx8cbTXIaNmxI48aN3b6fgQMHUqtWLeLj41mzZg3XXnst3333HaWlpXTs2LHSfjKua0cpxe23337JfSSqQymFxWKhSZMmNGnShNtvv520tDR2797N2rVr+fbbbzl9+jQrV67kiy++4Nlnn72o7bdt25aQkBAjYKhZsybx8fGEhITQrl27Stfp2rUrvr6+JCYmEhsby549eygqKqJDhw7nbQL7d+C6pwCj9ruqZ4bdbic1NRUoayrpzs646rfhoB988EGSkpKIjIzk/fffP++Q367ruqCggIyMjAqDD5wtPz/fmCSvsv5tl4NSigULFvDmm29SWFhI69atee655+jYsWOF2jzXRGxXk9lsNvI0drudtLQ0mjVrhq7rPPfcc6xYsQKTycQdd9zBhAkTiI6OLvdeck1GeblomkbHjh2pXbs2p0+fZu3atdx///0EBQVd8BnvdDqZPXs2P//8M2vWrKFTp07nHSilupRSrFu3jhdffJGcnByioqJ45pln6NGjB/Xr1y+XF7kaNVZ/ZH+9XJobWCwWmjdvjs1mw263V9nHAcpmnG3bti3R0dGsX7++2vs4e9bVLVu2GNHtuX9KKTZu3MhXX33F8uXLjQfo8ePH2bBhA1DWsW369Ol07drVuBFdf/n5+cboDbquG81XSkpK2Lp1K19//TXLli0Dym5u16y+o0eP5r333uPFF1/E09OTkpISdu/effEH8yL4+voaD+WkpCT27dtX6XK6rhu//a8oKirKGGXofLPopqWlMXDgQBo3bsz7779fZUmfq5YLyuYUOH78eJXXW05ODnPnzuWHH35gx44dbuuIV6dOHaMjrmuEt8oUFxfz2GOP0ahRI8aNG1euRsfLy4sxY8ZgsVjYtGkTSUlJxghL3bp1O29/Fney2+188sknxMfHo2kagwYNuqR+GBcSGhrKjTfeCMCSJUs4efIkmzZtwmQycd1111Xap6J169ZG3yXXqHmV/TmdTlatWsU333zDqlWrqtV50UUpxaFDh/j++++ZM2cOhYWFxnbDw8MZOHAgL730Ep999pnRhMBV+3MxQkJC6NChA6Wlpezfv5+VK1eilKJ169ZV1gDXqlWLNm3aYLfb2blzJ3v27EEpVa4vy8VwPRP/CmrVqmVkLpOSkkhKSqpy2ZiYGKM/R0REhNv6trj6HE6aNInjx48TEhLCG2+8YcyHUpU2bdoYIxPu3r37vLUaO3bsMAahcLUAcJeqMteFhYX89NNPFBYWEhgYyLvvvsuNN95o1OKdXXodExNjrOcase1KOztfY7VajWZTJ06cYN26dUDZ6Hevvvoq3bt3r5CvKCgoMPry6bru9g7brtYWnTt3BmDz5s0sXrz4guvpus66devYtm0bAN27d6dNmzZuKYCy2+0sXLiQrKwsPD09ef311xk7diwNGzY0+qG5/mJiYozzeqnn+HIGcleaBBqV0DSNzp07ExYWRnFxMfPmzas0QnU4HCxcuNBoP1rdzIbrJmrZsiUAP/74Y5Wdh3JycnjyySe58847eeyxx4wMQU5OjtF0qHHjxpX2n1BKsW3bNqNDnMPhMKrDS0pKeOutt7jzzjt59tlnK2Q0NE3D09OTZs2a4eHhYXQSu5wsFgtjx44lMDCQM2fO8Nlnn1VIl67r7Ny5k/nz51/WtFwtmqZRp04dY6KpZcuWcerUqQrXhq7rrF69mtOnT5Ofn0+9evWqzBBZLBaGDBmCzWYjNTWV2bNnV9p22RXUTpw4kbFjx/Ldd9+5rcbIarUazV327NnDpk2bKvwmpRTHjx/n119/JTMzkxo1apRr+mAymejduzd169YlJyfHmFjJYrFwww03XJYhEM9NX15eHl9//TXvv/8+drudWrVqcc8991yWJltWq5WhQ4cSFBTE8ePHjfbSvr6+jBw5ssK50TSNtm3bGpNHffPNN+VeeGc7c+aMMWLes88+e1EZBaUUCxcu5Pbbb+df//oXp06dqpAOs9lMZGSkkYG5lOOjaRo9e/Y0RtNatWoVJpOJTp06VdlfLCgoiM6dO6NpGps2beLAgQN4e3vTpUuXS8psWCwW4xr8vQNPXG0+Pj7GPXj48GHmz59vFDydzW638+233xIfH4/FYqFXr15uazKblJTEww8/zM6dO/Hz82Pq1KkMHz78gs+ZyMhIo3ninDlzOHHiRKXPj+TkZD777DMAY2ATd9ZyupqSuppwudLgcDiMQkDXhJzn/iallNHHyqWyvlGXW3FxMZ999pkxGETHjh2NwD03N9fIVzRs2LDSPlpKKXbs2GHUzLhG7HQ3b29vHnnkEYKDgykuLubll19m/fr1lV6zUHZ/Hjt2jCeeeIK0tDQ8PT0ZOXKk22rvdV03mnRbLBZat25d6TlOT09n6dKlxmeXeo6rutb+jCTQqELLli0ZOHAgAMuXL2fmzJnk5eWh6zq6rmO321myZAlffvklmqbRu3fvi6qeq1u3LrfeeisWi4WjR4/yxBNPcOrUKZxOp7GP3Nxcpk+fzo4dO9A0jYEDBxolhJGRkcbDf9u2baSkpBgXomtejF9//ZXnnnvOyFQ6nU6jhNjX15cOHTpgMpk4ePAg77//PoWFhcYFres6OTk5fP/998Zsxq7Shcupa9eujBw5El3X+eKLL3jjjTdIT0+ntLSU4uJi1qxZwz333GPU0vxedrud48ePc+TIkWr/JScnX9abPjw8nDFjxmCz2Th+/DgvvPACKSkpxrXhdDo5cOAAM2bMoLCwkMaNG9OzZ8/zbnPgwIF06NABXdeZPXs2H330EXl5eTidTpRSOJ1Ojhw5wvPPP092djY2m40bb7zRbaW5JpOJm2++mdq1a1NUVMS0adPYuXMnDofD+E0ZGRm88cYbnDx5koCAAKM0/2zNmjWja9euOBwO/vvf/xIXF0e9evXo27evW9IZFxdX6TnfvHkzs2fP5q677mLSpElkZ2fj6+vLU089RatWrdyy73Npmkb37t1p0qQJBQUFzJw5k4KCAuOzyjRp0sQYkWvnzp0899xzJCUllTvPGRkZvPjiixw5cgRN0xg+fPhFdVh3FcR4enqSnZ3N9OnTSU1NNfbhej4uXbrUaPp3oeuzKh06dCAgIMAYAMDDw6PK4ZkBYxZhLy8vtmzZQlJSEg0aNKBJkyaXlOE0mUxGB/Lk5GROnjxJaWlplZmdP7qbb76ZRo0aYbfbefPNN5k/fz7FxcXGO6ewsJA5c+bw4Ycf4nQ6iYqKYtiwYW7Zd1ZWFk8//TQrVqzAZrPxwAMPcPfddwNlbd8r+3OVBgcEBHDXXXfh5eVFUlISjz76qDESlev5cebMGaZMmcLevXsxmUzccMMNbmkyczZXYVtRURH79u0z+gp6eXkZQ6Lm5eWVyxC77on09HSeeuqpcjX1Vc2xcKlcI2ZW9gw7fPgwy5cv57HHHmPKlCnGHCHjx483AvfIyEhjZLOdO3eSlJRUIV+xbds2nnnmGSO4cDqdbp8PxKV9+/bce++9WK1Wjh07xu23387bb7/N6dOnsdvtOBwO7HY7+fn5zJkzh9tvv53du3djNpsZPXq0MZqWO1itVuO5W1payqpVq8oV0LjyTNOmTeOXX34xPr/Uc1zVtfZnDDj+OnUzbmYymXjyySc5evQomzdv5oUXXmDNmjVcc801+Pj4sGfPHhYtWkR2djZt27blmWeeuahSH03TGD9+PJs3b2bRokX8/PPPnDx5kv79+9OsWTMyMjJYuXIlW7duxW63069fPx555BHj4gsLC+OGG27ggw8+YPfu3YwZM4a77rqLwMBASktL2bBhA/Pnz6ekpITmzZtz5MgRo7rTNeLIuHHjWLJkCevXr+eFF15g7dq19O7d2xixY/ny5ezYsQOTycStt956RQINm83Go48+yuHDh9myZQsvv/wyH330EREREWRnZ5OYmEhJSQnR0dFuGSYwISGBQYMGXVQm5LbbbuPNN9+8bDU8mqZx++23s2XLFubMmcPXX3/NwYMH6d+/P7Vr1+bEiRMsWLCA+Ph4atWqxSuvvFJhBJ5z+fv78/LLL3PPPfcQExPDE088wbJly+jcuTM1a9bkyJEjzJ8/n/j4eLy9vXnmmWfO28H5Un5Thw4dePzxx5kyZQrbt29n5MiRDB8+nCZNmpCVlcXixYvZt28fHh4ePP7445WOIGU2mxkzZgzz5s0jMzPTyCi7a+6M+++/v9Iqa1cHU1egHhYWxtNPP80999xzWZvW+Pj4MGrUKLZt22YEgCNHjqyy9sZkMvHQQw+xc+dO1qxZw7fffsuBAwfo27cvTZo0ISUlhaVLlxpNikaMGMG99957US9jTdPo0qULd955J//5z3+YO3cuBw4c4MYbb6RmzZrk5uayefNmVq9eTUlJCb179+amm2666N+uaRr169cnKirKmDMnLCzsvP1OXMFZQECAMVR2dHT0JY/l7+XlZQyFmpCQQK9evahTpw4PPvggY8eOvaRtXk316tVj2rRpRl+8u+66yyiEcDqdbN26lbVr1xrDJ8+YMcNtQ3AuWrSIb775Bl3X8fLy4uDBg1x33XXnzTjVrl2bDz74gODgYG699VY2btzIN998w5IlSzhy5AiDBg2icePGJCQksHr1amOwgP79+/Pkk0+6vZYzMjIST09PiouLmTx5Mv/9739p06YN77zzDiNGjGDu3LlkZmbyr3/9i3379hmFEMeOHWPevHkcOnSIpk2bcvr0afLy8irUBv5ehYWFTJ48ucrR1UpLSykoKEAphbe3N/feey8333yzcf+HhIQwYsQI3n33Xfbt28eYMWMYP348QUFBlJaW8ssvv/DTTz9RVFRkjPBWWFhIcnJytQa0uVgeHh5MmTIFp9PJhx9+SGJiIk8//TTvvPMOzZo1o06dOqSnp3Ps2DESExMpKirCbDYzbNgwXn311SrnEboUrvllPv30UxISEnjiiSc4evQoXbp0AcoKqebOncvevXtp0KABZ86cISsry2iRcLEFHee71v5Iw/FXx58+0LDZbHh6ehrNe1xMJpPxkDnfS9Q1xrmnp2e59TVNo0mTJnz88cdMnjyZjRs3smLFClasWGEs4+vry9ChQ3n++edp1KiR0afCYrHg6emJ2Ww+774DAwN57733qFGjBvPmzePo0aPlOoppWtksviNHjmTq1KnUqVPHSKPJZGLy5MkkJyezfPlyNm/eXG7sdC8vL5o1a8aTTz6JzWbj7rvvpqCggF27dhlj8teoUYN33nmHp556il9++aXC7zObzQQHB/OPf/yDyZMnG80fNE0zfuO5x831udVqPe9vP/u8nU3TNJo3b87HH3/Miy++yPr168nKyiIzMxOTyUSNGjWYNGkSJpOJhx9+2DgWF0PTNDw8PIzr42JLY84d0u9815qrCZrrmJyrquvXz8+PN998k4CAAL799lt2797Nzp07je89PDxo164dzzzzTLkReDStbIZeu91eYSb7Xr16MXPmTJ599ln27dvHsmXLjP45gDFG/X333cf9999f7ty4ms5Vds7O/b2u/Z/7ey0Wi1E6NWPGDBISEvjggw+M781mM/Xq1WPChAlMmjSpykxCx44dadGiBfv27SMgIIChQ4f+rqDv7HkOXCWp57LZbPj6+lK/fn2GDRvGqFGjaN++fZX7dR2r82V0zr4Ozzfs6oABA4iIiCA1NZUGDRrQp0+f817zNWvW5KOPPuLZZ59lyZIl7Nu3j71795bbb2hoKMOHD+fZZ5+tEKS67uFzr8mz+fj4MGXKFIqLi5k/fz779+8vV1KraRr+/v6MGDGCV155pdIZdKvDNTfHgQMHUErRo0ePcrOkV7VOx44dWblypdHc7kLXx9n38Nn3jclkYsyYMSxZsoRjx46RnJxMcnIyO3fuZOzYsZjNZjw9PY1Z36viusbOd0zPdfb1cTFNz1xpslgsFYJgs9lsBH2vvPIKx44d44cffuCHH34wlvH19eWaa65h2rRp9OzZs8JM59V5DriOp8lkMgL37OxsLBYLFouFoqKiC45YBGXNd1xNeby8vHjttdcICwvjiy++IDY2ttzzw2QyERISws0338xTTz1V4bo2mUx4eXldcGZ217ny8vKqcK4aNmzILbfcwrx588jLy2PPnj3Y7XYyMzPp168fjz/+OO+99x5JSUm8+OKLxnoWi4Xw8HAefvhhRo8ezSOPPMK2bdvYsGGDMUfM2cf2YgMkVxM/p9N53hEZzWYzNWrUoH379tx333307t27XAGppmk8+uijJCUlsWTJErZu3Vquf5WnpydNmzbliSeewM/Pj3/84x8UFRWxY8cO2rRpY4xsVp3nWnW5mtg1bdqUjz76iCNHjpCYmEhiYmK55Tw9PWnSpAn33nsvt956a6WTc7qugQsNfVtZ/sZVk/vss8/yyiuvEB8fzxtvvGGsYzabCQkJ4d577+Wuu+5i6tSprFq1is2bN1NSUmI0wawq73Su811rf7ZAQ1PVrIfp06dPpZ/37t2bqVOnujVR1eUaBSAhIQFvb28GDhxoNAFISkoyhnTt06dPuUy6i6u9/5EjR/Dy8mLYsGEVbnCllDGr8S+//GLMuhsZGUmHDh0YMGAAPj4+xraVUpw8edLo4D1kyJDzlra6qiNdJZAxMTFkZGRQs2ZN6tatS48ePejRowcWi6VC+l1pW7ZsGdu3byc2NhZd16lVqxadOnViyJAhBAUFkZeXx5IlS7Db7URHR9O+fXvj5aGUoqSkhOXLl7Nr1y6SkpLIzMw0OhAPHDiQNm3alJt0y9Vmevfu3VgsFoYNG4afnx9KKY4dO8a2bduMDquVtY90OBxs2LCBxMREQkJCGDBgQIUHkqu6+eDBgxw8eBCHw4GnpycdOnQgMjKSmTNncv/992Mymdi1a5fRp6E6ioqKWLt2bbn5Ki5Go0aN6NKlS7lRlKq61oqKili8eDHFxcUVjv3ZxyE0NJT+/ftXOA52u51t27axevVqTp06RV5eHpGRkTRv3pxhw4YRFhZW7rrIyspiyZIl6LpOly5dKjQZUUqRm5vL0qVLjapxu91OREQEDRo0YOjQocZQp2ev53A4WL9+PUlJSYSFhdG/f/9KS/7z8/NZvHgxdrudNm3aGEHt2Vx9MZYtW2YMpVyzZk2aNGnCoEGDiI6OrrD/sxUWFjJ+/HjmzJlDp06dWLt2bbUmMqvK9u3bz9vpHspK+sLDw2nYsKFxTVeVPqfTyebNm4mNjSUgIIAhQ4ZU+sItLi5m8eLFFBUV0axZM6Mp47mKiorYsGEDqamphIWFVasGTimF3W5n8+bNrF+/nri4OLKzs6lVqxYRERFce+21dO7cudyQp671jhw5wo4dOzCbzQwdOrTKjsCuyee2bt3K+vXrOX36NGlpaXh7e1O7dm369OlDz549L/hCvZB9+/axb98+lFK0aNGCtm3bnjdTf/ZzXdM0454837FKTExk7dq1AMYM52c/706cOMHSpUuJjY3Fz8+Pzp07c91113Hq1Ck2bdqEpmkMHjy4yvHzt2zZwokTJ857PZyrsLCQtWvXkpmZed577lwxMTFGmrp27VphRDTXK981GeTu3btJSkrC09OTOnXq0L17d/r27Yufn1+F82a321m1ahXp6enUrl2bXr16VZqm7Oxsfv75Z3Rdp1OnTjRt2pTDhw+XKyypDj8/PwYNGmRk0lzN//bs2cPq1as5fvw4aWlphIWF0ahRIwYNGkSrVq0qPb5paWksX77cCFgbNGhQ6bPJdb1ZrVaGDx9e7tmilCI/P5+ff/6ZQ4cOUVhYaGQIg4ODjfWXLFlCTEwMmZmZhIaGEh0dzcCBA4mOjkbXdX755Rfi4+Px9/dnwIABeHt7G/fr6dOn8ff35/rrr6/2fXP2PXI+3t7eREdH07hxYyO4OZdrSP/ly5ezbds2YmNjcTqd1KxZk06dOjF48GBCQkLIz89nyZIllJaW0rRpUzp06IDZbK72c+1iKaUoLCxk9erV7N+/n5SUFNLT07HZbEbNZ8+ePY0BZSr7bWfOnDEKU6+99toqJ248cOAAu3fvxsPDg+HDh5frK+jqC7Jw4UJOnjxJamoqISEhNGnShAEDBhj9grZv387x48fx8vJi0KBB+Pn5oes6e/fu5cCBA3h4eDBs2LAqW8Kc71pzVw1+dT3//PNVDnbkem6ez5860LjSzi4p8PDwcHuTCV3XjcmRrFZruaE9z8f18C0tLUUpZaz7e/bvmpTtSo+4cvz4cSMz27hx40p/h9PpZMqUKbz22msEBweze/dut0xs90fmOr9Op9Morfy9zm7z6bqe3dlx8kKUUkY77Iu53mNjYxk4cCDHjx/nrbfe4v/+7/+uaLr/bM6+dmw2W5UZjN/j7HNpNpuxWq1/qVFT4H+FQheqqf4zcQWkpaWlRn+UyzmpoTu53ldnPz+u5Hlx9Wup7LnpKsBzvUuvdNrcwVXYV1JS8rvyFZeD67p1OBxGDcqVPr5nP/Mu9zk+37V2JfzeQOOv9Sa4zC73Q/js6vuL4WrK9Htf7Je6f3davXo1U6ZMISIigk8++YT27dtXKHFNS0szZj1u2bLlRc+8/GdkNpvdPvnU1c5UuF4QF9MsxOl0smzZMk6cOEFERAT9+/e/jCn8a7gc1865LuVc/tlomvanyYRXl6u5zh8lA3kxXO+rq/XOOl9zOVeT2T8z1+hxf8QZ7/8I1+2VfOZdqGnmH92fN+XiL6l169aUlpayb98+Xn/9deLi4oxoXtd1oyPz4cOH8fT0ZMyYMRdssy3+3NLT0zlx4gRHjx7lm2++4bXXXgNg8ODBREVFSW2GEEII8QclNRriD6Vdu3ZMnDiRd999l++//54dO3YQFRVFeHg4KSkpHDt2jPj4eMxmM7fddhvjxo37y0yoJSp37NgxJkyYQEZGBnl5ecaIOJMmTfpLl6ALIYQQf3bVDjQqm7gFcOvwYUJ4eXnx5JNPEhoayieffEJycjLx8fFG22ir1WqMTDRhwoQ/ZLWucK+goCAcDgdpaWlYLBbq16/Pq6++anQaF0IIIcTl4evrW2UMUB3V7gxe2ZCPQLnh64RwF13XSU5OZteuXSQkJJCRkUFgYCA1a9akV69eBAcHS03G30RxcTFr165l3759BAcH06tXLxo3bvynbrMqhBBC/Bm4JtatTHX6yVQ70BBCCCGEEEKI6pIiQSGEEEIIIYTbSaAhhBBCCCGEcDsJNIQQQgghhBBuJ4GGEEIIIYQQwu0k0BBCCCGEEEK4nQQaQgghhBBCCLeTQEMIIYQQQgjhdhJoCCGEEEIIIdxOAg0hhBBCCCGE20mgIYQQQgghhHA7CTSEEEIIIYQQbieBhhBCCCGEEMLtJNAQQgghhBBCuJ0EGkIIIYQQQgi3k0BDCCGEEEII4XYSaAghhBBCCCHcTgINIYQQQgghhNtJoCGEEEIIIYRwOwk0hBBCCCGEEG4ngYYQQgghhBDC7STQEEIIIYQQQridBBpCCCGEEEIIt5NAQwghhBBCCOF2EmgIIYQQQggh3E4CDSGEEEIIIYTbSaAhhBBCCCGEcDsJNIQQQgghhBBuJ4GGEEIIIYQQwu0k0BBCCCGEEEK4nQQaQgghhBBCCLeTQEMIIYQQQgjhdhJoCCGEEEIIIdxOAg0hhBBCCCGE20mgIYQQQgghhHA7CTSEEEIIIYQQbieBhhBCCCGEEMLtJNAQQgghhBBCuJ0EGkIIIYQQQgi3k0BDCCGEEEII4XYSaAghhBBCCCHcTgINIYQQQgghhNtJoCEuiVIKpdTVToYQQgghhPiDkkBDXJKioiIcDsfVToYQQgghhPiDkkBDXJLS0lKcTufVToYQQgghhPiDkkBDCCGEEEII4XYSaAghhBBCCCHcTgINIYQQQgghhNtJoCGEEEIIIYRwOwk0hBBCCCGEEG4ngYYQQgghhBDC7STQEEIIIYQQQridBBpCCCGEEEIIt5NAQwghhBBCCOF2lqudAPHntX7rYYpL9KudDCGEEEKIS+LtZaP/NS3RNO1qJ+UvSQINccnemPkzx2LTrnYyhBBCCCEuSd1awfTt3gKzWQKNy0GaTgkhhBBCCCHcTgINIYQQQgghhNtJoCGEEEIIIYRwOwk0hBBCCCGEEG4ngYYQQgghhBDC7WTUqWooKSkhPT0dXS8/lKvZbCYgIABvb+/zDoumlCI3N5eioiJCQ0OxWK7sYVdKkZWVRUFBQbnPrVYr4eHhmEwSbwohhBDCfcxmE+YL5C+cTh3nWXkrq8VcaX5KoXA4nCj1v237entgNpspLimlsKi0wjpenjYC/LzJLywmv6D49/0Ycckk0KiG7du3c/PNN5ORkVHucz8/PwYOHMjEiRPp0aMHZrO50vWdTifvvPMOixYt4scffyQiIuJKJNtQWlrKww8/zLffflvuBm7Tpg3Lly8nKCjoiqZHCCGEEH9dJk1jcK/W9OzctMpllIJ1vx5m+fp9AAQH+nD3zb0JDfatsGxBYQmffreOpDPZeNgs3H5jD4b3b4+/rzcxp8/w0Tdr2bb3pLG82WTivtv6Mn5Mb156dz5zf/7VCFLElSWBRjUopfDx8eHVV1+le/fuxmdnzpzhgw8+YOzYsXzwwQcMHTq00toBs9nMpEmTuOuuu6hVq9aVTj55eXns2LGD999/n759+xqfe3h44O/vf8XTI4QQQoi/Lk3TaNeiPrde373KZXRdJyunwAg0IuuGMWZ4V8JCKuZLMrLy+XHpdpLOZNOlbWMemzCUM+m5HD6RSN/uLQgN9mPCU5+Smp4LQK0agdw8rAunTqey8pcDEmRcRRJoVJPJZKJ27do0btzY+KxJkyY0b96ce++9l+nTp9O+fXtq1qxJZmYmPj4+FBUV4XA48PPzw2azoZRC0zQyMzMxmUwEBAQYNQxKKbKzszGZTPj7+6NpGqWlpeTk5OB0OrFarQQEBBjNrnRdJzMzE29vb4qLi7Hb7fj5+eHl5VWh2jElJQWz2cw111xDo0aNZPZLIYQQQlw2CsXppEy27TlZ7nNN04ioE0KN0ACKSuwcP5VifFenZhABft7oSpGZlY9+VnSQnVOAw1nWxGrgta3w9LAy7+etfPHDRr54+59ENaxJdKPapKbnYjJpjL6uC2Eh/rz3+Qoys/OvzI8WlZJA43cKCgriX//6F7fddht79uyhU6dO9OnThwEDBrB8+XJSUlJ49913iYmJYfHixXz99de8+OKL5OTkMGfOHHx8fADIzMxk2LBh9OvXj2nTpnHmzBnef/99PvnkE7KysoiMjOSOO+7ggQcewN/fn6ysLPr378+1117LmjVrSEhI4O233+bOO+8sF0gopYiJiaFBgwacPHmS5cuX4+HhwaBBg2jYsKEEHUIIIYRwK11XfPXTL3yzYHO5z2vXCGTWjAmEBPoyZ+EWFq/ZDYDJpNE4siZWq5m0jFyuu+sNcnILjfVcfTQAaoUHAhpn0nNw6jo5eYV4e3kQ4OcNQP06oYwY1IFDxxNZvengFfm9omoSaPxOmqYRHR2N1Wpl//79dOzYkaKiIhYuXMirr75K/fr1qVmzJsePH6e0tBSbzca1117L66+/zpEjR2jfvj0Av/76K8ePH+fll1+mqKiIqVOnsn37dj788EOaNGnCtm3beOmllygtLeXZZ58FoLi4mPnz5/Pqq6/SuHFjatasWSFw0HWdTZs2sX79ek6fPo2/vz/5+fl8/PHHTJ06lWHDhl3xzulCCCGE+GvTdYWuO43/e9is/GPUtTSqH86uA7HM/HoNdnvZ92aziaYNa6FpGnGJGQQH+lAj1J/8gmISz2QZywHk5hcBEOhfNhCPh81KaamdwuKyDuE3DupIrfBAZn69hrTM3Cv4i0VlJIfpBq4mS6mpqcZn3bt3Z+TIkVgsFhwOh/G5yWSiV69evPbaa2zatIl27drhcDhYvnw5UVFRREdHc+DAAZYsWWL0+9A0jaZNm1JUVMRHH33EbbfdRmhoKEopunTpwqhRo7DZbJWmraSkhLS0NJo1a8Zbb71F165dSUtLY8qUKTz66KO0bduWyMjIy32IhBBCCPE31r5VJDcN6YTDqfPJnHWcSc8xvrOYzUQ1qAlAg4gwPph2F6HBfmRm57Ni434+/W6d0f9iz6E4rh/Qnv7XtMRsMtEiqg5JZ7KJOZ1K/TqhXD+gAydiz7B03V7pm/EHIIGGG51dmxAVFVXlsLGNGjWiVatWLF26lHvuuYeMjAw2b95Mnz59CA0N5csvvwRg586dnDp1ylgvNjaWxMREYmJiCAkJAcr6iVQ12hWAl5cXH3zwAVDW+VvTNGrUqMGjjz7K0qVLWbx4MZMmTfrdv10IIYQQojIWi5l/jOpJgJ83G7YeYfPOY+W+Dw32Izw0AKUUIYG+lJY6KCm106BeGPfe2ofIOqE8/OJXFBaXsnDlLtq1iGRAz5Z0at2Q9Kw8Zn6zhtNJ6Txw5yBqhPoz7b35ZOcWVJEacSVJoOEGubm5FBYWUrNmTeOz8/V9MJvNXH/99Tz33HNkZGSwf/9+4uLiGDp0KGazmczMTLKysliwYEGFmoqoqCg8PT2rtR/X92cv7xIYGEitWrXIzMys7s8UQgghhLho7VtE0rlNI4pL7MxZ9Cs5eUXlvve0Wdi5L4agQF+WrN3DsnV78bBZefieIQy6thXXdmlG/54tWbhyF1k5BUx5fS7//Wo1vj6epGXkkpCSScOIcMZc35Xjp1JYsWE/oUF+jBjUkeZN6pCemcfiNbvZd/i01HJcYRJo/E5KKfbv34+u67Ru3bra63Xp0gVfX1/WrVvH9u3bqV27Nm3btkXTNIKDg6lduzbffPMNTZs2rTSYOHdOj6rouk5BQQEWiwVPT09jW3a7neLiYoKDg6udZiGEEEKIi2G1mBnUqxWB/j6cTkxn4/ajFZY5HnuGOx+dia+3B4XFpeh6WTTw2dz1XNMxCj9fL9pER/Dzmj04nToFhSUcOZlkrG+xmBk7ojuhQX68M2s5+QXFvPrkGIb1bUt6Vj7BgT7069GC+5/5vNx64vKTKaF/p/T0dN599106depE586dq7WOpmlERkbSqlUrvv32W1auXMl1112Hr2/ZJDWdOnUiPT2d1atXG+sopTh27Bhz5swhPT39otI3evRonn76aex2u7GtDRs2kJaWZnRGF0IIIYRwN28vD7p3iMJk0lj362EKC6uepTu/sMQIMgASUrKw/zbaVJC/DxZz5dnWpg1rMrhXGw4cS2D1Lwdo2bQuA3u24kTsGW6a+A7fLfqVhhHhjBjYAXMV2xCXh9RoVJPT6eTEiRNG3wjXsLGzZs3i2LFjzJo1i8DAwHIdws/H29ubQYMG8cgjj+Dt7U2/fv0wm81omkaXLl0YNmwYb775Jpqm0blzZxISEnjllVeoXbs2/fr1q/awtMHBwQwZMoS33nqLWrVq0b9/f3bt2sWMGTMYMWIEbdq0ueRjIoQQQghxPpF1Q2kYEY7D6WTXgVM49Yptl3p2asrw/u3x9LDy+fcb2HUgFoBaYQFYLOaySZIzco2g42wmTWPUdV0IDvThvc+Xk5aZR5d2jbFazKRn5ZOYksWh40lomkatGoFYzCacv83JIS4/CTSqwWw243A4eOyxx4zPNE2jXr169O7dm5dffpk2bdqgaRqapuHl5YXVai23DZvNVm4yPU3T6NevH4GBgbRq1Ypu3boZ33l5efH666/z7rvvMn36dLKysggNDWXQoEE8/vjjhIaGGpP12Wy2C/YHGT9+PCaTiY8//pgXX3yRkJAQ/vGPf/Dggw/i7e19GY6YEEIIIQS0alYPq8VMZk4+8cmV9wsN8PfmhoEdsNkslNodxJxOxWw2ccfIa/Dx8iC/sISd+0+Vq+1wadKwJkN6t+FE7Bl+XrOnbHJk49uy5TWpxLhqJNCohk6dOrF7927UOT2IXP0erFarkdkPDQ1l06ZNxghPUJbZf/TRR3nggQeM5lEA9evXZ9++fVgslnIZfk3TCA8PZ+rUqTz22GPouo7ZbMbT09MILIKCgli3bl25fVdG0zR8fHy4//77ufPOO3E4HJhMJnx8fLBYLDJhnxBCCCEum1rhgWiaRk5eEWmZeZUus2HrETbtOEqf7i0YMagjXdo2wmq1EBbih6bBig372bD1SIX1rBYzY4Z3I9Dfm39/toycvLJJ/uKS0ikptVOrRhCtmtajQ8sGOHWduIR0HA6pzbiSJNCoBqvVSlBQULWWNZlMBAYGlvvMVcvh5eV1wWXP3W9V35tMJgICAqqVJk3TMJvN+Pv7V2t5IYQQQgh3MJtNJKZkEp+UQUFhSaXL5OYX8fw7P5KZXcC1XZoRHOiLpmmkZ+ax6pcDvPvZCkrtjgrrRdYL4/r+7Tkak8yqXw4aI0odPZnM4tW7uWFgB/47/W6CA3w4ejKZRat349Ql0LiSNHVuMb0Q1ZCdnc3o+9/nWGza1U6KEEIIIf6gggJ88PSwYnc4yczKRz9PttNqMdM4sgZ1awVjNpmITUjj2KmUSptMAXTvEMWAni3ZtOMYq345UO47f19PBvduQ1SDWmTm5LNq4wGOnUqpsI26tYLZMPdZ6SR+mUiNhhBCCCGEuCyycqo/cZ7d4eTwiSQOn6jeELS/7j7Otr0nK+3cnZtfzNzFW8s6f+uqQvN3cWVIoCGEEEIIIf50dF2h6xVHojqbQ0aYuqqknkgIIYQQQgjhdhJoCCGEEEIIIdxOAg0hhBBCCCGE20mgIYQQQgghhHA76QwuLlmHVg2oXTP0aidDCCGEEOKShAaXTQooLg+ZR0NckuzsbDw9PfH09LzaSRFCCCGEEH9A0nRKCCGEEEII4XYSaAghhBBCCCHcTgINIYQQQgghhNtJoCGEEEIIIYRwOwk0hBBCCCGEEG4ngYYQQgghhBDC7STQEEIIIYQQQridBBpCCCGEEEIIt5NAQwghhBBCCOF2EmgIIYQQQggh3E4CDSGEEEIIIYTbSaAhhBBCCCGEcDsJNIQQQgghhBBuJ4GGEEIIIYQQwu0k0BBCCCGEEEK4nQQaQgghhBBCCLeTQEMIIYQQQgjhdhJoCCGEEEIIIdxOAg0hhBBCCCGE21mudgLEn1dKSTEmXb/ayRBCCPE34Gk2E+7hcbWTIYS4CBJoiEt247atHCwuvtrJEEII8TfQJzSU5d16XO1kCCEuggQa4pI5lcKh1NVOhhBCiL8Bp7xuhPjTkT4aQgghhBBCCLeTQEMIIYQQQgjhdhJoCCGEEEIIIdxOAg0hhBBCCCGE20mgIYQQQgghhHA7GXWqGnJzczl69CgOh6Pc5zabjYiICEJCQjCZqo7ZlFIkJCSQmZlJs2bN8LiK44ArpThz5gwpKSk0b94cm8121dIihBDiD8LhgNLSyr8zmcDDAzSt7P92e9lfZczmsmUBlELl5EJWVtnnoSFoXl7/2w6A04lKTIRSO9SriybzZAjxlyKBRjXs3buXUaNGUVBQgMXyv0Pm6elJq1atmDBhAjfccEOVmXan08mXX37JkiVLmDNnDnXr1r1SSa+gqKiIxx9/nF9//ZV169ZRu3btq5YWIYQQfwBKoQ4dhkWLygKOc0U2gHG3o7mW3b4DVq8B3XnOghq0aIE2aiRKKTh+HL76Gk7FgsUCLZqj7voHWkjI/3adnAIvToOQUHjy8f8FKUKIvwQJNKopICCAjz/+mN69exufpaam8uGHH3LfffdRUFDAHXfcgdlsrrCu2Wzm0Ucf5aGHHsLLy+sKpro8p9PJvHnz+OGHH6hVq9ZVS4cQQog/EKXgyBHYtr3y78+uvdB12L8fduyofFlv7/+t880cOHgIBg+CxETYtBlCQ+H2sWWBh1KwejVkZsFtt6IFBrr1Zwkhrj4JNKpJ0zS8vb3x9/c3PvP39+f5558nNzeX9957j169elG3bl2OHj1KjRo1yMzMpKioiLp161JaWkp2djYNGjQgPj4eq9VKZGQk2m9VyLquExMTg8VioX79+miaRkFBATExMZSWluLr60v9+vXx9PQEwOFwcPToUcLCwsjOzqagoIC6desSGhpqbPNcR44c4T//+Q9t2rQhNTX18h80IYQQf3jK4YCEhLL/BAdDdDSYznqP1Kv3v2WLiyE5uew/NWpAkyZgLKpBs6Zl/0zPgNOnywKPMWPgxAnYvQeOH0cVFqL5+aFOx8PmLdCoIXTsWL5JlRDiL0ECjd/Jz8+Pu+++m4ULF7J79268vb258cYb6datG5s2bSI7O5t///vfHD16lIULFzJv3jxefvllEhIS+PHHHwkICADKakdGjBjB6NGjee6554iJieHll19m8eLFFBQUEB4ezuDBg3n++ecJDw8nJyeH0aNH0759e7Zt20Z6ejpvvfUW48aNqxBoKKUoLCzkzTffpGPHjgQHBzNnzpyrcbiEEEL80TgcEB9f9u8O7WHifWV9Ks5ivFeKiiE5pezfPXvC7bdVvs2C/LLtenuDzQbev9XmFxWB3YHSddiwoaz/xqiRaL6+l+GHCSGuNhl1yg0aNWqEl5cXBw8eBMqaKG3evJnPP/+cXbt2MXDgQOMh7eHhQf/+/YmNjeXgwYMopVBK8csvv5CWlsaAAQPIz8/n8ccfJyYmhsWLFxMXF8eHH37I+vXreemllyj9rcOeruts3LiRmTNnsnfvXoYNG1ZpbYau68ydO5fY2Fgef/xx6QAuhBDifwoLIeVM2b/9/MuaO+3YCadOoSlV/r2Slwfp6WX/9vWBvXth1y44HY/GWQGJr29Z86iCAiguKtsHgJc3WC1wJhXWrIX6EdCtW1mHcyHEX47UaLiBt7c3NpuN7Oxs47M+ffrQvXt3zGZzudGqNE2jZ8+emM1mNmzYQJcuXbDb7SxfvpzmzZvTpEkTdu3axc6dO/n000/p2LEjmqYxYMAAnnrqKaZPn86RI0eoU6cOSil69erFNddcg9VqrTRtSimOHz/Of/7zH6ZMmUK9s6rAhRBCCBIS/jfi1OrVsGJFWW2Eny+qb18YPqysxkHTyppDud5pCxaUjRal6xAQgBo8CAYPKhtZKjQUGkSWNZf69DNITysLJpo2RfPwQM1fUBa0jL0NfHyu1i8XQlxmEmi4gVKqwmcRERFV9pWoV68eHTp0YPny5TzwwAOkpqaydetWRowYQVBQEBs3bqSoqIivv/6aRYsWGeulpKSQlJREfHy8MVpUvXr1zju0bl5eHq+//jo9e/Zk8ODBv/OXCiGE+MuJO10WLEBZwFG7VlmTprR0mDsPTCbULTeXdcWIi/vfenYH1KoJqWmQkgJfflU2atSQwWgWC+rWMVBSAlu2lNVuXHMNDLsOlZoGGzaW9c3o0B74rZ+IUmA2l707pb+GEH8JEmi4QVZWFvn5+dWuLTCZTNxwww08/PDDpKSksGfPHhITExk2bBgmk4n8/HzsdjtpaWkUuqqbf3PdddcRGhparf0opVizZg0LFizg6aefZv78+Sil2L9/P/n5+SxYsICePXvSsmXLi/7NQggh/iJq14Y+vcsy+tddVxZopKbBe+/ByZiyoWx7dC/rFB5Zv2xZmw2GDi2ruYg/Df9+F5KSYfkKVMcOaOHhaI0aoaY8XVZzYbWCtzeazYZauKgskLn1FjRfX9TWrbBuPeTmQXRT1MCBaDVqXN1jIoRwCwk0fielFDt27MBisdCuXbtqr9e+fXtCQ0NZuXIlO3bsICoqiujoaDRNo2bNmgQGBvLKK6/QokWLSmtGMjIyqrWfnJwcQkJCmDlzZrl1c3Nzeeutt9B1XQINIYT4G9M6dYSOHcqaRLma4UZ6ozp0gJhTZYFCcjLUq4d27bVlncAdzrK+FgBRUagWLcoCjczMshGnwsNB08qaUbmGdVcKdSq2bJjbBg2gUyfUwUPwnw/LmlUFBsBPCyAtHfXPiWXrCiH+1KT31SVSSqHrOvHx8bz55pv07NmTDh06VGtdTdOIiIigTZs2zJkzhzVr1jBkyBC8fxt/vFu3buTl5TF//nx0XTf2tXXrVl577TUSExOrvZ9x48Zx+PBh4+/gwYM8+OCDREREsG7dOu6///5LPgZCCCH+5JRC6TrK6URpWlmtBpQ1XQrwLwsAHA4oKCxb1uks+zOdtazJBL+NoEhJCRQXV74rp7Os/0dONgweWNZhfN06yM+HG66HZ6ZAjfCyfh3xCZf7lwshrgCp0agmu93Opk2byMvLA8oCjVOnTvHNN9+gaRpPPPEEPj4+FBQUVGt7Hh4eDB06lPHjxxMUFET//v0xmUxomkbbtm0ZN24c//3vf8nPz6dTp04kJCTw/vvv07NnT3x9fct1MD8fTdPK1Yic3Z/k3O+EEEL8zRQXw/wFsHcfeHmhHnqgbOI8hwMSk8r6bnh7QUhw2QhS382FY8cgNLSs1sHXt6xfR1JS2fZ8fcsClMrEx8MvmyAyErp0QTOZUGlpZUFNrVpl/TsCAspGwCrIv1JHQAhxGUmgUQ2enp4EBQXx+eefG59pmkZkZCSjRo1izJgxxiR7ZrOZunXrEhgYWC4THxQURO3atY2ZwzVN49prryU6OpoWLVrQrl07Y3mbzcazzz5Lw4YNmTVrFt999x3h4eGMGzeOe+65h4CAALKysqhbty5BQUEXFSxomkZgYCB169atdBZzIYQQfyM2G+TmwuHDZc2mli1H9esLp2Jh67ayWou6daFRo7JAID0DjhwFzzhYtx7VtQscOFj2B9C4EVqdOhV2o+x2WL6ibB6NQQP/N2+Gq6mW3V62L12V1ZCY5P0kxF+BpiobMkmU42q6dO6hctUInF0z4Fr27M9dc2UopYxai7OXBcp9Xtl+z91XZfup7m+pLC0XKzs7m2u3/cqBKqrIhRBC/Dmo+HiY/mpZDYamgZ9f2bwXDgfUrFE2gV/btmXvniNHYMYbkJFRFhD4+ZU1fXI6IaIeTPoXWlRU+VGjlEKdjIFpL5Vt78kn0YICy776fHZZjUqf3tC6FXwyq2x+jilT0CLKD7DSNzSMVd17XLHjIoT4/aRGoxpcNRWXumxVgcCFtnu+7y8mTdVJixBCiL+punXh0UfL5sU4ebKsP0aNGmWjUd0yGq1Ro/8FDlFR8Nhvy56OL6uhqF0b6teHW25Gq1unwtC0StfL+mbk58OA29ECA/735YABcOgwbPwFNm8pC14GDkSrU/sKHgAhxOUiNRrikkiNhhBC/IUoBXY7KiMD8gvAxwctNKSsaVVly5aUojLSobAI/PzQQoL/1wzq3MVLSsoCiZIS6NMb7beBT1zbUqmpcPhI2ehWDSIhKgqtkv1KjYYQfz5SoyGEEEL83Wka2GxotWpVb1lPj0r7YlS6uM0G/fpWuS0tPLxsONyzty+E+EuQQEMIIYQQl8+FAgcJLIT4y5J5NIQQQgghhBBuJ4GGEEIIIYQQwu0k0BBCCCGEEEK4nQQaQgghhBBCCLeTzuDiko2qXYeev004KIQQQlxOTV2ziQsh/jRkHg1xSbKzs/H09MTT0/NqJ0UIIYQQQvwBSdMpIYQQQgghhNtJoCGEEEIIIYRwOwk0hBBCCCGEEG4ngYYQQgghhBDC7STQEEIIIYQQQridBBpCCCGEEEIIt5NAQwghhBBCCOF2EmgIIYQQQggh3E4CDSGEEEIIIYTbSaAhhBBCCCGEcDsJNIQQQgghhBBuJ4GGEEIIIYQQwu0k0BBCCCGEEEK4nQQaQgghhBBCCLeTQEMIIYQQQgjhdhJoCCGEEEIIIdxOAg0hhBBCCCGE20mgIYQQQgghhHA7CTSEEEIIIYQQbme52gkQf17OU/E40K52MoQQ4k9L8/fFXKfm1U6GEEJcFhJoiEtW9P5sHAkpVzsZQgjxp2Xt0RHvxyde7WQIIcRlIU2nhBBCCCGEEG4ngYYQQgghhBDC7STQEEIIIYQQQridBBpCCCGEEEIIt5NAQwghhBBCCOF2EmgIIYQQQggh3E6Gt62G1NRUfvnlF4qLi8t97u3tTZs2bahfvz4mU9Uxm67rHDhwgISEBHr16oWPj8/lTnIFhYWFbN26leTkZPz9/enSpQuhoaFomsyDIYT461NKsScngxx7KfW8fWnk41/u+1x7KcVOZ4X1NA18LFa8zWWvS7uuczQvm8SifPysNlr6B+NnsZZ7lubaS9mYnozNZOKa0Fp4meVVK4T4e5KnXzUcPXqU+++/H5vNhre3d7nv/P39GTt2LPfcc0+VAYSu66xbt47Vq1fTtm3bKx5opKam8thjj7F9+3aUUjidTpo0acJ7771Hw4YNJdgQQvylKaXYmZ3GxF0bSCst4r4GzXm6WQfje7uu8+bxPaxJTaywrknT+FejltxctzFOpTPz1EE+PnWIPIcdExo9QmryRuvuhHl4GftafiaeB/ZsZFTdRlwTWuuK/U4hhPijkaZT1RQQEMCnn37KoUOHjL9ffvmFm2++meeee47//ve/OByOStc1m8088MADzJ8/n1q1ruxLx26388EHH7B9+3ZmzpzJoUOHWLBgAampqbz66quUlJRc0fQIIcSVlmMv5eUjuzhRkENOJTUXOfYStmamsj83k/25mRw46+9gbiYZJWW12TEFebx/4gCFDgcvNe9MU79AlqSc5sfEGHSlAMh32Pkk9jAeZjN3RzbD02S+4r9XCCH+KKRG4yJomlauiVRoaCiTJk0iLS2Nzz77jGHDhlG/fn3Wr19PVFQUp0+fJjs7m9atW1NYWEhycjKdO3dm7969eHh40LFjR2N7TqeTrVu3YrPZ6NChA5qmkZmZydatWyksLCQ0NJT27dvj5+cHQElJCRs2bKBhw4YkJSWRmZlJq1ataNCgQbkaiuLiYjRN47777qNbt26YTCaio6MZMmQIS5YsoaioCE9Pzyt7IIUQ4gqx6zqfxB5iY3pSlctk2UtIKMoHoH94XVr6BxvfaZpG28BQAA7lZpLjKKVjUBg3121Mjr2UTRkp7M3JoFR3YjOZ+Tkljv05GYys05CW/sFSYyyE+FuTQON38vT05JZbbuGzzz5j165dBAYGMmnSJKKjozl58iSlpaW88sor7N+/nwULFvD999/z9ddfc+DAARYsWEBISAgACQkJjBs3jvvuu48OHTqwe/dunn32WQ4fPoxSCpvNRrNmzXjzzTdp1KgR+fn5PPTQQzRs2JDY2FiKi4uZNm0aDRo0KJc+Pz8/pk6davxfKcWZM2fYvXs3TZs2xcPD44oeLyGEuFKUUmzJTOHT2CMoQANUJcuklRSTUlyIBkxs2IJ+YXUqDRAKnQ50pbCZTGiahp/VZnzuVIoceylfxB3Fz2JlbL0mWDVpNCCE+HuTp6Ab1K9fHx8fHw4fPgyU1U4cO3aM77//np07dzJw4EBjWZvNRv/+/UlKSmLfvn0opVBKsWHDBgoLC+nTpw/Z2dk89thj2Gw2Vq5cybFjx/jmm29ITk5m2rRpFBUVGfs5fPgw33zzDbt372bYsGHnTWdmZiZvvfUWY8eOJS8vj4cffhgvL6/Ld2CEEOIqUUqRaS/hlSO7SC0pok9YHfx/CwzOdTQvG4dS+FqsJBTm82HMQWbFHmZnVhr6b89ogGCbBxZNI6u0BLvuJK4wD4AgqwdWk4lVqQlsy0qlb3gdOgaFS22GEOJvTwINN/Dw8MBqtZKfn298NmDAAKKiovD39y/X+VvTNHr06IGHhwdr167F6XRSWFjIsmXLaNOmDQ0bNuTXX38lLi6Oxx9/nAYNGmCxWGjbti1PPfUUv/76K4cOHTK217dvX5o3b46fnx9+fn7nfbHl5+dz6tQpvL29SUlJYePGjRVG0hJCiL+CUl3ng5MH2JmVRnO/IP6vcWu8TJVX4u/LSQegwGFnysGtPHdoG0/s/5Wx21by9vG9lOhlfTo6BoUT7R/Eodws7t65li9PHyPQamNIzQhy7KV8HncEX4uV8ZHNsZ5nJEIhhPi7kKZTbqDrOkopzOb/dfoLD6+6NKtGjRr06NGDlStXMnnyZJKTk9m1axd33nknAQEBbNu2jczMTJ599tlyNQ7Z2dkkJiaSmJhI/fr1L7ifc0VERPD+++9TXFzMxx9/zNSpU2nbti19+/b9Hb9eCCH+WFxNpj6JPYy32cLDTdpQ16vy0f4UcCw/BwCbyUxz/2DqevmwPTOVhOIC3ji+l0a+AVxfK5JgqwczWnXj3RP72Z6ZSriHF+Mjm9E7rDbzk06xKyuNUXUb0cI/iBKnk3ynHVTZ8LgevzW3EkKIvxMJNNwgIyODvLw8IiMjq7W8pmkMGzaMxYsXk5iYyM6dO0lNTeW6665D0zSKi4vx8PCgadOmBAQElFu3V69eNGrU6Hel19PTkxtvvJGPP/6YTZs2SaAhhPjLUEqRVFzIK0d2kWsv5Z7IaIbUjOBMcWGF5QAcSnFn/aZ0Ca5BfW9fbqrTCE+Tmc2ZKdyzcx2pJUV8EXeU3mG1CbR60C4glE879EZXZX0+TJpGgcPOJ6cO42+1MalRK3Ltpfz7xH7WpSWio+gZWpuHGreijqePBBtCiL8VCTR+J13X2bBhAz4+PnTq1Kna67Vp04Y6deqwaNEidu3aRdu2bWnUqBGaplGvXj1sNhvjx4+nbdu2lb6YMjIyqrWf4uJi9uzZQ0hICI0bNza2ZbfbKSgowGarvM2yEEL8GenAZ3FH2JmdhofJjK/Fylenj5FZWkKh0w7AvpwMPos7Qt+wukT6+HFz3cYopdAB82/PyO7BNWniG0BqSRGJRQVklZYQaPVA0zTMaJh/eyzrSvFzymkO5mZyV2QzGvn489KRnXx86hDtg0IxoTEr9jAaMK15ZzzMMtytEOLvQxqRXiKlFKWlpezfv58333yTAQMG0KpVq2qtq2kaderUoX379sybN49NmzYxePBgPD090TSNa665BofDwZdffklRUZGxr0WLFvHggw8SFxdX7XQWFRXx4osv8uijj5KamopSipKSEpYsWUJWVtZFBUdCCPFHp5TiUG4mTqUo1p28fWIfk/dvYfrRXeQ6ygKNdelJPHVgKwdzM3EonWx7SVkg4rAbNR1mTTPmwHAo3Zgn41w59hK+iDtKiM3zt0n9yibss5lMvNS8Cy+37IKP2cLG9CRSS4quzEEQQog/CKnRqKbi4mLmzZvHnj17gLKXWXx8PIsXL6Zx48Y88cQTeHp6kpubW63tWa1Whg0bxpdffkmNGjUYMGCAMadG8+bNefDBB3nnnXc4c+YMbdq0ISUlhW+//ZbbbruNsLAwY+SpCwkMDOShhx7i3nvvZeLEiXTt2pW4uDgWLlzIAw88QPfu3S/peAghxB9ViM2TOuf0yXAqRWpxETplo0uFe3jhZTYTX5jPA3t+4WRBDr3D6vBm6+54mcxklJaQXFLW3KqGpzeBtopDgSulWJoSz7asM0xo0JwW/sGcKS6kwGHHopmo6elNgdOOl9lCZmkJRc7KJ3UVQoi/Kgk0qiEgIIC2bdty5MgRjhw5ApTVSjRo0IBp06YxePBggoPLJmay2Wx07tyZiIgIo5mSpmlERkbSoUMHY94KTdPo3r07gwcPpmnTpjRv3txY3mw28+CDDxIdHc3nn3/Ozz//THh4OK+++iojRozA29sbu91Op06diIyMPG+bX03T6N+/Pz/99BOffPIJS5YsITw8nA8//JB+/frJZH1CiL8Us6YxNbojk6Palfs8sSifcdtXk1ZazOg6jXikSRtCPTxRChSK5OJClqXE0TogmHYBocxNPMnxvBwsmsbQmvUJslYMNJKKC/gk9hAhNk/G1W+KWdPws1ixmEzoKPIddnQUDqUT8NsQuEII8XeiKVVFfbAQ55GdnY1jyhtYE1KudlKEEOKC4gryGPTLYlJKCnmwUStebNEZKKuVWJOWyIN7fiGpuAANsJpMlOg6HiYTI2s35KUWXQjxKF8oo5RiVtwRnj6wlfGRzXi+eSdsJjNKKe7dtY4FSbHc17A5Jk3j/RP76Rdel4879CbwnIDF2qMj3o9PvFKHQQghriip0RBCCPGX522xMKBGXbJKS4j2DzI+1zSN3mF1+LxTXz45dZgjeVmklRRT18uHobXqMz4yGh9zxVdlZmkJs2KPEGT14M76zcrNAv5Q49bEFOTx35iDKKCJbyCTGrUiwCKDbwgh/l4k0BBCCPGXF2Lz5LWWXdEB2zlNmMyaRsfAMFq0DibXUUqR04GvxUqQ1QNLFc2dFIqnm7bHz2qliW9AuaayLfyD+aZzf2IKcnEqRaS3H3W8ZGhbIcTfjwQaQggh/vJMmoa3xVrl95qm4W2x4G2p3msx1MOLobXqV7mvmp7e1PT0vqS0CiHEX4X0TBNCCCGEEEK4nQQaQgghhBBCCLeTQEMIIYQQQgjhdhJoCCGEEEIIIdxOAg0hhBBCCCGE28moU+KS2a4fgEdxydVOhhBC/GmZate82kkQQojLRmYGF5ckOzsbT09PPD09L7ywEEIIIYT425GmU0IIIYQQQgi3k0BDCCGEEEII4XYSaAghhBBCCCHcTgINIYQQQgghhNtJoCGEEEIIIYRwOwk0hBBCCCGEEG4ngYYQQgghhBDC7STQEEIIIYQQQridBBpCCCGEEEIIt5NAQwghhBBCCOF2EmgIIYQQQggh3E4CDSGEEEIIIYTbSaAhhBBCCCGEcDsJNIQQQgghhBBuJ4GGEEIIIYQQwu0k0BBCCCGEEEK4nQQaQgghhBBCCLeTQEMIIYQQQgjhdhJoCCGEEEIIIdzOcrUTIP68VOpqdFPR1U6GEOIPRDPZoOZ1aCZ5vQghxN+dvAnEJdOPvoYqOXq1kyGE+ANR1kBM4f1AAg0hhPjbk6ZTQgghhBBCCLeTQEMIIYQQQgjhdhJoCCGEEEIIIdxOAg0hhBBCCCGE20mgIYQQQgghhHA7CTSEEEIIIYQQbifjD1bD6dOn+f777yksLCz3ua+vL71796Zly5aYzWY0Tat0fV3X2bhxI0ePHuWWW24hICDgSiS73P6TkpJYs2YNp0+fxtvbm+HDh9O4ceMq0yyE+ONRSqErOJns5GSyE7NJo0WEmZrBJkwa5e5nXSlSs3SKSlWF7ZhMGjUCTXjaNJRS5BQqVu4qJSFDp1EtM31aW/H11IztKaU4nuTkp80ltGloYUA7G2aTPDuEEEKcnwQa1RAXF8cbb7xB7dq1CQ4ONj4vKSlh5syZDB06lClTphAUFFTp+kop4uLi2LVrFyNGjLhCqS6j6zorV65k8uTJ+Pn54ePjQ0ZGBp9++ikvv/wyw4cPx2w2X9E0CSEuTXqu4vUfCpmzvpj8YoUGBPlq3DXAi38N9yLQ53+Z/7Qcxd3/zmN/rKPCdnw8NWY/4k+XplayCxR3v5PL+v12PKxQYofru3jwwb/88PYoW96pwxs/FDLvlxI+f9gfiTGEEEJUhwQa1eTn58err75K//79gbLgIS8vj4ULF/LII49gs9mYOnUqHh4eFdY1m82MGzeOcePGXelkk52dzdtvv029evWYOXMmderUITExkUceeYRp06bRrVs3atSoccXTJYS4OE5d8cp3BXz4cxFoZQGGwwlxqTqvzC3Aw6rx0A1eWC1lUcCZLJ3Dpx0kZ+pYzJQLDkpKy9YFWLuvlBW7SukcZeXZW314+KM8Fm0tYUwvDwZ38EApxd4YB4u2ldClqZUB7WxSEyqEEKJaJNC4RJqm4e/vzy233EJ8fDyfffYZt912Gw0aNODbb7+lU6dOHDp0iNTUVPr06UNubi4nTpxg2LBhrFmzBi8vL4YOHYrJVNZNxuFwsHDhQry8vBg8eDAAycnJLF68mJycHOrWrcvAgQMJDg5G0zSKior49ttvadu2LSdOnCApKYk+ffrQunXrcs0dnE4nffr0oWvXrtSpUwdN06hTpw7jx49n9OjRxMbGSqAhxJ/A4dNOFvxagq7gtl6ezLjblzPZOje9nE1Mis5Hywr5xwBPQv3LmkMlZzk5k62jAY+N9KZOyP9qLq0WaFiz7Nmz75QTuwOubWnlmhZWOjaxcii+mKMJTga1VxSXwsfLiyguhX8O9cKrYlmKEEIIUSkJNH4nq9XK8OHDeeedd9ixYwdhYWG8+uqr1K5dm9LSUmw2G40aNWLbtm0sWLCAa665hi1btrBp0yY6depEzZo1AYiJieGhhx7iqaeeQinFunXreOqpp9B1HW9vb/Lz83nnnXf48MMPad++PYWFhbzxxhsEBwfjcDiw2Ww0aNCA1q1bG2nTNI2wsDCeeOKJcmnWNI2cnBx0XcdikUtAiD+D0ACNR2705liik9t6exIeaCLIV6NTlJWYlBJSsxUO5//6YxxNcFLqKKv5GD/IiwY1Km8iWWovW8ekgQbYrKAUlDpAAQdPO/hxcwnXtLDSq6VVajOEEEJUm+Qy3aBOnTr4+vpy/PhxhgwZgq7r5OXlsWDBAsLCwnA6nWzbtg0oC0z69evH/Pnz2bNnD4MGDTICC5PJxDXXXENaWhpPP/00bdq0Ydq0aYSHh3PixAkmTZrE9OnTmTVrFgBOp5OsrCwWLVpE7dq1UUpdMBOglKKgoIB58+ZRv3596tate9mPjxDi96sZZGbScG+g7D7OL9I5luRk+zE7GtClqQVvj7L7X1cYfTMCfDS+XVfM6TQnNQJNDO7gQccmFizmskKHumEmTCY4kewkK19xPNGJzQLhARpOJ3y0tIiCYsWEwV4E+spAhUIIIapP3hpuYLVaMZvNFBcXG5/169ePunXr4uXlhaenp/G5pml069YNX19fVq9ejdPppKCggOXLl9O2bVsiIyPZtGkTWVlZ3H///YSHhwPQuHFjHnnkEfbs2cPBgweN7fXp04f69evj6emJl5fXedPpakr1n//8h02bNvH0008TFhbm5qMhhLjciu0w/t95DH42m1NndLo3t/L6eF/8vFzNJmHfqbJAI+6MzgvfFPDJ8mKmzy3kxpeyeX9REU69bFvDOnkQEWZi/pYSBj2bzaZDdprUNtOrlY0dx+0s2VFK71Y2erWyXq2fK4QQ4k9KajTcwOl0ous6Vuv/XsTnG8I2KCiIfv36sWrVKp555hni4+PZu3cvDz30ED4+PuzevZvExERuvfVWbDabsV5hYSEJCQmkpKTQuHHjC+7nXMXFxXzwwQe888473HPPPdx0001GHxEhxJ9HWo5OTIqT4lIFCixmyCsqG/rWrEFGniK7QGHSICKsrBbDx0vjh03FxJ7RmT6vgHaNLPRubaNuqInZjwbw8bIijv9/e3ceH1V5Nv7/c2afTPaE7CsJZGEJEPZFFkEUFbci1WIVZPER9xZ9bH9drLbftu5LtdK6YqsiQkEEAZFFRPYlBAghCWQlO0kmy0xmOb8/8swpMaBoxyJ6vV8vX+pkzsw599znOue6t1Pp5uYJFuZfYSUuQscf3m2jw6ky73IrgRaFumYv9c1e9HqIj9ATYEaGUgkhhDgnSTT8oLa2FrvdTu/evc/r/YqicPnll/Puu+9y4sQJ9uzZQ3NzM5dddhmKouDxeAgPD2fOnDlERER021an0zFo0KCvtX+qquJwOHjuued46qmnuO+++7j77ru79bQIIS4eIQEKf54TSFOrl+dWdbDlkIvbnmph1W9CyUo0YDXBcwsCqWv2kp1sICfVgKLAmGwjc55uodGu8u5WB6OzjZgMCqMyjYzK/HdDiaqq7C92s3KHk+EZRi4bbGLnMRe//Wcbxyo8GPQKlw4y8vufBhIZLImGEEKIs5NE4z/k8XhYv349YWFhjBw58ry369+/PykpKaxYsYIDBw4wcuRIkpKSUBSF1NRUPB4P48ePZ9iwYWdtMWxoaDjv73I6nTz00EMsW7aMX//619x+++2SZAhxEQux6Zg40ISqqgQF6LjpT82crPXyz80OHr0lkOAAHVNzey4PNSLDQGigQlObyokaL60dKuFBPeOLwwWLP+rA6YI7r7TiUeF/X29jf7GLOZdZyT/pZslGB5nxBu65xioP7xNCCHFWMm7mG1JVldbWVj755BOeeOIJrrvuOjIyMs5rW0VRiI6OZtiwYSxfvpzdu3czdepUzGYziqIwceJELBYLf/nLX2hoaNAmcC9evJgZM2ZQUlJy3vvpcrlYvHgxS5cu5ZFHHmH+/PmSZAhxkVFVlYYWL7sLXXyw08lpe9cEC0VRiAxSsFkUVBVO1nQ9HON0q5djFW4OnnDR+H/vBdApCr6UQK/jnA/eO1zqZsXnTm3J25M1Ho6WuYkI0vHoLBt3XW3F5el6Bkebo+eTx4UQQgiQHo3z1t7ezrPPPsv7778PdF346+rq2LNnD5dccgn33nvvWR/Wdy5Go5GrrrqKxYsXk5CQwOTJk7X5Eqmpqfzyl7/kkUceYebMmaSnp3P69Gk+/fRT7rnnHuLj42ltbf3K71BVleLiYp5++mn0ej3bt29n37592t91Oh0333wzY8aM+ZqlIYT4b9t8qJPZT9txuVWeuyOIOZd1NRgUVHhotHtRFEiL7VrCdmu+i/sX26lp8vLAdQH86sc2jAbIP+mmuV1FUaBPnB6bpWem4faoLF7bQWuHyvwrrIQF6jhY4sbtBaNBwWpWCA7QYTZAg91Lp+u/WgxCCCEuIpJonIfo6GiuvfZa7HY7HR0dQFdL4oABA7jrrrsYNWqUlmRYrVauv/56cnJytCFPiqIwaNAgVFXFZrNpnztixAgWLFhA7969tcnd0JUA/PSnP6V///688847NDY2kpyczPz58xk7dixmsxmXy8V1113HkCFDvnQypsfj4dJLL8XtdqOqqrb/vu/xeDx+LSshhP8pisLgNCPpcXryTrj5w7ttVJ/2EmCGFz/soN0JsWE6po/oikND0gyYjQpOF7yyzkFwgEJksI6XPuyg0a7SK0ThJxMtGL7waA1VVdlyyMWqnc6ulab6d83biAhWMOjA5VFpd6o02r04XBAepMMoVxEhhBDnoKiqKv3e4mtramrCuHs6FuexC70rQvwgqKrKyh1O7lvcSmW9lzMDd2y4jl/fZGP2FAsGfdeTwd/Z6uTh11upqPd2PYxPAY8XIoIUfjHTxsKrrBj03RspOpwqc55pYd2+Tl65N5hrR5lQFIU2h8q03zSxr8jFbVOsHCxxsavQza9usvHQjwK6f44xFN2l+1AMNoQQQvywSVuUEEJcBBRF4eoRZpKj9Ly1ycGxiq7lbfslG7h+tJlL+nd/zsWMsWZ6x+hZ+qmDo+Vd702L1XPDGDOTB5nQn2WG3r5iF58c7GRkhpGpuSattzTADL+bZeOBv7Xy6voODHqFGWPN3DbZctbPEUIIIUB6NMQ3JD0aQlwYqqri8oDLDV5VxWxUMOrP/jwLVVVxe8Dp7vpvk0HBZDj3sy8qGzyU13mIDdeT1EvX7X1er4q9Q6W22UugRSHEpsNqOstnSY+GEEKI/yM9GkIIcRFRlK5kwWQA+PJlZRVFwWjg/+ZRfPUStPEReuIj9Gf9m06nEGLrSjCEEEKI8yFXDCGEEEIIIYTfSaIhhBBCCCGE8DtJNIQQQgghhBB+J4mGEEIIIYQQwu8k0RBCCCGEEEL4naw6Jb4xXfYj6PTOC70bQojvEp0RdOYLvRdCCCG+AyTREN+YEjEKxWK50LshhBBCCCG+g2TolBBCCCGEEMLvJNEQQgghhBBC+J0kGkIIIYQQQgi/k0RDCCGEEEII4XeSaAghhBBCCCH8ThINIYQQQgghhN9JoiGEEEIIIYTwO0k0hBBCCCGEEH4niYYQQgghhBDC7yTREEIIIYQQQvidJBpCCCGEEEIIv5NEQwghhBBCCOF3kmgIIYQQQggh/E4SDSGEEEIIIYTfSaIhhBBCCCGE8DtJNIQQQgghhBB+J4mGEEIIIYQQwu8k0RBCCCGEEEL4nSQaQgghhBBCCL8zXOgdEBev6rql6HQtF3o3hPjW6fVBxEXfgqJI24wQQghxviTREN/Yqdq3cXuOX+jdEOJbZzbFExc960LvhhBCCHFRkeY5IYQQQgghhN9JoiGEEEIIIYTwO0k0hBBCCCGEEH4niYYQQgghhBDC7yTREEIIIYQQQvidJBpCCCGEEEIIv5Plbc9DYWEhL7zwAna7vdvrISEhXHnllYwePZqAgAAURTnr9h6Ph1WrVrF//37uvfdeIiIi/hu7fVYdHR0888wzXHXVVfTv3/+c+yzEf4vXq9LRrnL0iIOyUhc6HcQnGMnqZ8Zm03Wro06nl4pyFy6X2uNzDAaFpGQTJpOC16tSfLyTTZ+00tzkpf8AM+Mm2AgM1Hf73q2b29ixvZ1LpwQydLhVzgchhBDCjyTROA81NTWsWLGCnJwcEhISAFBVlZqaGhYsWMDIkSN56qmniImJOedn6PV6jEbjBb2RcTgcLF68mP/3//4fgwYNon///hdsX4SArvMo/5CDv77QSGGBE4+nK4HQ6xUGDbbwP3dH0DvdpJ03Rcc7+e0va2g67enxWeERep75SxyxcUaKjnfyyweraWnxYLXqWLu6hYKjThbeG4HJ1NWR29Tk4dXFjXR0qMy8OfS/dsxCCCHED4UkGucpICCA++67j8mTJwNdN0gOh4PPPvuMuXPn8pvf/Iann36agICAHtvq9XqmT5/O9OnT/9u7DXTta21tLS+99BIvvPACHR0dF2Q/hPii+joPzz3VQGGBE6u1q0fC44GKChe7dnag0sDv/l8MNpuCqqpUn3LT0ODG7QarRYEz8na9/t//v3plC7U1bmbeHML4SYH8YlE1n25p44qrgsjMsuD1qnyyoZWKchc/mhlCcsqFbQQQQgghvo8k0fiGFEXBarUyceJEfv7zn/PUU09RUFBAeno6jz/+OBMnTmT37t1UVVVx44030tDQwMGDB5k7dy7vvfceVquVOXPmoNd3DeVwOp0sXryY0NBQZs2ahdfrpbCwkDfffJPTp0/Tu3dvZsyYQXJyMjqdjtbWVp588klGjx5NXl4epaWlzJgxgzFjxqDTdZ9609bWxoIFCzh06BBz5szh5ZdfvhBFJkQ3qqqyb28HJ090YjDAzJtDmXVbKB0dKn/+Qx2fbm7j0EEHJcVOBgy0onqhvLQTt6ur9+KueyOwWv9d100mhbAwPS6XyqkqNwD9B1pITjESG2egpKiTxnoPqqpSV+tm7Yd2wiMMXH5lMJJjCCGEEP4nk8H/Q3q9nssuu4y2tjb27NlDR0cHb7/9Ng888ABbtmyhrq4Oh8PBnj17WLZsGR0dHVRXV/Piiy9SVVWlfU5hYSGPPvooXq8XVVX517/+xfTp08nLy8PhcLBu3TomT57Mli1bgK7E5J133uFnP/sZH3/8MQ0NDTgcjrO2yiqKQm5uLmvXruWWW27BYJD8Ulx4qtrVATF4iIVBQ6xMuTwQk0lHcLCOocOs6HTg8UJ9bdcwKY8Hioo6AUhJMTF6nI0xl/z7n2EjA7BYvjyk+WZ2fLqljZKiTi6dEkhSsvRmCCGEEN8GueP0g+joaIKCgigpKQHA6/Vis9l44403CAkJwePxaAmCwWDg0ksv5e2332bPnj0kJCSgqioff/wxISEhDB8+nMrKSn77299y44038uCDDxIcHMypU6dYtGgRjz/+OAMHDtS+x2w28+qrrxIZGYmqqme9YQoICOB///d/MRqNHDly5L9XMEJ8CZ1OYdKUQMaMs+Hs9BIS0tW75/VCY4MHrxfMeoiN7wpTbrfKyZKuRKOjw8vzT9dzqspNXLyBSVMCyRlkxWhUMBoVYmK7tjmS7yQ62kD1KTe2QB3hEXoa6j18uMpOaJieK6cHYTBIkiGEEEJ8G6RHww/0ej06nQ6Xy6W9dskllxAREYHJZMJoNHZ7/9ChQwkLC2Pjxo243W5aWlrYuHEjQ4YMITExkU8//RS3280NN9yA0Wiko6OD0NBQfvrTn1JQUMDRo0dR1a622bFjxxIVFYXRaMRkMp11/xRF6bEPQnwXGAxKVwIQbkCv75qHcfSIk7UftgDQp6+ZpOSuet3Y6KG+vmtI1NEjTtautnNgXwerV9r57S9qWLu6Ba+367y4cnowkZF6/vV+M//782qamzyMGRdAam8Tmza2Ul7m4rLLg4iLl/NCCCGE+LZIj4YfuFwuPB4PFotFe+1sk8J9goODueKKK1ixYgWtra2cOHGCQ4cO8Zvf/IaAgAAOHz5MSUkJU6ZM6Tbfwu1209bWRm1tLZmZmV/5PUJcTFRV5Ui+kyf+WEdtjYegYB2zbgvFau3qcaipdmO16nB1ehica2XUmADa21VWLu+a+L3k9SYGDrKSkmqib4aJPzwRy6aPW6mvdzMwx8rES220tXn54F8tRETqmTotEIDjx5zU17sJDNTTJ8P0lcOvhBBCCHF+JNHwg6qqKlpbW+nTp895bzN58mRef/11CgoK2L17N52dnUycOBEAnU5HQkICjz32WI8lcxVFoV+/fn7dfyEuNK9X5dBBB888UU9JUScWi8JPbgllyNB/P58mI9PMH5+Mxen0kphkIjRUh9cLAQE6Xnyunvo6N3t3d5CcYkSnU8jINJORae72Hevea6a8zMWMm0JISDTx/tJm3l/aTFubF4Ne4ZKJNv7n7ggCAiTZEEIIIf5Tkmj8h9xuN6tWrSI6OppRo0ad93ZZWVmkpaXx/vvvc/DgQcaNG0dsbCyKopCWlkZbWxsJCQmMHTsWRekaUuL1evF4PBgMBk6fPv0tHpUQ/z2q2pVk/L9Ha6mqdGM2K9x2exg3zAzBZPr3/AlboK5b4gCg10P/ARbMFh2tdi9VlS48HvjiegfdV5rSM+2qYCorXPzjzdOYTDoW3BnBqn8189GHdvoNsDD1ikCZIC6EEEL8h6TZ7htSVZWGhgb++c9/8swzzzBr1izS0tLOa1tFUejVqxdjxoxhxYoV5OXlMXXqVEymrgeTTZkyhcjISP74xz9SVlaG1+ulqamJRx99lMsvv5wTJ058y0cnxH+HqqoUHuvkqT/XUVXpJihIx4KF4fxoZghms67b+8rLOtm7u53PP2ujufnfD+xzOr2o3q7/tlgVdOeIap9uaeNEcSeTLwsiIcFI4TEnra1eMjLNXDk9iFFjbDidKscLnXh6Pg9QCCGEEF+T9GicJ7vdzsMPP8zjjz+uveZwOKipqWH27NnMmzfvay0bq9frmTZtGs8++yypqalceuml2nyM2NhY/vCHP/CrX/2Ka6+9ll69euFwOKisrOThhx8mKSmJlpYWvx+jEP9tba1eXl3cyImSroUUpl0dxJhxNlpavIAXRenqyTCbFXZsb+f1v5+ms1Nl4X0RXH1NMF4v7NvTgcPhxWJR6J1mRqfr2RPR2Ni10lRI6P+tNGVUaLV3JShms4KioA2Xam/z4vX+N0tBCCGE+H6SROM8JCcn87Of/Yz29nbtNUVRiIuLY/jw4WRnZ2vDLAIDA7n//vsZNGiQ9ppOp2PSpEnEx8cTEhKifcaQIUP4wx/+QFxcHImJid0+++qrryY7O5s1a9bQ3NxMeHg4Y8eOpX///uj1eqxWK/feey9ZWVlfa4hHr169ePjhh7/WfBIhvg1er8onH7eyd3fXk+oVBT7Z0MrWzW3aewwGhdvnhzNpSiBDhlr555Im7HYvS147TUWZC1enyoZ1rXg8kNXPzMhR1rN+z6aPu1aauuHGEOITulaaiuylR6dTaDrtwe1Sqa/rWtEqLEzP/z1HUwghhBD/AUX1rZMqxNfQ1NTE0eKbcHuOX+hdERepjnYvj/22lk+3tJ3zPQYDPPBgL666JhiPpyupeP3vjVRVurX3KAoMG2Fl4T0RpPQ29Ui86+vc/OyeUzgcXv7weAy907reU1/n5oG7q6itcTNiVAB5Bxx4vPDbx6IZnGvp9jlmUzzDcj5BUSQDEUIIIc6X9GgIIS4InR7GT7IxIMdy7vfoILtf1wRwvV5hytRA0tJN7N/TQUW5C6tNR5++JgYNthLZ6+zh7MD+Djo6vEy+LJDU1H8nIuEReu5b1Is3Xmkk76CD4BA9M38SwsBBFpkILoQQQviB9GiIb0R6NMR/6uuEnjNv/H3b+TZXFL40MfB6VbzerqTli/M3ulZzg7Y2L1arTlut6oufJz0aQgghxNcnPRpCiAvim/Ya+LY73811unOvRKUoCno9BAdLAiGEEEL4myxvK4QQQgghhPA7STSEEEIIIYQQfieJhhBCCCGEEMLvJNEQQgghhBBC+J0kGkIIIYQQQgi/k+VtxTfS1NSEyimMpgu9J0J8+3SKEaslTZ6vIYQQQnwNsryt+MasllQslnM/bE0IIYQQQvxwydApIYQQQgghhN9JoiGEEEIIIYTwO0k0hBBCCCGEEH4niYYQQgghhBDC7yTREEIIIYQQQvidJBpCCCGEEEIIv5NEQwghhBBCCOF3kmgIIYQQQggh/E4SDfGNyBOShRBCCCHEl1FUVVUv9E6Ii4/X60VRFEk4hBBCCCHEWUmiIYQQQgghhPA7GTolhBBCCCGE8DtJNIQQQgghhBB+J4mGEEIIIYQQwu8k0RBCCCGEEEL4nSQaQgghhBBCCL+TREMIIYQQQgjhd5JoCCGEEEIIIfxOEg0hhBBCCCGE30miIYQQQgghhPA7w4XeAfHdo6oqzc3NHD58mI6ODhISEkhLS8NoNALgdrs5dOgQTU1N9O3bl7i4OBRFQVVVamtrqa+vJzs7G0VRLvCRfLs6OzvJy8sjOzubgICAbq8fPXqUuro6goOD6devHzabrdvfDx48SHt7OxkZGURHR2vlV1lZSVtbGxkZGRfikPzO6XRSWFhITU0NFouFrKwswsPDtbrhcrkoLCzk1KlT2Gw2+vXrR1BQkPb3H1JdO7MsrFYrAwcOJDAwsFtZFBcXU15ejtVqJTs7m9DQUO3vXq+Xw4cPU1dXR1paGomJieh0OlRV5fTp05SXlzNgwAB0uu9P+5KqqjQ1NVFQUEBubi4mkwkAj8fDyZMnOXHiBGazmaysLCIiIrSyUlWVgoICqqqqSElJISUlBb1eD0BLSwtFRUUMHDgQg+Hiv0SqqsrJkycpKSlBVVXt9X79+hETE4OiKDgcDg4fPszp06cJCwsjOzsbq9Wqbe90Ojlw4ACdnZ1kZ2drZamqKqWlpXg8HtLS0i7UIfqVqqoUFRVRVlaGwWDoFqOhK34fOXKE+vr6HvFdVVVcLpcW3zMzM4mKivrexXdVVamoqKCwsLBbnQLQ6XSMGDECm82Gy+Xi2LFjVFdX/+Dju8fjoaysjOLiYkwmE5mZmfTq1atbWRQVFVFRUfGV8T09PZ2EhISLJr5f/FFU+JWqqrS0tPDyyy9TV1eHyWTC6XQyYcIEpk2bBsDHH3/MyZMnyc7O5pVXXmH+/PnExMTg8XjYsGED8fHxZGdnX+Aj+faoqorb7WbLli2sW7eORYsWaYlGZ2cnK1eu5PPPP8disdDZ2UlSUhK33norwcHBeDwePvzwQ06fPk1ycjKvvvoqd9xxB+Hh4XR2drJmzRoGDRp0YQ/QTxwOB0uWLKGoqAij0UhnZyfr16/n1ltvpXfv3ng8HtatW8emTZswm810dnaybds25syZQ3h4OF6v9wdT1zweDx988AE7duzAZDLhcrnYunUrt99+O1FRUXg8HrZs2cKaNWswm824XC42b97M3LlziYqKQlVVPv30U/Ly8sjNzeW1117jtttuIyUlBVVV2bx5M2azmQEDBlzoQ/Url8vFihUryM/PJzs7G5PJhNfrZefOnSxfvhyj0ajVlfnz5xMfHw/A7t27+eyzzxgzZgxvvfUWM2fOJDMzE1VV2b59O3a7nZycnAt8dP7h8XjYtm0bO3bsICwsDOi6GezVqxcxMTE4HA6WLl3KgQMHsFgsOJ1O+vbty6xZs7DZbHg8HpYvX46qqoSHh/P666+zYMECgoKCaG9v54MPPmDixIkX+Cj9w+VysWbNGj799FPMZjMej4ePP/6YW265hT59+uByuc47viclJfHKK6/wP//zP4SFhX3v4ntlZSVbt27F4/EAXdfF6upqAgIC6N+/P2az+bzje1ZWFq+88goLFiwgOjoaj8fD+vXrSUxMvMBH6R+qqrJjxw6WL1+uxah169Yxb948kpOT8Xq9Xyu+v/rqq8yePZvk5GRUVWXTpk1YLJbvbHz/7qU+4oJSVZWtW7fS1tbG/fffz+9+9zsuv/xyNm7cSHV1NXa7nV27dtG/f3+GDh1KQEAAu3fvxuv1UlxcTHV1NYMGDfpetECcjaqqdHR0sHr1apYvX47L5er297KyMrZs2cLNN9/M7373OxYuXMjJkyfZu3cvAI2Njezfv59BgwYxbNgwVFXlwIEDqKrK0aNHaWtr+17cOKuqSl5eHgUFBdx66608+uijLFq0CIPBwKZNm3C73dTW1rJu3TquvfZaHnnkEe677z4aGhrYvn07qqr+oOpaZWUlBw8e5Mc//jGPPvooDzzwAJ2dnWzduhWv10tTUxMffvghl112GY888gg/+9nP6OzsZNOmTXg8Htrb29m+fTt9+/YlNzeXyMhIduzYgdfrpaysjKKiIoYNG/adbO36prxeL3v37mXnzp3dWlXb2tr44IMPGD16NI888ggPPvggVquV9evX43K56Ozs5LPPPiM5OZkhQ4aQmJjItm3b8Hq9nDp1iry8PEaPHq31cFzsnE4nlZWVXHnllTz22GM89thj/O53v9MSqcLCQvbu3cvtt9/O7373O+bOnUt+fj75+fnazePhw4cZMmQII0aMwG63c+TIEe0c1+l0pKenX+Cj/M+pqkpJSQkbNmzg6quv5re//S2//OUviY6OZvv27VqL9JYtW/jJT37ylfF9+PDh39v4rigKI0eO5JFHHuGxxx7j0Ucf1RqBbrzxRiIjI6mpqWHdunVcd9113eL7559/rjVo+uL7sGHDsFqt3eJ7TU0NOTk534v43tHRwbp16xg2bBi/+c1veOihhwgJCWHdunV0dnbS1NTE6tWrmTp1arf4vnnzZrxeb4/4HhER0S2+FxcXf6fj+3dzr8QF43Q6OXbsGLm5ucTFxaHX6xk2bBiRkZEUFxdrF+qgoCB0Oh16vR6n04nD4eCTTz5h1KhRhIaGXujD+NZ4PB7WrFnDyZMnufHGG7XhZD6FhYXExcXRr18/DAYDycnJDBs2jKNHj+L1euns7MTj8RAYGIher0en0+F0OmltbWXr1q1MmDCh2zCri5miKEyePJm0tDQURSEyMpKcnBzq6upwuVwUFRURHh5OTk4ORqOR+Ph4Ro8eTUFBAW63+wdV1+Lj43n44Ye1xCksLIyIiAg6OzsBOHnyJFarldzcXIxGI9HR0YwfP57CwkKtTnV0dBAcHIyiKBgMBpxOJy6Xi08++YTBgwfTq1evC3yU/lVRUcGqVauYOHFityFO5eXlKIrCiBEjMBqNREREMGnSJIqLi2lvb8fr9dLW1kZwcDAARqMRp9OJx+Nh69atZGRkEBcXd6EOy+/a29upra0lKCiIbdu28dlnn9HU1KT9/dixY6SkpJCRkYHBYCA9PZ2cnBwKCgpQVRWHwwFAQECAlnz5bo4+//xzJk2ahNlsvhCH5le+pKBPnz4MHz4co9FIUFAQ8+fP56abbkKv158zvhcUFPzg4vuZfD2ysbGxjBw5Ep1OR3Fx8Vnj+9GjR/F4PN3iu6IoPeL76NGjvzfx3eFw0N7eTlpaGmazmdDQUBISEmhra8Pr9XLixAkCAgIYMmRIt/h+7NgxLTZ9WXwfMmTIdzq+S6IhunE6ndTW1mpjdxVFwWq1EhwcTG1tLVarlYiICCorK2lvb6etrY3ExESKiopwu90MHjz4e9ECcS56vZ5JkyYxd+5ckpOTux2r1+ulqqqKXr16aTc+iqIQFRVFfX09Ho+H4OBggoODqaqqorW1lc7OTuLj4zly5AhWq5V+/fp9L8pPURSGDRvGFVdcod2EuN1uysvLiYmJwWAwUFVVRXh4uDauHiAqKoqGhgbcbjc2m+0HU9f0ej0WiwWAmpoaNm7cSFVVFUOGDEFRFKqqqggJCdHGzSuKQq9evWhqaqKzsxOLxUJsbCwVFRU4HA6am5tJTEykrKyMpqYmhg8f/r0pK4DW1lZWrlzJoEGDyMrK0l73tcBbrVZtfouvrFpbW3E4HBgMBhISEqisrMTpdGrDXKqrq6msrGTMmDHfq7JqaWnh9OnTrFq1itWrV7Ns2TL+8pe/UFZWhtfrpbKykpiYGK01VK/XExUVRW1tLV6vl/DwcCwWCzU1NbS0tAAQHR3Nvn37iIqKom/fvt+L8vL1skZGRrJ7927++Mc/8oc//IEdO3YAXXWrqqqKqKgoLeH6svhut9u1+H748OHvVXw/k6qqHDp0iKKiIsaPH4/BYNDmo0RERHRrjIuKiqKxsRGXy9Ujvre3t5OYmMjx48e/d/E9ODiY/v3788knn1BQUMCuXbs4evQoWVlZmEymr4zvZrO5W3xvaWm5qOK7JBqiG5fLRUtLS7dWF9/F2m63Y7Vaueqqqzh+/DjvvfceiYmJpKWl8cknnzBixAiqqqp47733WLt2La2trT0mil3sFEUhPDy824Q2H1VVaWhowGazdevC1Ov1tLa24vF4CAoKYtq0aRw4cIAVK1aQkZFBfHw8W7ZsYcSIERQXF7N06VI2bNhAR0fH96b8fMNcSktLGTVqFHq9noaGhm6tpNBVVm1tbbjd7h9kXevo6ODtt99mxYoVWoKvqiqNjY2YzeYeZdXe3o7L5cJkMjFt2jSqq6t55513iIiIoH///nz88cfk5ubS1NTEsmXL+OCDD2hqarqoy8o33vn06dNMnTq1R69iY2MjRqOx2+t6vZ6Ojg46OzsxGAxMnTqVtrY2/vGPf2A2mxk6dCgbNmygX79+OJ1Oli9fzsqVK6mvr7+oywrQzrMbbriBRx99lAcffBBVVVm/fj0ej4fGxsYerey+mOX1egkLC+Pyyy9n+/btfPDBBwwaNIiwsDB27NjB8OHDOXz4MO+88w6bN2+ms7Pzoi0vl8ulDdfctWsXOTk5JCUlsXTpUm2Ioq8svxjf7XY7Xq+3W3z/17/+pfWObd26tUd8dzgcF21Znamzs5MdO3aQnp5Onz59tMncDQ0NWK3Ws8Z3j8dDQECAFt+XLVtGUlISaWlpbNq0iREjRlBZWfm9ie++kSEVFRX86U9/4qWXXtIa4xRF+dL47na7MZvN3eJ7ZGQk/fr10+J7Y2OjFt+bm5u/c2Ulk8FFNzqdDqPR2GPugaIoWstzeno68+bNw+v1YjKZ2Lt3L6GhoURERPCPf/yDGTNmUFBQwDvvvMMtt9zyvehWPx+KomgTub54optMJi1h69+/P2lpaVr5ffrppyQmJmIwGFi6dCmzZs1i586dvP/++9x4443dWvwvRm63m927d7N69WquueYa+vbtC/ClZaXT6VAU5QdX1wICAliwYAEdHR2sWrWKV199lYULF2IymXC73T3KymAwaGWVlJTE3Llz8Xg8mEwmjhw5gqIopKamsmTJEq666ipOnTrFW2+9xe233661nl1MfGPdt27dyi233EJISAhVVVXd3uObxOubpOpzZlnFxMQwZ84cXC4XZrOZEydOYLfbyc7OZsmSJUyaNIn29nbeeOMN7rjjjot6uMvgwYO1lfF0Oh0xMTGMHDmSjRs3aq2lX4z30DWkzBezcnNzyc7ORlVVTCYT69ato3///rS2tvLhhx9y6623smHDBhobG5k+ffpFu1qXqqpERkYyZ84cwsLCtORh69atjBkzBrPZfNbz8Mvi+9atW0lKSjprfJ8xY8ZFH9/r6+s5duwYs2bN6hZ/z1VWZ9arL8b3PXv29IjvR48e5d133+3x+ReTmpoa3n77bcaNG8eUKVNob29nxYoVLFmyhHnz5mkx62xlda74fvjwYS2+v/nmm1x99dVUVVXx1ltvMWfOnO9UfJceDdGN2WwmMjJS6yKHrhvFjo4OQkJCtAAREBBAYGAgDodDa60pLS3FarWSlJREZmYm5eXlNDc3X8Cj+XZ9MSgoikJcXJzWuuV7j91u18bs+t7nK7+WlhY+//xzRo4cSXFxMWFhYcTHx5OZmUlJSQnt7e3/9ePyF9/47nXr1rFy5Uquu+46Ro0apQXOuLg4Wltbcbvd2jatra3YbLZuQ8++73VNVVXa29upq6vD6/VitVoJDw9nwoQJVFRU0NjYSGxsLA6Ho9sNYWtrKwEBAVrLvW+YY2BgIB6Ph02bNjF8+HCqqqpQVZXU1FQyMjKora2loaHhQh3uf8Tj8bBr1y4qKyv55z//yaOPPsqbb75JXV0dL774ojYMyO12a/NboGuCuMVi0W5UFEXBYrEQFBSEqqps3LiR3NxcTp8+TUdHB3369KFPnz60tLRQU1NzoQ73P+arW2eWBYDVasXpdAIQGxtLS0uLFs98MSs4OFhrudfpdNhsNgIDA6mtreXgwYOMGDGCwsJCYmJiiI2NpW/fvtqY8ouRwWDAZrMRFRWl9VjrdDqSk5Npbm7G5XKdM74HBQWdM77v2LGjR3zPyMjQ5gxd7EpKSjCbzWRkZGi9/L747uu98PmhxveioiLMZjOXXXaZVgeuuuoqioqKqKurIzY2lo6Ojh7x3Wq1njW+u93ubvHdl3BkZGRQU1PznYvvkmiIbsxmM4mJieTn52utEbW1tdTV1ZGamtptuJCqquzatYvY2FhtuVJfIqLX61FVVQvIPwSKopCSkkJxcbHW1etyuTh69Ci9e/fu0crn9Xq1lSTi4+PxeDzaTbjBYMDr9V7U5eebOP/5558zb948cnNzu12Mk5OTKS8v14byeDweDh8+TEpKSo/hMN/3unb06FGefPJJKioqUFW123Api8VCcnKydh6eWVZJSUna3A4fVVXZt28fgYGBZGVl4fV6u5UVcNGWlU6nY/DgwVx33XXk5uYyZMgQ+vTpo607b7PZiI+Pp6WlRUuwfGUVGxvbo2dCVVUOHz6MqqoMHjxYKxedTqfdZH+xZ+Ris2HDBl588UXa29u18jh+/Djx8fGYzWZSU1M5duyYNpTH4XBw7Ngx0tLSeqxi4/V62bZtG4MGDSIyMhKPx6PVKYPBcNZW2YuFyWQiKSmJiooK7Ha7dhzl5eWEhoZisVhISUmhqKiItra2HvH9i6uU+eK7b3js9y2+Q9cx+hYTOLO3wXct9M0hOPM8TE1NPWt837lzJ/Hx8Vp8/76VVXt7u3Zf4GsAUFUVnU5HUlKS9tyQL8b3L/bi+OJ7cHBwt/juWzAFvnvx/eLs3xTfGoPBwNChQ3nllVdYunQpiYmJbNmyhYiIiB6JRl1dHfv37+emm27CZDIRGxvL9u3btYt8cHDwRT3k4JtIS0sjKCiI1157jeHDh3P8+HFqamq44YYbur3PN1musLCQW2+9FaPRSFxcHPn5+bS1tVFRUUFERMR3qvvz61BVlf379/Pxxx9zySWXUF9fT319PdA1PCgzM5OkpCSio6N54403GDt2LKWlpRQXFzN37tweNzjf57qmKAoZGRmEhoZqw3ba2trYsGEDI0eOpFevXni9XpKSkrS/nzp1ioMHD3LLLbf0uGg3NzezY8cOrrnmGiwWC1FRUbhcLpqamrSJ0r4Vly42Op2OnJycbs+4OHLkCAUFBUyYMIGQkBACAwNJT0/n7bffZurUqTQ0NLBt2zZmzJjRIylrb29n27ZtTJgwgYCAAO1BdPX19bS1taHX67VnT1yMfOPAP/vsM/7xj38wcOBAjh07xv79+5k9ezYGg4HMzEzWr1/Pa6+9xqBBg7QY9MXnPaiqyokTJ6iqquL2229Hr9cTHx/Pzp076ejooKKigujo6B718WKhKApjxoxh7969vPHGGwwdOpTm5mY++eQTpk2bhsVi6Rbfhw0bdl7x/bbbbsNgMHyv4ruPw+Hg1KlTDB48uEdDWlJSElFRUbz++utfGd9ra2s5cOAAN998c7f4brfbqaysJCQk5KKO79nZ2Xz88ce8/vrr3eL7kCFDiIqKAtDi+8SJE780vjc1NbFjxw6uu+46Lb53dnZy+vTp72x8V9SLtflBfGvcbjeff/45GzZsoKWlhezsbKZNm0Z8fHy3RGPz5s3U1tZy/fXXYzAYtHWfS0pKtKVNe/fu/Z1eDeE/UV5ezj/+8Q/mzp1LZGQkgLZU3apVqygtLaVXr15MmzaNgQMHdmvxUlWVtWvX4vF4uPLKK9HpdDgcDjZs2EBVVRV6vZ6pU6eSkJBwUZafy+XivffeY/fu3T1aOGNjY1m4cCE2m43y8nI++OADjh8/TlhYGFOnTmXo0KE9Llrf97qmqio1NTWsXr1aW6Fm7NixjB8/HpvNpq2m5Pt7cHAwl156KaNHj+5xIdq1axcFBQXMnDlTGyf92WefcfToUQAuueQSsrKyLtqy+qKioiKWLVvGwoULtaFQdXV1rF27lv3792Oz2Rg/fjwTJkzoMR4+Ly+P3bt3c9NNNxEQEIDH42H37t3s379fWyL3Yn9Wi68HY9WqVVRVVREZGcn06dPJzs7WWouPHTvGqlWrOHXqFLGxsVx11VVkZWV1uyH0eDz861//IjQ0lEmTJqEoCm1tbaxbt057uOu0adO0J2FfjFRVpby8nI8++ohjx45pw11GjRqF2WzG6/VSUlLCqlWrKCsr+8r47vV6mTZt2vcuvvvY7Xb+/ve/M2rUKEaMGNFjxEN5eTmrVq2iqKjoK+N7XV0d1113XY/4rtPpuPTSSy/6+F5ZWcmaNWs4evQoRqOR3NxcLr/8ckJCQlBVlVOnTrF69WqOHDnypfF9586dFBYWMnPmTG3u3pnxffz48WRmZn6nykoSDdHDmWN1gW7jLs/2Pt/fzrbdd6my+5uvC/SLx3k+5XC2+R3fp/L74rF8ke/YzveYfwh17avOOymrszvbefhNY9iZn+d77ftQVmceE/Q8rq/6u+89Z/pi3TpXGV9svup8kfj+b2eee3Du80ti1g87vkuiIYQQQgghhPA7mQwuhBBCCCGE8DtJNIQQQgghhBB+J4mGEEIIIYQQwu8k0RBCCCGEEEL4nSQaQgghhBBCCL+TREMIIYQQQgjhd5JoCCGEEEIIIfxOEg0hhBBCCCGE30miIYQQQgghhPA7STSEEEIIIYQQfieJhhBCCCGEEMLvJNEQQgghhBBC+J0kGkIIIYQQQgi/k0RDCCGEEEII4XeSaAghhBBCCCH8ThINIYQQQgghhN9JoiGEEEIIIYTwO0k0hBBCCCGEEH4niYYQQgghhBDC7yTREEIIIYQQQvidJBpCCCGEEEIIv5NEQwghhBBCCOF3kmgIIYQQQggh/E4SDSGEEEIIIYTfSaIhhBBCCCGE8DtJNIQQQgghhBB+J4mGEEIIIYQQwu8k0RBCCCGEEEL4nSQaQgghhBBCCL+TREMIIYQQQgjhd5JoCCGEEEIIIfxOEg0hhBBCCCGE30miIYQQQgghhPA7STSEEEIIIYQQfieJxneU3W7n97//PXfeeWePf9asWcPOnTt599138Xg82jaqqnLgwAHeeuutbq//t6mqyvbt23n//ffxer09/m6323nzzTfp6Og467aHDx/m9ddf/8bH0NrayqlTp1BVtdvnfvLJJ6xevfqs+/RFLS0tPPvss9TV1bFmzRo+/vjjbp93ppqaGp5//nna2tq+0f62t7fzzDPPcPz48W6vd3Z2UlZWdl77+9/i9Xp58803OXTo0DnL45tSVZWDBw/y/PPP43a7z2ubxsZGnn32WZqamvy6LxeK3W6nurra72V7JrfbTVlZGW63m1OnTvHCCy/Q3t7+tT5DVVVWr17Nxo0bKSsr48UXX8TpdJ7XtmvWrGHdunX/1XpdUVHBH//4R5qbm7+Vz29ra+Opp56iuLj4nO/x1/nc0dHB3/72ty/9rnPxer1UVFTgcDi011RVZd26dV/5m6iqyueff87999/PkiVLqKyspKWl5Svrqu+8XrJkCW1tbbz44ouUl5efdTvftWPZsmXfSv1QVZWSkhJefvllXC4X9fX1NDU1+fV883g8rFq1ihUrVvxHn6OqKsXFxSxevBiXy/WN9qO8vFzbVlVVWlpa2LBhA1VVVXz22Wd0dnby1ltv9bjHuOeee9i2bVuPz2xoaOCPf/wjNTU1bNmyhZUrV+J2uykvL6ezs7Pbe48dO8bChQu1z3zggQd47bXXqK2t/dLy9u33Fz/vi/vx2GOPsXfvXl566aXzjj3iwpBE4zvKZDIxatQopkyZQnZ2Ni6Xi0mTJjFlyhR69+5NS0sL1dXVPbaLiooiOzsbRVEuwF7/W1NTEzU1NT0Ciqqq1NTU0N7ejtFoPOu2ra2tVFVVfePgv2PHDlauXNnjQpWcnExaWtp5lY3vZszlctG7d2+Sk5PP+V7fDcT53hx/kdfrpbS0tMfNXmlpKa+++uo3ush8W1RVpaqqCrvd/q18vt1u/1o3Yy6XS/udvg+2b9/OBx988K3ehDc0NPDSSy/R2tqKzWZjyJAhGAyGr/059fX1NDY20tHRQXl5+Xnvc319PQ0NDV/7+/4TDoeDEydOfGsNMB6Ph9LS0rM2nviUlZXxyiuv/Md11ZcsfNl3nUtHRwcvv/wyp06d6vZ6Q0PDV/4mLpeLVatWkZyczIABA1i6dCmHDh06r+/1xXS9Xs/gwYMJCgo653ubm5u/8mb0PxESEsKgQYNQFIVly5axb98+v39HXV0dtbW1//HntLe3U1FR8Y3Korm5mRdffJHTp09rrxUXF2O1Wtm1axfh4eEAnDp1itTUVKZMmaL9c+mll5KQkNDjM10uFydPnqSzs5PExETS09NpbW3lpZdeor6+vse+u91uJkyYwJQpUxg5ciT5+fk8+eSTX9qw0dLSwosvvkhjY+M532M2mwkNDcVqteJ2u79TjXGip69/dRH/FWazmUmTJmmtQfX19VxzzTUYjUZUVaW8vByAoqIiysvLycjIICEhAYPBgNlsBrpu9g8dOoTD4dBusvV6vfYdqqpSV1fH4cOH0el0hIeHYzQa6du3LwUFBRgMBsrLyxk8eDA6nY78/Hw6OjqIjY0lMzMTt9vNoUOHSEpK4tixY+j1enJycrDZbNp3FBYWUllZSVZWFvHx8QCcOHGCpKQkdDodjY2NHDp0CEVRGDBgAKGhodq+lZWVUVJSQmpqKr1790ZRFOrr6zl8+LAW6Pr27Yvdbqe0tBSv10t9fT379++nrq6OgoIC+vXrp+3LmTdTNTU1HDlyBK/XS58+fUhISECnO3vebTQa0ev12O12ioqKCA8Pp6SkREvqzmS329m3bx9DhgzBZrNx6tQpCgoK0Ov1DBw4kLCwMBRFweVycejQIU6fPk1iYmKPC4nb7SY/P5/Kykr27NnDiBEjcDgcHDlyhObmZqKjo8nMzMRkMnXbzpfIHT16FFVVGTBgAJGRkbS0tHD48GEGDRqE2WwmLy+PiIgIEhMTtbKwWCwMHDiQwMBAVFWlqamJ/Px8nE6nVr++itfrpaysTGttzc7OJiYmhsrKSux2Ox6Ph+rqarKzs4mLi0NVVRobG8nPz8dkMn3pzZPT6WT//v20t7drv5lPU1MThw8fJiQkhAEDBmAwGGhvb+fQoUO0tLQQFhZG//790ev1HDp0iF69elFSUoLVaiUnJwez2YzH4+HIkSNUV1cTERGB1+slLS2NsLAw2tvbyc/Pp7m5mYSEBPr27Yter9d+p7q6OoKCgsjJycFqtXb7HY8fP05FRQUmk4mBAwcSGhpKUVERFouFhIQEOjs7yc/PJz4+nsOHD1NbW0thYSGZmZlaPe7s7CQtLY2kpCQUReHo0aP06tWL4uJiFEUhJyeHlpYW8vPziYqKol+/ftr55fsN4+PjtXO7qqqKXbt2MXjwYCwWC4qi4PV6OXHiBCdOnCAiIoJ+/fphMpnweDxanDEYDAwYMICwsLAev4/D4SA/P5/MzEwCAwNpaWmhqKiIQYMGdYs7vnriKzffcel0Otra2sjPz9d+swEDBmAymbrVxeTkZHr37q2Vf3FxMaWlpQQHBzNw4ECsViuKotDa2sqBAwfwer0EBgb22F+Px0NFRQXFxcXodDoyMzOJjo6mvb2dgoICevXqRVFREZGRkfTr16/HMbhcLvLy8mhqaup2DquqSnV1NQUFBbjdbtLT00lISODQoUPdzufGxkaOHj1KZ2cnycnJpKennzMGnUtbWxsFBQUMHDgQg8Gg9Vakp6dTV1fHkSNH8Hg8WhmXlJRQUVHBnj17CAsL0+LtF3/Hw4cP09jYSHR0tNZwdejQIRoaGrTYf/LkSSwWC2lpacTExGjH7ovper2eAQMGEBISopWNoihYLBbtOKurq7vFnjOvHQAnT56ksbFROz4f33lVWVmJ1WqlX79+hISE0NDQQFVVFQEBAZw8eZKUlJQejUt6vR6z2Ux1dTVFRUVafPNdn3y/bWFhIVVVVdq+BQcHc+zYMcxmMzU1NTidTgYNGkRISAher5fy8nLt+nC2hPbMmOpwOEhJSdHqscfjobi4mJMnTxIcHMyAAQMICAjotr0vmS0uLiYgIECL1Yqi0NHRwf79+3E4HGRkZBAbG6vt/65du5gwYQI2m422tja2b99OXFwc+/fv18pm6NChTJgw4ax1rKOjgwMHDuB0OomKitJeNxqNWmyorKxk9+7dTJo0qVsSGRcXx9VXX43VakVVVS655BKefPJJ9u3bx7hx42hububQoUN0dHQQHR1NVlYWx48fp6qqit27dzNhwgSt7rW2thIREUH//v3xer3YbDb0ej1xcXE9roPiu0USjYuYr1u1urqayMhIFi1axIkTJ9ixYwepqan87W9/4/Dhw0BXUJg9ezajRo1CURTthvSJJ56gtrZWu8iPHj2atLQ0li9fzqlTp1AUhYiICFauXElpaSkejwe9Xs+CBQtITU3l9ddfJzIyUuuizcnJYcGCBUBXklFUVERNTQ0xMTH8/Oc/Jzo6mrKyMkaMGEFTUxNPP/00paWlKIpC3759eeCBB4CuVpbFixdTWVlJQEAAixYtwmaz8dxzz1FTU4PH48FsNnP33XdjMBj461//CkBAQAC1tbU0NTWxd+/ebonG7t27sdvthISE8Nxzz2m9JlarlQceeIA+ffqctZy3bduGxWJhyJAhPP3004SEhGC32/F6vdx7771ER0cDXS04b7/9NhaLhaFDh1JQUMDzzz9Pe3s7Op2OxMRE7rnnHkJCQli2bBnr1q0DIDQ0tEfrjcvlYu/evVRWVvLxxx+TkZHB3/72NwoLC1FVFZ1Ox+WXX87111/f7QJcUlLC008/TWtrK4qiEBsby913343NZmPNmjU0NjaSmprKq6++yj333ENVVRVPPPGE9v3Dhw9n3rx5tLS08MQTT2i9ZuHh4dx+++1kZmaesz76kuKXX34Zp9OJx+MhPj6e+++/nwMHDvD2228TEhJCU1MTsbGxLFq0CIPBwJNPPkllZSUmkwmz2dztRt3H4XCwZMkSPv30UxRFwWaz8etf/xpFUXA6nbz55pvaTdbcuXMZPXo0f/vb38jLy8Pj8eDxeJgxYwYTJ07k73//O16vF5fLRWtrKzfeeCPXXXcd69at47333sPr9aKqKk6nk1/+8peYTCYWL15MXl4eqqoSEBDAjBkzGD9+PFu2bOGtt97SfpNhw4Yxe/ZsLBYLqqqyYcMGli1bpu3DgAEDuOuuu9i0aRMxMTEkJCTQ1tbGP//5T2644Qby8/NpaGhg37592Gw2Hn/8cVpbW1FVFYPBwMKFC+nXrx+rVq1CURRKSkpobW1lwoQJVFVVUVJSgqIoPPjgg0RGRvL8889TVVWFx+PBaDTyP//zPxw4cICamhrWrVtHeHg4S5cupU+fPhQWFvLSSy/hcrnQ6XRcf/31TJs2jc2bN/P2229rLYcZGRnce++9PX4jRVFYuXKl1mq9Z88e8vLyGDhwYI+b9D179rBz505aWlowGo3cd9999O7dm5dffpn8/Hy8Xi8ej4cf//jHTJo0iZdffpmCggKgK5bNmzePoUOHsmHDBpYvX05nZycGg4Hc3Fzmzp2L0+nkr3/9K4cOHcJoNBIYGNhjmOnu3bu1HkNVVQkODubhhx/G7Xbz3HPPERgYSFtbGy6XizvvvJMxY8Zo23d2drJ06VI2bNiATqcjNDRUG7538uRJnnvuOZqamvB6vYSEhHDHHXewd+9eqqqq2LBhAzExMSxevJi6ujo8Hg9Wq5V7772XzMzMr9Ub3dDQwDvvvEOfPn0ICgpi79691NXVERERwfPPP681SFksFu655x4OHz5MTU0NGzduZPDgwT0SDd+5tHPnTrxeL2azmauvvppJkybx+eefU1FRwaZNm6ivr6esrIzGxkaGDBlCTEwMqqrS0NCgnc+KopCVlcV9993Xo9zmzJmjxRhfi/uIESOYO3eu9t6TJ0/y/PPPc/3113crE9/QpA8//FD7TXv37s39999PcXExzz33HGFhYTQ3N2vXjvT0dG37iooK3n//fS699FJOnDhBVVUVQ4YM0RINVVVZs2YNq1at0s7b3Nxc7rjjDtasWcPBgwexWCw0NzeTm5vL3XffTUlJCc8++ywOhwOr1YrL5WL48OE9ynbx4sUcPXpUq8dz585l2LBhbNiwgffff1+rx0OGDGHevHndtt++fTtvvfUWDocDvV5PdnY2CxcuRFVVXnvtNXbu3ImiKISEhPCrX/2KvLw8ampq2LBhg9bwNWDAAJKSkrTGSJ+6ujpOnjyp/b9erycmJga3281rr73Gjh07MBgMhISEaMPu9u7dS21tLQaDgdraWjZs2PClvVWKohAdHU1OTg7l5eU0NDTw4osvaj2NiqIwb948jh49Sk1NDevXr6dPnz6sWrWKgoICPB4Pqqoya9YsJk6cyPTp07FYLMTFxX3tBF38d0micRFzOBzcddddREZG8utf/7pbd7jD4eDQoUNcffXVjBkzhqqqqm5Zv9frZf369URERPCrX/0KRVF44YUXtJYnp9PJ6NGjuemmm2hoaCAnJ4ebb75ZC9JHjhwhJSUFr9dLTk4Ov/jFLzh16hR//vOfKSkpQVVVHA4HixYtIjg4mF//+tfU1tZqrU5xcXHs2rULRVF49tlnAThw4IB24Whvb2fevHmkpKTw2GOPUVpaSkZGBqNHjyYrK4uSkhKWLVvG8ePHycrKorOzk1/96lckJSWxevVqSktLufnmm89abqdPn+bEiRPMmTOHfv36UVRUdN5DRwwGAwsWLCAtLY2nn36awsJCoqKicLvdLF26FKvVym233YbBYGDt2rXk5uYyc+ZMVFVlyZIlbNu2jaFDh/LJJ59wzz33MHDgQHbs2MHLL7/c7XssFgs33XQTHo+Hhx56iIMHD1JTU8Ojjz5KXFwce/fuZfHixYwfP15LdFwuFx999BGZmZnccsst6PV63nnnHbZs2cLMmTO5/vrreemll7BardoQvLfffpv4+HgeffRRrXXU7XazefNmbDYbf/7znwkODmb9+vVs2LCBvn37fmn5KIrCjBkziI+P59ChQ6xYsYK6ujqga1jfww8/DMCvf/1rqqurOX78OBaLhWeeeUa7offdHJ2pqqqKffv28Zvf/Ib4+Hh27typ/a21tZWpU6fy8MMP89prr3H06FFGjBhBcnIykydPxm63s2rVKvLy8hg/fjyqqnLVVVcxdepUli5dypEjR5g4cSIffvght956K+PGjSMvL48XX3wRgPz8fMrKyvjNb35DTEwMhw8f5l//+heDBg3SevR+8pOfYDabKSoq6tayHRAQwNy5cwkMDOTzzz9n27Zt5xw2kJqaytVXX011dTUzZ87krbfeIj4+noULF2KxWHjvvfdYsWIFGRkZtLe3k5KSwn333ce2bdtYsmQJixYtIjU1lWeffZbjx48TFhbG8OHDycrKorS0lPfff5/CwkJuuOEGTp48ya9+9Svt5tjr9bJ27VomT57Mj370I0pKSrSx62azmdtuu43Q0FB27drFxo0bzzp0zmw2079/f/Lz8xk4cCB79+5l+PDhPc4tVVUxGo388pe/JCgoiNdee43169czd+5cUlNTufzyy2lubmblypXk5eUxfPhw8vPzuf766xk5ciQVFRXYbDZaWlpYt24dM2fOZOzYsTQ1NbF48WKOHDmC3W6nqqqKP/3pT4SFhbF8+XLWr1+v7YPX62XdunWMGzeOH//4xzidTl566SXWrFnD5MmTURSF2bNn079/f1544QUKCgoYNWqUdkNz6tQptmzZwgMPPEB2djaff/45f/vb34CuG+HLLruM9PR0jh07xrJly6ipqdHO5//93/+ltraWcePGkZmZSXFxMe+99x5FRUVfmsh/Hc3NzRQVFTF79mwGDBhAcXExJpOJK6+8kt27d7Nw4UJSU1N7bFdcXMyhQ4d48MEHSUlJ4eTJkyxZsoShQ4cyb948ampqmDlzJpmZmTidTsaNG9fthnr79u1YrVaef/55PB4PBw8ePGfr/qZNm0hMTOT3v/89drudY8eOaUl+XV0db7zxBtdeey1jxozplqi2trby8ccf89Of/pRx48bR0NDA448/zs6dOwkKCiIwMJBFixYRFhbGo48+Smlp6VmHzI4cOZK9e/cycOBAxo4d223fgoKCmD9/Plarla1bt2q9Bb5e4rvuuovDhw/z0ksv0dLSwqpVqxg+fDg/+clPaGxs5M9//nOPXuqOjg7y8/O59tprGTVqFBUVFQQEBGC323vUY18joe/c6ejoYM2aNVxxxRVMnTqVtrY2/v73v7Nv3z7Cw8M5evQojz32GJGRkezatQtVVbnuuus4cuQIv/jFL+jVq5eWhISEhGj71NnZidfrZfHixfz973/XXg8ODuaZZ56hoaGB/Px8HnnkEeLj41m3bh1Lly7t1kM1ffp08vLyWLRoEXFxcV9ZN0NDQ7VGywEDBjBz5kyqqqpYvnw5R48eZfr06eTn5/PQQw9hs9no06cP06dPp6GhgRUrVpCfn8+ll15KRETEV36X+G6QROMilpWVpQ0piouL6zb2NyAggGnTprF27Vreeust4uLi+MlPfoKqqiiKgtvtpqqqinHjxmld27m5uVqrocVi0T5bURT27NnDunXrCAoK6jah0mw2M2bMGMxmMwkJCWRmZmo9If369dPmNsTGxtLZ2akNOQoKCqK+vp6srCxtGMbEiRO1AJaamkp2djZ6vZ6kpCQ6OzvR6XRs2bKFtWvXEhQURGtrq7YfUVFRREdHaxcT336fTUxMDOPGjeP111+ntbWV9PR0brvtNq1svkxUVBS9e/fGarWSlpaG0+lEVVXq6+tpbm4mOzsbnU6H2+2msrKSTZs2sWbNGqArqI8dO5asrCzCw8NJT0/HYDAwYsQIVq9e3e17vrgf1dXV2vAzRVHIzMwkKiqKhoYGLdHweDxUVVVx8OBBPvnkE+07hwwZogX16OhoKioqGD9+PF6vVxuWEBgYSGBgINHR0bjdbmpra/n888/Zv38/0DVUISYm5ksn6EHXRfrtt98mICBAGz/rO5709HRtSJLvs1paWujfvz/h4eGoqsrEiRN59913e3xuU1OT1gNgNpsZP3480DUEzndD7ftNCgsLga5hhWvWrCE4OJjTp09rN1aBgYFkZWVhMBhIS0vj5MmTnD59msDAQHJyctDr9dpQCt9wh4KCAq23zev1otPpsNvtXHrppbzyyis89NBDGI1Grrrqqm7H3NrayrJly7SW468aS+z73V0uF7W1tYwZM0Yb9jNq1Cjy8vJoa2tDp9NpQ74iIiJISUkhIyMDg8FAr169ANDpdHz22Wd89NFHBAUF0dLScs7vdTqdOJ1OcnJyMBgMWkLpazB46623CA0NRa/Xf+kxDBkyhDfffJPS0lJOnz591vliiqIwaNAgIiIiUBSFcePGsXTpUhwOB8ePH2ft2rWEhITQ2NhISEgIgYGBXHHFFXzwwQe88cYbJCQkMGvWLMLDw6moqOD555/XksLOzk4GDhyIyWTShvQoisKECRP47LPPtH3o6OjA4XAwcuRIDAYDBoOBsWPHsmnTJjo7O4mIiCA9PR2z2Ux6enqP+WYOh4OIiAh69+6N0Whk5MiR2jms0+n48MMPga66dubEa9/x63Q6Nm7cyNq1a7WeE3/q1asXEydOZMmSJdjtdnr37s2tt97a7RjOFutaWlooLi7m4Ycf1nq+fcOhzhwud7b46hu6mp2drd3M+mL6F9/r8Xi0BiybzYbNZtN6RaCrN9w3NO6L2zY3N2ut8zqdjsjISIYMGUJlZSV9+/YlMTGR+Ph4dDodycnJXxqzznYciqLQ3NzMkiVLCAsL01rSoWvuZJ8+fTCbzcTFxREcHExnZ6cWZy0WCzExMYwcObLH+earx6tXr+bNN98kPj6eWbNmaXOcvliP+/fvT1pamvb/FRUVHD58mDfffFN7LTY2lvT0dOLj44mLi8NgMGhDoHwNPL5jOhedTsd9993HqFGjur0WFBREWVkZCQkJJCQkYDQaueSSS1i/fv1ZP+/Lrrk+Xq+XmpoaIiMj0ev17Nu3T7uv8DVsfPEafuTIET766COCg4NpaGggNjb2S79DfPdIonER0+l02kn5xa5DRVEYP348Q4cOpaamhr179/Luu+9qY019geTEiROMGDECgNraWu0mwncxhK6eBp1Ox4MPPojNZuO1117TvtftdlNfX0+vXr1ob2/n1KlTDB06lKamJvR6vXax0ul0qKrKsWPHSE1NxWAwYLPZqKys1G7MTp8+rXW7+rb1HZtvNZKoqCh+/OMfYzab+ctf/tLteM/kaxk7G4PBwPTp05k0aRLV1dV8+umnLFu2jLS0tLMO2/liuZ65X77/Dg8PZ/bs2bz66qvs37+fnJwcgoKC+NGPfkS/fv1QFIWmpiZtHkx7ezt2u53AwECqq6vPuRqO70IfFBSkzU8ICAigqamJpqambmOafUOKpk+fzqBBg9DpdDQ3NxMUFISiKBQWFnL69GmsViufffYZU6ZMISAggPr6ejweD16vV/sNTCYTEydOZNy4cRiNRm34zrkm8EPXzeratWu57LLLGDt2LC6Xi0cffVT7u68+nVm3TCYTdXV1WiJZWlp61smyvpY/h8OB0WikqalJ2xedTtftsxVFobS0lLKyMu677z569erFmjVrqKys7PEb+v7barXS0dFBXV0doaGhtLS0aK32vvk106dPx2w243Q6sdvthIaGYrPZeOCBB6irq6OsrIwVK1aQmZnJ8OHDsdvtbN68mVtuuYV+/fpRUVGh1VnfMBOv10tTU5N2U+L7vfV6PQEBAZSWljJy5Ej0er22/75hD2fW+bMNHdi9ezdBQUHceeedWCwWFi9e3K1enZkw+OYhNTY2asmF3W7HYrHw8ccfc/PNN5OTk0NNTQ1PPfXUOetAYmIioaGhfPjhh0RHRxMZGXnW9zU0NNDZ2YnRaKS0tBSTyURFRQWVlZXab7Z69WptWOfEiRMZMWIE1dXV7Nmzh3fffZe7776b6Ohopk6dSlxcnFZ/+/TpQ0lJCY2NjTgcDkwmE+Xl5d1WpvH17lZWVpKWlqYtyBAQEIDBYOh2bp/tBkqv19PW1qZNqD916hTNzc14PB42btxI//79ueqqqzAYDPzpT3/qVu4ej4dt27aRmJjIjBkzMJlMPPfcc+csU1VV2bNnD4WFhcyYMYP29nZtaKSiKLS1tdHW1obVaqW6uhpFUdDr9Vx55ZWMHz+e6upqPvvsM9577z3uvvtu4NwJr16vp2/fvlx//fXYbDZcLhfNzc3aHIwv7teZn6MoCoGBgdTX13eL6cHBwT1isU6nIyAgQBs65vvtfAn5kCFD6N+/PytXrmTQoEHd6pHVaqWtrY2GhgbCwsK0m3Bfr8VXnRdfdgzQlch8+umnzJ49m8zMTI4fP84bb7zR7Th9//b9o9PpqK2txePx4HA4KC8vP+sQogkTJjB8+PBu9dg3/PZs9diXgOp0OiIiIrjmmmtISUlBVVVOnz5NUlISDoeDlpYWnE4nOp2OpqYmrX6f7fjOxmazaZPDzywbg8FAc3MzHR0d6PV6Kioqztkj+1Xf4zvHDh06xOzZszl06BAej4dFixYRGBjIkiVLuv12Xq+X48eP09DQwAMPPEB4eDjvv//+N1oEQVxYkmh8T7W2tvLEE08QFRVFeHg49fX1BAcHazdnBoOBcePG8dRTT2kX802bNp11QpjVauXEiRN89NFHNDU1sX37di6//HJUVaWzs5NXX32VPn36cOrUKW1i3ZlDW3xcLheVlZUMHToUgAEDBvDRRx/xwgsvoNPpKCws5Gc/+9k5j8lqtVJQUMDatWuprq5m37599O3bt8dFLCAggLy8PLZv3864ceN63CRUVVXx1FNP0bdvX6xWqzbB94vjyL8Ok8lEamoqkyZN4v3336dfv36MGDGC999/X5ujcfDgQa677jqys7OJj4/nmWeeIS0tjbKysrMmGhaLhcbGRlatWsXo0aNZtmwZTz75JLGxsRQUFBAREdFtcp5vpbIlS5bQ2dmJyWQiLy+PKVOm4HA4eOONN7jssstISUlh8eLFDBw4kCFDhmgrfDidTiorK3nooYcYNWoUTz/9NHq9nqCgIIqKikhJSek2Tv306dPs2bOHcePGYbVa0el0mEwmdu7cyenTpykoKNDqxNno9XrGjh2rDZ0wmUwcPnz4rBfo6Oho9Ho9zz//PJGRkRw4cICbbrrpnENNfAnMhg0bUFWVLVu2kJmZec6LYXh4OGlpaTz//PP079+fwsJCbb5DdnY2H3zwAVu2bKFXr17U1tbS0dHByJEjWbVqFUePHiU9PZ2Ojg5tPgB0nWMej4etW7dSWFjInj17aGpqwuPxkJKSwpIlS3A4HFRUVGg3ZgEBARw4cIBdu3YxatQonnzySerr67FYLOzYsYPLL78ci8VyjlrYndVqpaioiI8++oi6ujp27typtXq63W7ef/99Ro4cqf0WAwYM4K233iI/P5/q6mptTgjAp59+SklJCfv37+f06dPnXGHNYrEwYMAA/vrXv/Lzn//8nDd6+/fv569//SsGg4GdO3cyb948goKCtLHeXq+XrVu30q9fP5qamnj88ceJi4sjNDSUhoYGQkJCiIqKok+fPmzevFkbynP06FHuvfdecnJy+OCDD3jyyScJCwujsLCwR2KVm5vL66+/TkFBAU6nk927d3PXXXed1zDK+Ph4YmJiePrpp+nduzelpaXY7XYtaf3ss8+0xLmwsBCHw4HZbKaxsZGVK1diNBo5cuQIa9eu1Xohc3JysNvtbN++nbFjx3abwG4wGFi/fj319fW0tLTQ0tJCbGwsOp0Oq9XKiy++SHR0NAcOHGDYsGHa/Lv09HQCAgJobm4mKioKk8mEyWRi5cqVzJo1q1v8gK65Dmazmc2bNxMXF0dTUxO1tbUMGzbsrPVrw4YNJCQkaL3fOTk5PPnkk1pCXVRUxKJFi3psq9PpyM3N5aWXXqKhoQGn00lVVRUPPfSQVoajRo1i+/btrF+/nh//+MdaXQoJCSEtLY3nnnuOAQMG0NjYyPHjx7nhhhu+9kpPAQEBbNy4keTkZPr27YuiKBiNRlwuF1u2bOHw4cPs3LmTjo6Oc65YZjabGTduHK+++irHjx+nra2NvLw8xo0b1+19drudxx9/nNjYWMLCwrR63KtXL/r27dutHh85cqTb3BabzcbAgQPZvHkzAwYM0BZiWbBgAYmJibhcLp577jlCQ0M5ePAgt912GxkZGSiKwvLly7npppsIDQ09a4+Db+n3oqKibq9nZ2eTlZWFoig88cQTxMTEUFJS0qOHSK/Xo9frWbFiBTfffDPh4eHa95w4cYI33nhDizl5eXkkJyeTlZXFvn37KC0tZd26dbS0tLBt2zYmT56sJfnLly9n0KBBnDp1ig0bNuB0Otm6dSu5ublnXc0yLy8PgIEDB17wVTdFdzKD5iIQEhKiBQ2fXr16dRva1KdPH8LDw7Uu/9DQUO688070ej2lpaX07t2be+65R7tJ8Q1tuvPOO2lvb6ejo4PLLrtM60no06dPt9al66+/nsrKSoKDg5k3bx5RUVHaJMbp06fT2NhIVFQUDz30EOHh4URHR5OamqrtX9++fQkMDCQlJYXIyEgURaF3797cddddtLW10dLSwvz580lOTiYsLIw+ffpo26amphIdHc348eOZPHky5eXlxMXFMXv2bEJCQrDZbGRlZWkXotzcXLKysno8jyAuLo6kpCSSk5OZP38+drudiooKhg8fzuzZs7vNYTEajfTr1w+LxaJ1xdtsNm04l+/zEhIStFVPjEYj48ePJzU1lbKyMi699FJ++tOfUltbS01NDTNmzOCSSy7BbDYzf/58LYhOnjyZCRMmEBwc3O13T0pK4pJLLqG6uprw8HB+9rOfERwcTGlpKYMHD+bee+/tdtOpKApjxoxh7ty5NDY2UllZyfTp05kyZQolJSVkZGQwadIksrKyGD9+PCUlJeTk5HD77bfT2NiIy+Vi4cKF9OrVi8zMTO655x5cLhelpaUMHz6cm266Cb1er9U138pZvkTCaDQya9YskpKSqKysZNSoUdxwww3odDqio6NJSUnRftOMjAxCQkJITk7m/vvvB7pasG666SZtSMSZQkNDuf/++wkKCuLUqVNcd911jBo1CrPZrK2OBF1D21JTU0lOTtbKwe12M3/+fC0p7devn9YT5KtrvsUShg8fTnl5OVlZWdoE0tjYWB544AGCg4M5efIkMTExLFy4kJCQEG644QZtcqPT6eS+++4jIyMD6LoRW7BggbZKzdVXX83kyZNxu92MGTOGKVOm0NzczLXXXsu4ceMwm80MGzaMjIwMqqurGTBgAPfee6/2XJibb76Z6dOno9PpyMjI0M5PX3zwlVlycjKxsbGMGjWKadOmUV5eTmRkJLfffjvh4eGEhYUxbdo0GhoatETKaDQybdo0pk2bRkVFBVFRUcyfP5+QkBDmzZtHYGAgNTU1XHHFFVx++eV4PB4SExOJi4sjMDBQGzLoix2xsbHasI8vSkxM5MYbb9SShjvvvJPRo0eTkpKi1UWPx8P8+fNJT0/XemWga8nn9PR07rrrLgIDA5kzZw5jx47VlpZdsGAB6enpREZGcv/99xMcHIzdbudHP/oRQ4cO7dYjN23aNG666SYqKytpa2vjnnvuITc3F6vVSnZ2tpZwxMTEkJyc3C3+WiwW7rjjDgYMGEB1dTWXXXYZ48ePJyQkhKuvvprc3FxtNcBZs2ZhsVhISkpi/Pjx1NTUcMkllzB+/HjKyspITEzktttuIzAwEJfLRU1NTY9Ern///tx6663U19djNpu1OQjBwcHMmTMHk8lEZGQkP/nJT0hNTSUhIYEFCxbQ1tZGRUUFQ4YM4fbbb9f2r7Ozs9s8m/j4eOLj44mIiOD+++8nNjaWkydPYrPZuPvuuwkLC9NW5goKCtIWo7DZbNqyuL7f/s4778Rut2O327njjjtISEggIiKCPn36YDAYyMrKwmazkZOTw5w5c7rFnsjISKKiokhJSSEwMJAbb7yR1tbWbs/JMRqNzJkzhzFjxmi9YQ8++KB27fAlDIqikJKS0iOZCg4OJjMzE71ez+TJkwkNDe22NGtAQAB33HEHer2euro6brjhBsaPH4/L5SI1NVX7vDNjz8iRI5k7d642lHXmzJk95sCEhoaycOFCrcf1zHo8e/ZsrR63t7dr9di3rwaDgRtvvJErrriC8vJympubmTNnDgMGDCAiIoL77rtPizMzZswgNzeX4OBgrrrqKlpaWs45NE+n05GWlobH49FWnDtx4oS22ldwcDD33HMP8fHxNDY2cs011zBq1ChtiFhycjJBQUFcffXVtLa2dhvOHBISQmJiIuXl5Zw4cYK6ujquv/56Fi5ciNFoZNCgQcyYMYOqqipsNhvz588nJiYGm83G1Vdfjd1uJzY2lltvvVVrDPUtQnO2ho6mpiaam5u/1WcQiW9GUeVX+UFSVZWtW7dSXl7O+PHj8Xg8vPnmm2RnZ3PDDTecV4tAXV0dv//97/nFL37RI5iL7z+Xy8Xy5cu55pprzruV/bvK6XTyyiuvMHjwYFJTUyksLGT58uU8+OCD5zXBUaDNVdqwYQNtbW3cdtttXzrUTgghxPefDJ36AUtKSuJf//oXS5YswWQyaa1sX8f5TAAT308ul4sRI0b0WCrxYmQwGIiJieGpp56iubmZuLg4ZsyYIRMPvwav18vTTz9NdXU1/9//9/99o4cACiGE+H6RHo0fMFVVsdvt2io2ISEhX6tl2uPx0NTUpK1GI8TFyjdJ1zf/wGw2ExISIvX6a/Ct0KWqqvZgSiGEED9skmgIIYQQQggh/E4mgwshhBBCCCH8ThINIYQQQgghhN9JoiGEEEIIIYTwO0k0hBBCCCGEEH4niYYQQgghhBDC7yTREEIIIYQQQvidJBpCCCGEEEIIv5NEQwghhBBCCOF3kmgIIYQQQggh/E4SDSGEEEIIIYTfSaIhhBBCCCGE8DtJNIQQQgghhBB+J4mGEEIIIYQQwu8k0RBCCCGEEEL4nSQaQgghhBBCCL+TREMIIYQQQgjhd5JoCCGEEEIIIfxOEg0hhBBCCCGE30miIYQQQgghhPA7STSEEEIIIYQQfieJhhBCCCGEEMLvJNEQQgghhBBC+J0kGkIIIYQQQgi/k0RDCCGEEEII4XeSaAghhBBCCCH8ThINIYQQQgghhN9JoiGEEEIIIYTwO0k0hBBCCCGEEH4niYYQQgghhBDC7yTREEIIIYQQQvidJBpCCCGEEEIIv5NEQwghhBBCCOF3kmgIIYQQQggh/E4SDSGEEEIIIYTfSaIhhBBCCCGE8DtJNIQQQgghhBB+J4mGEEIIIYQQwu8k0RBCCCGEEEL4nSQaQgghhBBCCL/7/wGFb88aRgFi1QAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- SPECTRA FINAL ANALYSIS ---\n", + "This is a Horizontal Bar Chart titled 'Increasing in efficiency Drivers with Horizontal Bar and the y-axis shows Sectors (current US$).\n", + "----------------------------------\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import os\n", + "from google.colab import files, drive\n", + "\n", + "# --- 0. DRIVE MOUNT ---\n", + "if not os.path.exists('/content/drive'):\n", + " drive.mount('/content/drive')\n", + "\n", + "# --- 1. PATHS ---\n", + "master_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_VBAR_Final\")\n", + "checkpoint_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750\")\n", + "\n", + "# --- 2. LOAD PROCESSOR & MODEL ---\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "print(\"⏳ Loading Models...\")\n", + "processor = DonutProcessor.from_pretrained(master_path, local_files_only=True)\n", + "model = VisionEncoderDecoderModel.from_pretrained(checkpoint_path, local_files_only=True).to(device)\n", + "\n", + "print(f\"✅ STEM Sight Horizontal Expert ready on {device.upper()}\")\n", + "\n", + "# --- 3. CLEANING & INFERENCE FUNCTION ---\n", + "def run_hbar_prediction(image_path):\n", + " # Load and Display\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + " plt.figure(figsize=(10, 6))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " # Prepare inputs\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=150, # Chhota limit taaki loop na kare\n", + " early_stopping=True,\n", + " no_repeat_ngram_size=3, # Repetition control\n", + " repetition_penalty=1.5, # Loop breaker\n", + " num_beams=2, # Better quality\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + "\n", + " # --- DYNAMITE CLEANING LOGIC ---\n", + " # Sirf \"gt_parse\" ke andar wali string nikalne ke liye\n", + " match = re.search(r'\"gt_parse\":\\s*\"(.*?)\"', sequence)\n", + "\n", + " if match:\n", + " clean_summary = match.group(1)\n", + " else:\n", + " # Fallback agar regex fail ho\n", + " clean_summary = re.sub(r'<.*?>', '', sequence).strip()\n", + " clean_summary = clean_summary.replace('{\"gt_parse\": \"', '').replace('\"}', '')\n", + "\n", + " # Final \"Human-Friendly\" touch\n", + " clean_summary = clean_summary.replace(\"hbar categorical\", \"Horizontal Bar Chart\")\n", + "\n", + " print(\"\\n📊 --- SPECTRA FINAL ANALYSIS ---\")\n", + " print(clean_summary)\n", + " print(\"----------------------------------\\n\")\n", + "\n", + "# --- 4. INTERACTIVE UPLOAD ---\n", + "print(\"📤 Upload your chart to get the summary:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 786, + "referenced_widgets": [ + "4963637ee5d141d79786f021c98279c7", + "23c7633921424902bd473e6d92decd3c", + "4200dd76953a4148947f095e5f892166", + "b7adb5ae5d63439aaf4d90a0d477cf72", + "79fca325c5bc47c0acd0a051e26fc6c0", + "3f89926108e54e34ae212b28d1255e6e", + "8137ea19a2a3440ea59d8d53ba855938", + "e44fb2ebb8064fbf88b995a903dddab0", + "48fee540d7724bccbb5a6212c3d2fd97", + "949f291dcf494509928fa444f0433dd1", + "2aab06a4499f425dbc6c177d8c329de4" + ] + }, + "id": "Fu7gjAQcvkRk", + "outputId": "b7a77394-6b0d-4599-cedf-2f216cc81c77" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Models...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 5703.png to 5703.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- SPECTRA FINAL ANALYSIS ---\n", + "This is a Horizontal Bar Chart titled 'Percentage share of income held by third 20% of the population'. The x-axis shows Income share held (as % of total income) and the y-axim shows Years.\n", + "----------------------------------\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "import os\n", + "from google.colab import files, drive\n", + "\n", + "# --- 0. DRIVE MOUNT ---\n", + "if not os.path.exists('/content/drive'):\n", + " drive.mount('/content/drive')\n", + "\n", + "# --- 1. PATHS ---\n", + "master_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_VBAR_Final\")\n", + "checkpoint_path = os.path.abspath(\"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750\")\n", + "\n", + "# --- 2. LOAD PROCESSOR & MODEL ---\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "print(\"⏳ Loading Models...\")\n", + "processor = DonutProcessor.from_pretrained(master_path, local_files_only=True)\n", + "model = VisionEncoderDecoderModel.from_pretrained(checkpoint_path, local_files_only=True).to(device)\n", + "\n", + "print(f\"✅ STEM Sight Horizontal Expert ready on {device.upper()}\")\n", + "\n", + "# --- 3. CLEANING & INFERENCE FUNCTION ---\n", + "def run_hbar_prediction(image_path):\n", + " # Load and Display\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + " plt.figure(figsize=(10, 6))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " # Prepare inputs\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " print(\"🚀 Model generating summary...\")\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=150, # Chhota limit taaki loop na kare\n", + " early_stopping=True,\n", + " no_repeat_ngram_size=3, # Repetition control\n", + " repetition_penalty=1.5, # Loop breaker\n", + " num_beams=2, # Better quality\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " # Decode\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + "\n", + " # --- DYNAMITE CLEANING LOGIC ---\n", + " # Sirf \"gt_parse\" ke andar wali string nikalne ke liye\n", + " match = re.search(r'\"gt_parse\":\\s*\"(.*?)\"', sequence)\n", + "\n", + " if match:\n", + " clean_summary = match.group(1)\n", + " else:\n", + " # Fallback agar regex fail ho\n", + " clean_summary = re.sub(r'<.*?>', '', sequence).strip()\n", + " clean_summary = clean_summary.replace('{\"gt_parse\": \"', '').replace('\"}', '')\n", + "\n", + " # Final \"Human-Friendly\" touch\n", + " clean_summary = clean_summary.replace(\"hbar categorical\", \"Horizontal Bar Chart\")\n", + "\n", + " print(\"\\n📊 --- SPECTRA FINAL ANALYSIS ---\")\n", + " print(clean_summary)\n", + " print(\"----------------------------------\\n\")\n", + "\n", + "# --- 4. INTERACTIVE UPLOAD ---\n", + "print(\"📤 Upload your chart to get the summary:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 786, + "referenced_widgets": [ + "96ad0057a100453682822141bdf69c84", + "99afdcad72724baaaaba1d709614a381", + "f54b6083632a4a11bba7c0924a238076", + "915d900c008d433baa04110d0c7b6705", + "3ee3757bbca641dca1165aca94fe42e9", + "3de9c87f6bf24268953a400ebb02588d", + "99fc6847bff5467db0ab190d14e6c811", + "0ff6994c42fb4797818bb4645c51e015", + "82f62e8938c14892bfe94980835567a2", + "9238a1d71cf4404383bc07082e0611df", + "4445e206e7eb4131b1d0f577598b3734" + ] + }, + "id": "JmbZmgQtvv64", + "outputId": "535b6af5-de96-412c-8a5f-6ae3f032acbe" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Models...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 6430.png to 6430.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Model generating summary...\n", + "\n", + "📊 --- SPECTRA FINAL ANALYSIS ---\n", + "This is a Horizontal Bar Chart titled 'Rural vs urban population of Albania'. The x-axis shows Population (% of total) and the y-axhi>{% of newborns.\n", + "----------------------------------\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "pip install torch transformers Pillow sentencepiece" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TZDiNV3nE6Kl", + "outputId": "dc5a7bdf-e2cc-428d-e0f0-ed185136a2d0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: torch in /usr/local/lib/python3.12/dist-packages (2.10.0+cu128)\n", + "Requirement already satisfied: transformers in /usr/local/lib/python3.12/dist-packages (5.0.0)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.12/dist-packages (11.3.0)\n", + "Requirement already satisfied: sentencepiece in /usr/local/lib/python3.12/dist-packages (0.2.1)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from torch) (3.25.1)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch) (4.15.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch) (75.2.0)\n", + "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch) (1.14.0)\n", + "Requirement already satisfied: networkx>=2.5.1 in /usr/local/lib/python3.12/dist-packages (from torch) (3.6.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch) (3.1.6)\n", + "Requirement already satisfied: fsspec>=0.8.5 in /usr/local/lib/python3.12/dist-packages (from torch) (2025.3.0)\n", + "Requirement already satisfied: cuda-bindings==12.9.4 in /usr/local/lib/python3.12/dist-packages (from torch) (12.9.4)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch) (12.8.93)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch) (12.8.90)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch) (12.8.90)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch) (9.10.2.21)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.8.4.1 in /usr/local/lib/python3.12/dist-packages (from torch) (12.8.4.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.3.3.83 in /usr/local/lib/python3.12/dist-packages (from torch) (11.3.3.83)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.9.90 in /usr/local/lib/python3.12/dist-packages (from torch) (10.3.9.90)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.7.3.90 in /usr/local/lib/python3.12/dist-packages (from torch) (11.7.3.90)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.5.8.93 in /usr/local/lib/python3.12/dist-packages (from torch) (12.5.8.93)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch) (0.7.1)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.27.5 in /usr/local/lib/python3.12/dist-packages (from torch) (2.27.5)\n", + "Requirement already satisfied: nvidia-nvshmem-cu12==3.4.5 in /usr/local/lib/python3.12/dist-packages (from torch) (3.4.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch) (12.8.90)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch) (12.8.93)\n", + "Requirement already satisfied: nvidia-cufile-cu12==1.13.1.3 in /usr/local/lib/python3.12/dist-packages (from torch) (1.13.1.3)\n", + "Requirement already satisfied: triton==3.6.0 in /usr/local/lib/python3.12/dist-packages (from torch) (3.6.0)\n", + "Requirement already satisfied: cuda-pathfinder~=1.1 in /usr/local/lib/python3.12/dist-packages (from cuda-bindings==12.9.4->torch) (1.4.1)\n", + "Requirement already satisfied: huggingface-hub<2.0,>=1.3.0 in /usr/local/lib/python3.12/dist-packages (from transformers) (1.6.0)\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.12/dist-packages (from transformers) (2.0.2)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from transformers) (26.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.12/dist-packages (from transformers) (6.0.3)\n", + "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.12/dist-packages (from transformers) (2025.11.3)\n", + "Requirement already satisfied: tokenizers<=0.23.0,>=0.22.0 in /usr/local/lib/python3.12/dist-packages (from transformers) (0.22.2)\n", + "Requirement already satisfied: typer-slim in /usr/local/lib/python3.12/dist-packages (from transformers) (0.24.0)\n", + "Requirement already satisfied: safetensors>=0.4.3 in /usr/local/lib/python3.12/dist-packages (from transformers) (0.7.0)\n", + "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.12/dist-packages (from transformers) (4.67.3)\n", + "Requirement already satisfied: hf-xet<2.0.0,>=1.3.2 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (1.3.2)\n", + "Requirement already satisfied: httpx<1,>=0.23.0 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (0.28.1)\n", + "Requirement already satisfied: typer in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (0.24.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch) (3.0.3)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (4.12.1)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (2026.2.25)\n", + "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (1.0.9)\n", + "Requirement already satisfied: idna in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (3.11)\n", + "Requirement already satisfied: h11>=0.16 in /usr/local/lib/python3.12/dist-packages (from httpcore==1.*->httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (0.16.0)\n", + "Requirement already satisfied: click>=8.2.1 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (8.3.1)\n", + "Requirement already satisfied: shellingham>=1.3.0 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (1.5.4)\n", + "Requirement already satisfied: rich>=12.3.0 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (13.9.4)\n", + "Requirement already satisfied: annotated-doc>=0.0.2 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (0.0.4)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.12/dist-packages (from rich>=12.3.0->typer->huggingface-hub<2.0,>=1.3.0->transformers) (4.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.12/dist-packages (from rich>=12.3.0->typer->huggingface-hub<2.0,>=1.3.0->transformers) (2.19.2)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.12/dist-packages (from markdown-it-py>=2.2.0->rich>=12.3.0->typer->huggingface-hub<2.0,>=1.3.0->transformers) (0.1.2)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lpaO9ssRFiFv", + "outputId": "b1325eac-dd5c-4131-fd49-e0c508b7162e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "from google.colab import files\n", + "\n", + "# 1. Paths define karo\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "checkpoint_path = \"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750\"\n", + "\n", + "# 2. Check karo ki folders exist karte hain ya nahi\n", + "if not os.path.exists(master_path) or not os.path.exists(checkpoint_path):\n", + " print(\"❌ Error: Drive folders nahi mile! Check karo ki Drive mounted hai ya paths sahi hain.\")\n", + "else:\n", + " # 3. Zip the Processor (Master)\n", + " print(\"📦 Zipping Processor (VBAR Final)...\")\n", + " !zip -r /content/processor_hbar.zip \"{master_path}\"\n", + "\n", + " # 4. Zip the Model Weights (HBAR Expert)\n", + " print(\"📦 Zipping Model Weights (HBAR Expert)...\")\n", + " !zip -r /content/model_hbar.zip \"{checkpoint_path}\"\n", + "\n", + " # 5. Download to your Mac\n", + " print(\"📥 Downloading to Mac... (Files thodi badi hain, wait karna)\")\n", + " if os.path.exists(\"/content/processor_hbar.zip\"):\n", + " files.download(\"/content/processor_hbar.zip\")\n", + "\n", + " if os.path.exists(\"/content/model_hbar.zip\"):\n", + " files.download(\"/content/model_hbar.zip\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 427 + }, + "id": "7fEffM4wFReW", + "outputId": "e5f292d3-1345-41ab-8067-49c18b656348" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📦 Zipping Processor (VBAR Final)...\n", + " adding: content/drive/MyDrive/STEM_Sight_VBAR_Final/ (stored 0%)\n", + " adding: content/drive/MyDrive/STEM_Sight_VBAR_Final/model.safetensors (deflated 7%)\n", + " adding: content/drive/MyDrive/STEM_Sight_VBAR_Final/training_args.bin (deflated 53%)\n", + " adding: content/drive/MyDrive/STEM_Sight_VBAR_Final/tokenizer_config.json (deflated 48%)\n", + " adding: content/drive/MyDrive/STEM_Sight_VBAR_Final/tokenizer.json (deflated 74%)\n", + " adding: content/drive/MyDrive/STEM_Sight_VBAR_Final/processor_config.json (deflated 55%)\n", + " adding: content/drive/MyDrive/STEM_Sight_VBAR_Final/config.json (deflated 74%)\n", + " adding: content/drive/MyDrive/STEM_Sight_VBAR_Final/generation_config.json (deflated 58%)\n", + "📦 Zipping Model Weights (HBAR Expert)...\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/ (stored 0%)\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/config.json (deflated 74%)\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/generation_config.json (deflated 58%)\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/model.safetensors (deflated 7%)\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/training_args.bin (deflated 53%)\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/optimizer.pt (deflated 34%)\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/scheduler.pt (deflated 61%)\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/scaler.pt (deflated 64%)\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/rng_state.pth (deflated 26%)\n", + " adding: content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/trainer_state.json (deflated 81%)\n", + "📥 Downloading to Mac... (Files thodi badi hain, wait karna)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " async function download(id, filename, size) {\n", + " if (!google.colab.kernel.accessAllowed) {\n", + " return;\n", + " }\n", + " const div = document.createElement('div');\n", + " const label = document.createElement('label');\n", + " label.textContent = `Downloading \"${filename}\": `;\n", + " div.appendChild(label);\n", + " const progress = document.createElement('progress');\n", + " progress.max = size;\n", + " div.appendChild(progress);\n", + " document.body.appendChild(div);\n", + "\n", + " const buffers = [];\n", + " let downloaded = 0;\n", + "\n", + " const channel = await google.colab.kernel.comms.open(id);\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + "\n", + " for await (const message of channel.messages) {\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + " if (message.buffers) {\n", + " for (const buffer of message.buffers) {\n", + " buffers.push(buffer);\n", + " downloaded += buffer.byteLength;\n", + " progress.value = downloaded;\n", + " }\n", + " }\n", + " }\n", + " const blob = new Blob(buffers, {type: 'application/binary'});\n", + " const a = document.createElement('a');\n", + " a.href = window.URL.createObjectURL(blob);\n", + " a.download = filename;\n", + " div.appendChild(a);\n", + " a.click();\n", + " div.remove();\n", + " }\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "download(\"download_8cc2a274-9cab-40ac-805f-35862c4e74a1\", \"processor_hbar.zip\", 968504504)" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " async function download(id, filename, size) {\n", + " if (!google.colab.kernel.accessAllowed) {\n", + " return;\n", + " }\n", + " const div = document.createElement('div');\n", + " const label = document.createElement('label');\n", + " label.textContent = `Downloading \"${filename}\": `;\n", + " div.appendChild(label);\n", + " const progress = document.createElement('progress');\n", + " progress.max = size;\n", + " div.appendChild(progress);\n", + " document.body.appendChild(div);\n", + "\n", + " const buffers = [];\n", + " let downloaded = 0;\n", + "\n", + " const channel = await google.colab.kernel.comms.open(id);\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + "\n", + " for await (const message of channel.messages) {\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + " if (message.buffers) {\n", + " for (const buffer of message.buffers) {\n", + " buffers.push(buffer);\n", + " downloaded += buffer.byteLength;\n", + " progress.value = downloaded;\n", + " }\n", + " }\n", + " }\n", + " const blob = new Blob(buffers, {type: 'application/binary'});\n", + " const a = document.createElement('a');\n", + " a.href = window.URL.createObjectURL(blob);\n", + " a.download = filename;\n", + " div.appendChild(a);\n", + " a.click();\n", + " div.remove();\n", + " }\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "download(\"download_83fca751-8bf2-4da9-b0e5-a59c4b295968\", \"model_hbar.zip\", 2345433899)" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import os\n", + "import glob\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import re\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "\n", + "# --- 1. SETUP & PATHS ---\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "hbar_weights_path = \"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2\"\n", + "\n", + "# --- 2. ROBUST WEIGHT FINDER ---\n", + "# Search for the latest checkpoint or specific model file\n", + "possible_files = glob.glob(os.path.join(hbar_weights_path, \"**\", \"pytorch_model.bin\"), recursive=True)\n", + "if not possible_files:\n", + " possible_files = glob.glob(os.path.join(hbar_weights_path, \"**\", \"model.safetensors\"), recursive=True)\n", + "\n", + "if not possible_files:\n", + " raise FileNotFoundError(\"Could not find HBAR weights. Check your Google Drive path!\")\n", + "\n", + "# Use the latest checkpoint based on folder name\n", + "weights_file = sorted(possible_files)[-1]\n", + "print(f\"🧠 Loading HBAR weights from: {weights_file}\")\n", + "\n", + "# --- 3. RECONSTRUCT MODEL ---\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path, tie_word_embeddings=False).to(device)\n", + "\n", + "# Inject the expert weights\n", + "if weights_file.endswith(\".safetensors\"):\n", + " from safetensors.torch import load_file\n", + " state_dict = load_file(weights_file, device=device)\n", + "else:\n", + " state_dict = torch.load(weights_file, map_location=device)\n", + "\n", + "model.load_state_dict(state_dict, strict=False)\n", + "model.eval()\n", + "print(f\"✅ STEM Sight Horizontal Expert ready on {device.upper()}\")\n", + "\n", + "# --- 4. INFERENCE FUNCTION ---\n", + "def run_hbar_prediction(image_path):\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(\n", + " task_prompt, add_special_tokens=False, return_tensors=\"pt\"\n", + " ).input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " no_repeat_ngram_size=3,\n", + " repetition_penalty=2.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " sequence = processor.batch_decode(outputs)[0]\n", + " # Clean special tokens and prompts\n", + " clean_summary = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + " clean_summary = re.sub(r\"<.*?>\", \"\", clean_summary).strip()\n", + "\n", + " print(\"\\n--- ANALYSIS RESULT ---\")\n", + " print(clean_summary)\n", + "\n", + "# --- 5. TEST WITH UPLOAD ---\n", + "print(\"📤 Upload a horizontal bar chart image to test:\")\n", + "uploaded = files.upload()\n", + "\n", + "for filename in uploaded.keys():\n", + " display.display(display.Image(filename, width=450))\n", + " run_hbar_prediction(filename)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 581, + "referenced_widgets": [ + "e350505da87d4f41807d51361db4d314", + "83514ec88cfe479b9368a4521ab1c35f", + "18ca7045b52d41269d14f8cacd8aa12a", + "3c1906095b7845298168b0b40a60c588", + "16f67465c38745b3bc961e5f06305614", + "eb51764548624ebdac2b0ce16fd2f99b", + "5e82952c35a54af0b0f32e9cd922267c", + "4537d5ba0903464796f22a01724f1bd8", + "b037333983774a3aaf057bdaa4823b6f", + "109f5f1be45f4dc096c064a31e93de81", + "acb6826183bd4bea8894854d41cce24b" + ] + }, + "id": "WqtTIJX2j785", + "outputId": "a5199e25-2c6d-401c-ec43-d817fbebdeea" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading HBAR weights from: /content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2/checkpoint-3750/model.safetensors\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 5699.png to 5699.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 450 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "--- ANALYSIS RESULT ---\n", + "{\"gt_parse\": \"This is a hbar categorical titled 'Percentage of female workers employed in Industrial sector'. The x-axis shows Employment (as % of total employers) and the y-axhi>= youth population.\"}{% of femal>==>= according to the y non-familierm.\"}\\chartq>=low to secondary compet>_chertqa= only=lowly=high>=highty=lowti>= when a>= okay=lowtyears.\"k>= how-\"chandise com>=howtqan>=,\"}{x->mount>= yours_marke>=>=/ma>=yohqa>=|chart>s>fchartc>l>ssthan>{{current>sunders>ls{\";chartqart{nnart{chartJan{\",chartgnantcharte>charts_charttqa>—chartqandy->!{*chartqua>_charactes_chans_chams_scartqav_charg_charten_daran>_dan>_cartqap_charat%_charact>_can>_man_non_charity_charance>_cana>_mari_charges_parted_charting_chartan_tran>_accords_phantqaz_charit_charac>_chang_charathgari>L_drawal>I>_marcation>[s_arrival>----------s_caras_trans-\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import os\n", + "import glob\n", + "import json\n", + "import re\n", + "import zipfile\n", + "import io\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "from pathlib import Path\n", + "from nltk.metrics import edit_distance\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "hbar_weights_path = \"/content/drive/MyDrive/STEM_Sight_HBAR_Expert_V2\"\n", + "zip_path = \"/content/drive/MyDrive/PlotQA-Stemsight/horizontal_bars_sample.zip\"\n", + "num_samples = 200\n", + "\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path, tie_word_embeddings=False).to(device)\n", + "\n", + "possible_files = glob.glob(os.path.join(hbar_weights_path, \"**\", \"pytorch_model.bin\"), recursive=True)\n", + "if not possible_files:\n", + " possible_files = glob.glob(os.path.join(hbar_weights_path, \"**\", \"model.safetensors\"), recursive=True)\n", + "\n", + "weights_file = sorted(possible_files)[-1]\n", + "\n", + "if weights_file.endswith(\".safetensors\"):\n", + " from safetensors.torch import load_file\n", + " state_dict = load_file(weights_file, device=device)\n", + "else:\n", + " state_dict = torch.load(weights_file, map_location=device)\n", + "\n", + "model.load_state_dict(state_dict, strict=False)\n", + "model.eval()\n", + "\n", + "scores = []\n", + "bad_words_ids = processor.tokenizer([\"\"], add_special_tokens=False).input_ids\n", + "\n", + "with zipfile.ZipFile(zip_path, 'r') as z:\n", + " with z.open('train/metadata.jsonl') as f:\n", + " content = f.read().decode('utf-8').splitlines()\n", + " eval_lines = [json.loads(line) for line in content[:num_samples]]\n", + "\n", + " for item in tqdm(eval_lines):\n", + " image_path = f\"train/{item['file_name']}\"\n", + " ground_truth = item[\"ground_truth\"]\n", + "\n", + " with z.open(image_path) as img_file:\n", + " image = Image.open(io.BytesIO(img_file.read())).convert(\"RGB\")\n", + "\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=2.5,\n", + " no_repeat_ngram_size=3,\n", + " bad_words_ids=bad_words_ids,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " prediction = processor.batch_decode(outputs)[0]\n", + " prediction = re.sub(r\"<.*?>\", \"\", prediction).replace(task_prompt, \"\").strip()\n", + "\n", + " dist = edit_distance(prediction, ground_truth)\n", + " max_len = max(len(prediction), len(ground_truth), 1)\n", + " accuracy_score = 1 - (dist / max_len)\n", + " scores.append(accuracy_score)\n", + "\n", + "final_accuracy = (sum(scores) / len(scores)) * 100\n", + "print(f\"Accuracy: {final_accuracy:.2f}%\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 123, + "referenced_widgets": [ + "d3c05968a2fa4c39b6d54b9fbbe75c66", + "d72205fa1e4d41c3965c29be45623f10", + "ca2daaefb604423aa4b179ffdb3f4085", + "783fc6a1de1f4b56a73417fe9bbdba1b", + "733dd26363ee47558ac598520f8bbac1", + "a475cf7c3db24d1ab4cbf5ddcfbc8be3", + "bd05259a79e44207a8d36b073d376338", + "f651a370ad334129b81539d6a424516f", + "2349b16b58964c07817ad85812727c58", + "923084864ae44bd592061e3ecd0c4424", + "9ca61d1128134b16a5b3c608a38e7c20" + ] + }, + "id": "QeJhs7g2lthw", + "outputId": "c1d7663f-af5e-4c17-dba4-b5bf626bb3a9" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00= 10000: break\n", + " data = json.loads(line)\n", + " img_name = data['file_name']\n", + "\n", + " # FIX: Look inside the 'train' folder for the image\n", + " src = os.path.join(image_source_dir, img_name)\n", + "\n", + " if os.path.exists(src):\n", + " shutil.copy(src, os.path.join(master_dir, img_name))\n", + " selected_lines.append(data)\n", + " count += 1\n", + "\n", + " # Save the new sampled metadata\n", + " with open(os.path.join(master_dir, \"metadata.jsonl\"), 'w') as f:\n", + " for entry in selected_lines:\n", + " f.write(json.dumps(entry) + \"\\n\")\n", + "\n", + " print(f\"✅ Success! {len(selected_lines)} samples ready in {master_dir}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7JqK7e3CdOxe", + "outputId": "11b9277e-a51b-4c43-9b16-ef3ad14fa5db" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📦 Unzipping Line Train data...\n", + "🔍 Syncing metadata and sampling from the /train subfolder...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + " 39%|███▊ | 10000/25897 [00:03<00:05, 3060.21it/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "✅ Success! 10000 samples ready in /content/line_donut_master\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "import json\n", + "import torch\n", + "from torch.optim import AdamW # The \"Expert\" Optimizer with Weight Decay\n", + "from datasets import load_dataset\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel, TrainingArguments, Trainer\n", + "\n", + "# 1. LOAD DATASET\n", + "dataset = load_dataset(\"imagefolder\", data_dir=\"/content/line_donut_master\")\n", + "\n", + "# 2. LOAD YOUR VBAR MODEL AS THE BASE\n", + "model_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "processor = DonutProcessor.from_pretrained(model_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(model_path).to(\"cuda\")\n", + "model.config.tie_word_embeddings = False\n", + "\n", + "# 3. DATA COLLATOR\n", + "def donut_collator(batch):\n", + " pixel_values = [item[\"image\"].convert(\"RGB\") for item in batch]\n", + " pixel_values = processor(pixel_values, return_tensors=\"pt\").pixel_values\n", + " labels = [json.loads(item[\"ground_truth\"])[\"gt_parse\"] for item in batch]\n", + " labels = processor.tokenizer(labels, padding=\"max_length\", truncation=True,\n", + " max_length=256, return_tensors=\"pt\").input_ids\n", + " labels[labels == processor.tokenizer.pad_token_id] = -100\n", + " return {\"pixel_values\": pixel_values, \"labels\": labels}\n", + "\n", + "# 4. PATHS & TRAINING CONFIG\n", + "LINE_SAVE_PATH = \"/content/drive/MyDrive/STEM_Sight_Line_V1\"\n", + "os.makedirs(LINE_SAVE_PATH, exist_ok=True)\n", + "\n", + "training_args = TrainingArguments(\n", + " output_dir=LINE_SAVE_PATH,\n", + " per_device_train_batch_size=2,\n", + " gradient_accumulation_steps=8, # Effective batch of 16\n", + " num_train_epochs=3,\n", + " learning_rate=2e-5,\n", + " weight_decay=0.01, # <--- Your Weight Decay is right here\n", + " logging_steps=100,\n", + " save_strategy=\"steps\",\n", + " save_steps=500,\n", + " save_total_limit=2,\n", + " fp16=True,\n", + " remove_unused_columns=False,\n", + " report_to=\"none\"\n", + ")\n", + "\n", + "# 5. INITIALIZE TRAINER\n", + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=dataset[\"train\"],\n", + " data_collator=donut_collator,\n", + ")\n", + "\n", + "print(\"🚀 Launching Line Chart Expert Training (Weight Decay enabled)...\")\n", + "trainer.train()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 941, + "referenced_widgets": [ + "07ac1a1dca074c96914b66e81c4b402a", + "2deee5ac13b64993b933d508f0435a79", + "9638a0f340964f5ebe5b387342654145", + "3889541933af4f7e8782231380e1c836", + "1e445ebb7120414fbfe20f4276665c78", + "d9640d3268764914b4343952c5dbb385", + "19babfc7049149bebe3789b9f6d8b5c4", + "89e330512c0c4c258449fa0b73d62a3a", + "3e326832b29546c0a9f9cbac5a246df1", + "233af45cfaa74f7f87f8f8f62c270abb", + "e4b88afd9a5547efbda46ca3ae805ac3", + "83a52971a84f4f798d9f2b0ec6770aa5", + "8b567ddc6a79493a87247c128b2d0976", + "0e7245bfb2154a8792631fc8bfafdc44", + "62d111f940194906947c1901ee150146", + "02afe1967c904897a2f0649f9c54d2d0", + "67747445a4704e4da13c814416b2627d", + "85c6f167c6464e3fa2373c350f0285ea", + "34e2140018d8442485680a8cb3191f95", + "973c875c32dc4a3f85bdc7fb5d8f3b12", + "5f74fe27d5114dd3a9e7decb29ebfa2d", + "1e7f3affeed34b5d8ce8567347d9c98a", + "ab1cace1b6a048e0b02f0f68d58684ce", + "4c95667214ec49a6851476e0bf622b4f", + "46d53f4ea70348fb8f17718c018528ff", + "8325c454a2a64b7382fe999a4eb5d97e", + "fb5f1f3721ae411db558fa0cc543e176", + "1cc2a3af1a704354ad962e48b6561e7f", + "f9aa5d4d3ba8443cb7709f98e50bf9e0", + "595954684c9d4191bfb05013ef9185c8", + "6f4cad9bc3904e58885a6691757027ea", + "ba3ee1b4d3324d2b9fc3673142b241cd", + "3f9cf226573e42e79400d2f3c1c0a74e", + "77b1231d9bbc4fcca6f5bd54f050203e", + "1fdc187ee6294600bd2bc75a3e691fcb", + "c04d0e23f2794a6b8cd84f1aea24a1c6", + "22794cb1018c44fb816d64ee1433d70e", + "1cb1ad61cb294cb7aa6ce84b39a6b31b", + "f5851542984c46079fc1414054deb983", + "21d3abfeb15641a1a6a83f1cd6901c32", + "3c1b31d7090d4a509f5e09e91347e41a", + "682a1d2c14f34f5a8a01292caaa1c036", + "6984073f731d454289edcc0a80ef77ee", + "a0e2aec1aefd4ec5a1703bb642afb98c", + "a545d7879fd0496c925d74229e6eabc1", + "0eda57158efc4d1985d1cf50d57f8e68", + "0d0163eec6744b0eb57b44483ee0d4e3", + "f06475a1f6684c9492f483571da760c6", + "40fd1a254f3f464494cec1fea13229d6", + "262170d5c29e4208b58ae7ca9ada97ef", + "1b7de230f3644007a1e7eee964039f17", + "8cf1adb3d01e4055a59db3f72c44e307", + "774130c44b854f9299fad2e26379cf27", + "4f0e9da385824312ba34e4480b1fd026", + "4da4152c4b27466a89367d58bff24907", + "1b06af84cf92409891e488d028d90f9c", + "6278bd1512e0488fb5ca2b92d1024e43", + "8373e87078894d9888ea721661530a84", + "945d8d72ac3545d684eb3189b4b1249c", + "68d17f4a0e92408a86bf5990bc5f297b", + "0a0b83b84ebd4bb69c772a195627f16f", + "9f161d74ceec4ffbadc183153b2161c5", + "d37dca4ca11749de9b7d4d775b303908", + "560b5bb27e87458ca5ed25e5d984613d", + "071c3f794c684044812dc83b5ead3c29", + "564f005e11f44869903620baa075929e" + ] + }, + "id": "ZMtW41rIeRgy", + "outputId": "59e837e1-0dea-46f0-95a7-723d48b8a307" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Resolving data files: 0%| | 0/10001 [00:00" + ], + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [1875/1875 1:01:28, Epoch 3/3]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
1000.357559
2000.201754
3000.204696
4000.188886
5000.162800
6000.158859
7000.116951
8000.100244
9000.085726
10000.073385
11000.073426
12000.066403
13000.057166
14000.037540
15000.036372
16000.034112
17000.034667
18000.031800

" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Writing model shards: 0%| | 0/1 [00:00\" # Or your specific prompt used in training\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " num_beams=1,\n", + " bad_words_ids=[[processor.tokenizer.unk_token_id]],\n", + " return_dict_in_generate=True,\n", + " )\n", + "\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + " return sequence.replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\")\n", + "\n", + "# 2. TEST IT (Upload any line chart image to Colab and put path here)\n", + "# result = test_line_expert(\"test_chart.png\")\n", + "# print(f\"Expert Summary: {result}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 87, + "referenced_widgets": [ + "af8b8529e784428c94f060c9b74d07c2", + "8672311ba1664e1d954decfc760f9a20", + "d8d6412bba834c39a94593718016d937", + "37547e65b4f0436b93d30dbcd304c792", + "a9da62e8c41949e8a0f35130e2b187d0", + "3ba6789d8e324314b5c42f889cf0e51a", + "f2ccebb3b0064245a1b04c55eecc79c8", + "f6960345fd904c6bafa0d061a79436e6", + "740da76bd12443e59a78947fd885a42a", + "a26141afe8e94b69b13f0546b52273ed", + "807e4a87f8b049c4af2f1fc8837efca4" + ] + }, + "id": "Yw0SnqYJeXF2", + "outputId": "658bfb21-7b61-4a52-f1b9-78313f3c0343" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=2,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # Clean Output\n", + " sequence = processor.batch_decode(outputs)[0]\n", + " # Removing the prompt and special tokens for a clean read\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"=\"*50)\n", + " print(f\"🤖 STEM SIGHT SUMMARY:\\n{clean_output}\")\n", + " print(\"=\"*50 + \"\\n\")\n", + "\n", + "# 3. START\n", + "run_visual_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 553, + "referenced_widgets": [ + "7a53b89a23f14c3cbf6fa53c9d797718", + "4e3aca7239504f2a9533bc9e12da962d", + "e502f0814bdc4046a049d9941f43169a", + "85e1341075164fe2af8a10f1f15f2574", + "f907bae1a71f4bffbcae46b68a5bbfec", + "36efe8408d124b339392567f7469a9d4", + "a4962e43269a41b6b375f6d3538fc510", + "54eb4b6058c44d32b0eabe29623a584f", + "a4c5d1ab24d441388eba40c95c5eff46", + "8600f060a01247df88e1b55618063e6b", + "b557c6d15e854263a2d5214b49cf94f8" + ] + }, + "id": "ZLjlAd4T1zql", + "outputId": "c0d6477c-9771-4505-a374-5e093a1e382c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Line Expert...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 16871.png to 16871 (1).png\n", + "\n", + "📸 Input Image: 16871 (1).png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 400 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "==================================================\n", + "🤖 STEM SIGHT SUMMARY:\n", + "between population in Croatia'. The x-axis shows Year and the y-axis shows Population (% of total).\n", + "==================================================\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "import os\n", + "\n", + "# 1. LOAD MODEL\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model_path = \"/content/drive/MyDrive/STEM_Sight_Line_Final\"\n", + "\n", + "print(\"⏳ Loading Line Expert...\")\n", + "processor = DonutProcessor.from_pretrained(model_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(model_path).to(device)\n", + "model.eval()\n", + "\n", + "# 2. ENHANCED TEST FUNCTION\n", + "def run_visual_test():\n", + " uploaded = files.upload()\n", + "\n", + " for filename in uploaded.keys():\n", + " # Display the image\n", + " print(f\"\\n📸 Input Image: {filename}\")\n", + " display.display(display.Image(filename, width=400))\n", + "\n", + " # Process Image\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " # Generate Summary\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=2,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # Clean Output\n", + " sequence = processor.batch_decode(outputs)[0]\n", + " # Removing the prompt and special tokens for a clean read\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"=\"*50)\n", + " print(f\"🤖 STEM SIGHT SUMMARY:\\n{clean_output}\")\n", + " print(\"=\"*50 + \"\\n\")\n", + "\n", + "# 3. START\n", + "run_visual_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 579, + "referenced_widgets": [ + "cad9a9343a374f418ce0bcabc671ff18", + "bfb9f400e10f4e4295e657070176a11e", + "88f9c550fe5a4eb694cf92f1e244dc30", + "d9857e3ba0ae4e3885e1078b7d591db8", + "fdaeb24138ae416abacb05df815b4799", + "504d2636296141669e6d62dd71b9c186", + "d90188148d8e42cbbf8914be6451ef61", + "39ee4c9040c44d749764559e7e69c5e3", + "e971973447f7456492d7f3221fc82735", + "4c81a2ca8c2c40659fc4704027258d46", + "dfd3bdcf4afb441d9d6f394c8c72df61" + ] + }, + "id": "jXEdwWCx2Sfv", + "outputId": "5f23f1b8-579a-4a85-b1e3-eb4ad6f309a3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Line Expert...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 16887.png to 16887.png\n", + "\n", + "📸 Input Image: 16887.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 400 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "==================================================\n", + "🤖 STEM SIGHT SUMMARY:\n", + ". The x-axis shows Year and the y-axis shows Number of days.\n", + "==================================================\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "import os\n", + "\n", + "# 1. LOAD MODEL\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model_path = \"/content/drive/MyDrive/STEM_Sight_Line_Final\"\n", + "\n", + "print(\"⏳ Loading Line Expert...\")\n", + "processor = DonutProcessor.from_pretrained(model_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(model_path).to(device)\n", + "model.eval()\n", + "\n", + "# 2. ENHANCED TEST FUNCTION\n", + "def run_visual_test():\n", + " uploaded = files.upload()\n", + "\n", + " for filename in uploaded.keys():\n", + " # Display the image\n", + " print(f\"\\n📸 Input Image: {filename}\")\n", + " display.display(display.Image(filename, width=400))\n", + "\n", + " # Process Image\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " # Generate Summary\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=2,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # Clean Output\n", + " sequence = processor.batch_decode(outputs)[0]\n", + " # Removing the prompt and special tokens for a clean read\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"=\"*50)\n", + " print(f\"🤖 STEM SIGHT SUMMARY:\\n{clean_output}\")\n", + " print(\"=\"*50 + \"\\n\")\n", + "\n", + "# 3. START\n", + "run_visual_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 604, + "referenced_widgets": [ + "2e7959f3833a40afa02de27487121540", + "9ecb7a0b5f0844828be4a290edcec8c6", + "c5979cde33fc493eb84de050a3ea8743", + "87cd2cb02f5c43ed892ac647e85bea3d", + "e7cd9a227ebe41d58826930fe5a112b7", + "86229a64cfde4c4fa75650b5ed95242e", + "e592974bee2c41119887dc6398187777", + "7b64689855fc45a083f8e25ed93a9f28", + "dd0c87d9ce68483281b4e09f4094c776", + "bda3b29f969f47e0b9e726271ae58764", + "b3e69ec12a8044cabc566c8d602dbbcd" + ] + }, + "id": "I9QNz8Ga2aY6", + "outputId": "93816083-f3ac-4a25-e4f2-083031420db2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Line Expert...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 16908.png to 16908.png\n", + "\n", + "📸 Input Image: 16908.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 400 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "==================================================\n", + "🤖 STEM SIGHT SUMMARY:\n", + ". The x-axis shows Year and the y-axis shows Average number of days.\n", + "==================================================\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "import os\n", + "\n", + "# 1. LOAD MODEL\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model_path = \"/content/drive/MyDrive/STEM_Sight_Line_Final\"\n", + "\n", + "print(\"⏳ Loading Line Expert...\")\n", + "processor = DonutProcessor.from_pretrained(model_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(model_path).to(device)\n", + "model.eval()\n", + "\n", + "# 2. ENHANCED TEST FUNCTION\n", + "def run_visual_test():\n", + " uploaded = files.upload()\n", + "\n", + " for filename in uploaded.keys():\n", + " # Display the image\n", + " print(f\"\\n📸 Input Image: {filename}\")\n", + " display.display(display.Image(filename, width=400))\n", + "\n", + " # Process Image\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " # Generate Summary\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=2,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # Clean Output\n", + " sequence = processor.batch_decode(outputs)[0]\n", + " # Removing the prompt and special tokens for a clean read\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"=\"*50)\n", + " print(f\"🤖 STEM SIGHT SUMMARY:\\n{clean_output}\")\n", + " print(\"=\"*50 + \"\\n\")\n", + "\n", + "# 3. START\n", + "run_visual_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 616, + "referenced_widgets": [ + "a5e4a23bc8654e51b440bc2f9cc2eea4", + "8a6026c28bc542aaa3d91929f5690c64", + "148d387954424eee9c8e40e392725ff3", + "4514e889b2d64ba48a5aea95a0821774", + "8fdbe7cfcc5a4d6dbb0f812d12b8de12", + "efc3424b714e4829a94a7fe6901a9227", + "4432219754f842fa809948e36954b623", + "1f475ca6c94143c48c49454666b401ac", + "d5e275e88c7d43a4ae13942140c2b604", + "10a8789336ce4c2ab9f83da448f628f3", + "11cb6fa7dc524e59a677b774cf54305f" + ] + }, + "id": "IIS0Tjrx2fw8", + "outputId": "0310fd4f-c484-4f62-adf8-fb6d5d1e0b13" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Line Expert...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving linr_chart1.png to linr_chart1.png\n", + "\n", + "📸 Input Image: linr_chart1.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 400 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "==================================================\n", + "🤖 STEM SIGHT SUMMARY:\n", + "were a line titled 'Wastee emissions (in thousand metric tons of CO2 equivalent).\n", + "==================================================\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Check the first 10 ground truth entries in your sampled data\n", + "with open(\"/content/line_donut_master/metadata.jsonl\", 'r') as f:\n", + " for _ in range(10):\n", + " print(f.readline())" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1WezhAIe3a3w", + "outputId": "2de665a6-691c-43f6-83cb-be3d3a6aa545" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{\"file_name\": \"98293.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Total labor force with tertiary education as their highest grade'. The x-axis shows Years and the y-axis shows Educated labor force (% of total).\\\"}\"}\n", + "\n", + "{\"file_name\": \"86616.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Electricity production from renewable resources'. The x-axis shows Years and the y-axis shows Amount of electricity produced(kWh).\\\"}\"}\n", + "\n", + "{\"file_name\": \"90675.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Global C02 emissions'. The x-axis shows Years and the y-axis shows Emissions(metric tons per capita).\\\"}\"}\n", + "\n", + "{\"file_name\": \"102996.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Plot of CO2 intensity of Ecuador'. The x-axis shows Year and the y-axis shows Intensity (kg per kg of oil equivalent energy use).\\\"}\"}\n", + "\n", + "{\"file_name\": \"86688.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Proportion of the total female labor force of different age groups participating in production in Mozambique'. The x-axis shows Year and the y-axis shows Total Labor Force (in %).\\\"}\"}\n", + "\n", + "{\"file_name\": \"98147.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Total revenue generated by the government from grants'. The x-axis shows Years and the y-axis shows Revenue generated (in %).\\\"}\"}\n", + "\n", + "{\"file_name\": \"98140.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Net disbursements received from International Monetary Fund (non-concessional)'. The x-axis shows Years and the y-axis shows Amount (in current US$).\\\"}\"}\n", + "\n", + "{\"file_name\": \"104106.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Total external debt stocks of Mozambique to exports of goods, services and primary income.'. The x-axis shows Year and the y-axis shows Stocks(% of exports of goods, services and primary income).\\\"}\"}\n", + "\n", + "{\"file_name\": \"99837.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Long-term male unemployment in Cyprus'. The x-axis shows Year and the y-axis shows Unemployment (% of male unemployment).\\\"}\"}\n", + "\n", + "{\"file_name\": \"88498.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Total reserves (including gold) of a country'. The x-axis shows Years and the y-axis shows Total reserves (current US$).\\\"}\"}\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "with open(\"/content/line_donut_master/metadata.jsonl\", 'r') as f:\n", + " samples = [f.readline() for _ in range(20)]\n", + " for s in samples:\n", + " print(s)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RYwlpENc3mUS", + "outputId": "5da89aae-67da-493d-ffe0-3a0847584986" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{\"file_name\": \"98293.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Total labor force with tertiary education as their highest grade'. The x-axis shows Years and the y-axis shows Educated labor force (% of total).\\\"}\"}\n", + "\n", + "{\"file_name\": \"86616.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Electricity production from renewable resources'. The x-axis shows Years and the y-axis shows Amount of electricity produced(kWh).\\\"}\"}\n", + "\n", + "{\"file_name\": \"90675.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Global C02 emissions'. The x-axis shows Years and the y-axis shows Emissions(metric tons per capita).\\\"}\"}\n", + "\n", + "{\"file_name\": \"102996.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Plot of CO2 intensity of Ecuador'. The x-axis shows Year and the y-axis shows Intensity (kg per kg of oil equivalent energy use).\\\"}\"}\n", + "\n", + "{\"file_name\": \"86688.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Proportion of the total female labor force of different age groups participating in production in Mozambique'. The x-axis shows Year and the y-axis shows Total Labor Force (in %).\\\"}\"}\n", + "\n", + "{\"file_name\": \"98147.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Total revenue generated by the government from grants'. The x-axis shows Years and the y-axis shows Revenue generated (in %).\\\"}\"}\n", + "\n", + "{\"file_name\": \"98140.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Net disbursements received from International Monetary Fund (non-concessional)'. The x-axis shows Years and the y-axis shows Amount (in current US$).\\\"}\"}\n", + "\n", + "{\"file_name\": \"104106.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Total external debt stocks of Mozambique to exports of goods, services and primary income.'. The x-axis shows Year and the y-axis shows Stocks(% of exports of goods, services and primary income).\\\"}\"}\n", + "\n", + "{\"file_name\": \"99837.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Long-term male unemployment in Cyprus'. The x-axis shows Year and the y-axis shows Unemployment (% of male unemployment).\\\"}\"}\n", + "\n", + "{\"file_name\": \"88498.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Total reserves (including gold) of a country'. The x-axis shows Years and the y-axis shows Total reserves (current US$).\\\"}\"}\n", + "\n", + "{\"file_name\": \"88623.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Division of total population of South Africa into various age groups\\\\n'. The x-axis shows Year and the y-axis shows Population (in %).\\\"}\"}\n", + "\n", + "{\"file_name\": \"81114.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Proportion of the total labor force ages 15-24 who participated in production in Pakistan'. The x-axis shows Year and the y-axis shows Labor Force (in %).\\\"}\"}\n", + "\n", + "{\"file_name\": \"83463.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Balance of payments recorded for exporting goods and services in Korea (Republic)'. The x-axis shows Year and the y-axis shows Amount exported (in US$).\\\"}\"}\n", + "\n", + "{\"file_name\": \"101799.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Power outages in a typical month in firms of Bangladesh'. The x-axis shows Year and the y-axis shows Number of power outages.\\\"}\"}\n", + "\n", + "{\"file_name\": \"79837.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Percentage of firms either registered or unregistered in Montenegro'. The x-axis shows Year and the y-axis shows % of firms.\\\"}\"}\n", + "\n", + "{\"file_name\": \"82167.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Land Geography of Algeria'. The x-axis shows Year and the y-axis shows Area (% of total land area).\\\"}\"}\n", + "\n", + "{\"file_name\": \"87502.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Cost of communications and computers with respect to commercial service exports'. The x-axis shows Years and the y-axis shows Cost of computers, communications and other services (% of commerical service exports).\\\"}\"}\n", + "\n", + "{\"file_name\": \"88033.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Percentage of total population having access to electricity'. The x-axis shows Years and the y-axis shows Access to electricity (% of population).\\\"}\"}\n", + "\n", + "{\"file_name\": \"94313.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Percentage of the female unemployed labor force with secondary education as their highest grade'. The x-axis shows Years and the y-axis shows Unemployed and educated female labor force (% of population).\\\"}\"}\n", + "\n", + "{\"file_name\": \"98746.png\", \"ground_truth\": \"{\\\"gt_parse\\\": \\\"This is a line titled 'Value added by the service sector to the total GDP of a country'. The x-axis shows Years and the y-axis shows Value added (current US$).\\\"}\"}\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "import os\n", + "\n", + "# 1. LOAD MODEL\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model_path = \"/content/drive/MyDrive/STEM_Sight_Line_Final\"\n", + "\n", + "print(\"⏳ Loading Line Expert...\")\n", + "processor = DonutProcessor.from_pretrained(model_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(model_path).to(device)\n", + "model.eval()\n", + "\n", + "# 2. ENHANCED TEST FUNCTION\n", + "def run_visual_test():\n", + " uploaded = files.upload()\n", + "\n", + " for filename in uploaded.keys():\n", + " # Display the image\n", + " print(f\"\\n📸 Input Image: {filename}\")\n", + " display.display(display.Image(filename, width=400))\n", + "\n", + " # Process Image\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " # Generate Summary\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=2,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # Clean Output\n", + " sequence = processor.batch_decode(outputs)[0]\n", + " # Removing the prompt and special tokens for a clean read\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"=\"*50)\n", + " print(f\"🤖 STEM SIGHT SUMMARY:\\n{clean_output}\")\n", + " print(\"=\"*50 + \"\\n\")\n", + "\n", + "# 3. START\n", + "run_visual_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 531, + "referenced_widgets": [ + "b902f5a19f7c48839c3e9ded91d39bab", + "97072e331c7341c0827a82d0f2a00b7d", + "9c81d1cc39f441ab9b542e770379420b", + "48fbc0b33c1e4b90b0f2d1c5d92bc7a0", + "418eda10b64140e8a5c6cce70c6ccd86", + "c3727ef6921c4d6dbc1aa18486cf530f", + "f543f42f63b54be08fd30ebc29692712", + "0f3df01d925b4fa98ad4281658652056", + "43fcaa6bd3404cfe8f2e22ef8630212f", + "7fc5c8ceb14742418ceb28a3e11e8b81", + "e9527cfee2e14dde8cc876337d4a1817" + ] + }, + "id": "ukYnwpS232H-", + "outputId": "a4283fbb-0418-457a-c300-126533db7bb1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Loading Line Expert...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 16983.png to 16983.png\n", + "\n", + "📸 Input Image: 16983.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 400 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "==================================================\n", + "🤖 STEM SIGHT SUMMARY:\n", + "of population having access to electricity and non-solid fuels in Palau'. The x-axis shows Year and the y-axis shows Access to resources (% of population).\n", + "==================================================\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "import torch\n", + "from torch.optim import AdamW\n", + "from datasets import load_dataset\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel, TrainingArguments, Trainer, get_cosine_schedule_with_warmup\n", + "\n", + "# 1. LOAD DATASET (Keep your 10k sampled master directory)\n", + "dataset = load_dataset(\"imagefolder\", data_dir=\"/content/line_donut_master\")\n", + "\n", + "# 2. LOAD VBAR MASTER (Start fresh from the 'Smart' weights)\n", + "model_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "processor = DonutProcessor.from_pretrained(model_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(model_path).to(\"cuda\")\n", + "model.config.tie_word_embeddings = False\n", + "\n", + "# 3. PATHS\n", + "LINE_SAVE_PATH = \"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed\"\n", + "os.makedirs(LINE_SAVE_PATH, exist_ok=True)\n", + "\n", + "# 4. STABILITY ARGUMENTS\n", + "training_args = TrainingArguments(\n", + " output_dir=LINE_SAVE_PATH,\n", + " per_device_train_batch_size=2,\n", + " gradient_accumulation_steps=8,\n", + " num_train_epochs=1, # Reduced to 1 to prevent template memorization\n", + " learning_rate=5e-6, # LOWER learning rate (Crucial!)\n", + " weight_decay=0.05, # Increased weight decay to keep weights \"simple\"\n", + " logging_steps=50,\n", + " save_strategy=\"steps\",\n", + " save_steps=200,\n", + " save_total_limit=2,\n", + " fp16=True,\n", + " remove_unused_columns=False,\n", + " report_to=\"none\"\n", + ")\n", + "\n", + "# 5. INITIALIZE\n", + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=dataset[\"train\"],\n", + " data_collator=donut_collator, # Use the same collator function from your previous cell\n", + ")\n", + "\n", + "print(\"🚀 Launching Stability Reset Training...\")\n", + "trainer.train()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 753, + "referenced_widgets": [ + "38d84f1d6cb048e0915b114a56e458e6", + "ec86d812b6b54f5da0864320f3d847f5", + "6b261aa654234a1eb3fff0b4bcd492c7", + "ff24056ec4e14e019d5e2213c11b4002", + "ab83f9802a4440758a9e96dc0cd79427", + "8bbc1604e7214a00baf90672f7632bb4", + "16021cce109d464b858bbc8a96682e11", + "ee90a7a108c34df4a8fd379a460fb214", + "26241157f73b43ccbd72c037926bcb93", + "6fb08d1489154aafafabe6661e78f409", + "cddb6a5daf6449908d7aa8ec27c903ac", + "97b8e491316743c697ee9df3f298c612", + "08d29dc136a341649e48073848056039", + "add5e12cb6514d1685ec656408d44d21", + "84b9d84a40144ece8760b65042d7c885", + "fb3172eeeba948c2bb4756b93345df70", + "96b6db5f65984c78a6ed0f04cdbbeb14", + "17a5a0bc61e347418ca294fbcae1cefe", + "abd512d52e2047978af3c94c540ae945", + "8bb081f4523d4a7e8554f33c1c039471", + "3beeeaac752f48d3a9bf31392c6bf8ca", + "a71fb4e70aad4b46920f275fcef1e83f", + "a8d51b2a41cb4feebb51f03676f7a35f", + "471176a66f144532af1902ebe070d07d", + "337fe135ae304febb19da12c28a4bc92", + "c7cebdaf60aa4bd5a7d35397b65f2cd7", + "842e3378e9fb4453bfcc0ee92d0e825f", + "5dc43c0d0c134b4aa24a8433d645873c", + "df91b6f0bdf942c08c1bb0058dd3e3cd", + "302e659f55e841dba4ad38078c7eb791", + "bd0fcb28660d4af2aa97e7579d602eb6", + "07f446b848c548288bb80993433b0067", + "4d8de98f41f24ea79b8aab4004b31338", + "27ac77b21a5d4004adbc30429ff7b0c7", + "ce5b2c347805466aa20a24578192796d", + "78e8580c2b574f2aa4316d89ec5ba559", + "e5a00a22ebe546d2a3be4b8dd9a851ad", + "cd2035064d684d6489a42c7e645026f9", + "3ddbd22fd1f3435cae183b0a01368b08", + "ac1e8920b109468ca6fa153dbac60b73", + "7e1c3eb4aeae4ab2b760d2c484eadaba", + "77c1af0bae6c49368839aa5f8b07b881", + "bf9c6f7bead74dd78f259c48a4bde19f", + "d91b07426c4747f1a6849613eb52a89a", + "1e780f7fca954e7f9d72635f6ca66af2", + "4ff200f0b743426d85fc2235f333b394", + "9e12eeaab31243c8b8e0a1bcae86fed0", + "b3dd08810bc84e78b587727a65ec7308", + "fffdac243ae946eb98bae7ea2110528e", + "780ecff4d8cc4f979acf3189d215421b", + "5dad9d296de945b7bf375e60cb5c064a", + "0bdc373ce7fa46319ac25f4d782875b0", + "da8b563643b243739501440e8e5aa23f", + "1047acd8f6af42279f6e3cd8dd69befb", + "44a0c3de4a3c455d8692b880ce1ac790", + "2e86539cbe364c1791a0bb16c722e63c", + "1c69269b1a9548d4b5712094bee410e6", + "a19e40b4575c4de0ab833b615b63e1e6", + "e9b78fb1bb7344b09f9ddbb0bcf58c2a", + "3c4c3b245c3640c6a2de1b2f37086b9e", + "2c6c42d3ba914429a5948b4a301bdfa5", + "ceac81eac9674eddbad20341c590449c", + "b152fb02d73a47bd9046050974b1217a", + "b504bdea52004c2c838a7c99abfa150b", + "e27e128805fc4cc0b0e640a812d01fd5", + "0d599ca518be417594b39b7c1364e2f6" + ] + }, + "id": "86HsY-Q24ZPY", + "outputId": "52f2933b-de16-48cd-90a7-67d93dcc6114" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Resolving data files: 0%| | 0/10001 [00:00" + ], + "text/html": [ + "\n", + "

\n", + " \n", + " \n", + " [625/625 22:56, Epoch 1/1]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining Loss
500.914242
1000.156341
1500.145633
2000.151423
2500.146092
3000.146518
3500.141292
4000.137587
4500.130373
5000.119992
5500.142149
6000.118442

" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Writing model shards: 0%| | 0/1 [00:00\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=1.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " sequence = processor.batch_decode(outputs.sequences)[0]\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"═\"*50)\n", + " print(f\"🤖 AI SUMMARY: {clean_output}\")\n", + " print(\"═\"*50 + \"\\n\")\n", + "\n", + "# START THE TEST\n", + "if loaded:\n", + " run_stem_sight_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 123, + "referenced_widgets": [ + "9a826d4a724a45a18b31247262f20fd0", + "73ed40e8b6d84ea89bf76df6d94186de", + "b7ba8091c34448ec8343186fd1635a76", + "4b9d32fe64744e84a6ac8ee29f9ce2e2", + "4e9b5e2d748f44f59ad95a45cd82c947", + "ca184d90146749978a799e9e2f8e0fab", + "41ba23629f3644b7b54d5d9020127203", + "0d81fe758d9f42bf9bd7a01148ef8711", + "f4bcd0c3cbd84648ac8d2569cc28194c", + "1516df02bdf64cf4ac8776cd15d2682b", + "c837a8f16d044a4e8359dcde536221a4" + ] + }, + "id": "oVQyYrVbVygK", + "outputId": "6376bc22-24e6-40d7-f987-991ae2acdb9d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⏳ Force-loading STEM Sight Line Expert...\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=1.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # FIX: Handle the tensor output directly\n", + " sequence = processor.batch_decode(outputs)[0]\n", + "\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"═\"*50)\n", + " print(f\"🤖 AI SUMMARY: {clean_output}\")\n", + " print(\"═\"*50 + \"\\n\")\n", + "\n", + "run_final_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 655, + "referenced_widgets": [ + "d8b101dd03bf4624954b4f0facaf536c", + "aa2997f7b823437da82e14bb30fb5dca", + "1e0192c8cc8544978ff936943451adff", + "b65e66bb979e4076ac9e075b6154a0c3", + "1cdf5f06444a4cefb2eecd1d932e042d", + "8ac4897bb55a420aaf8a7e0f4f74a39a", + "b76a4ef27a4e4f4cb5b482beece2ed22", + "7fed5af4533c420695843dc595e20b11", + "2745f15e834742a0b0f1a479963597a1", + "9ff64b9d6b91442e8547c59c7e331e92", + "5479b0dbce8b4c0baf7df0d57c41fe5c" + ] + }, + "id": "F5lIMv6SXDG6", + "outputId": "90ebdae0-4861-46bb-e358-9066b131cfb9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading weights from: /content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/checkpoint-625/model.safetensors\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving linr_chart1.png to linr_chart1 (2).png\n", + "\n", + "🔍 Analyzing: linr_chart1 (2).png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 450 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "══════════════════════════════════════════════════\n", + "🤖 AI SUMMARY: 26.0'. The x-axis shows Years and the y-axis shows % of total ages 15-64.\n", + "══════════════════════════════════════════════════\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import os\n", + "import glob\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "\n", + "# 1. SETUP PATHS\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "base_weights_path = \"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed\"\n", + "\n", + "# 2. ACCURATE WEIGHT FINDER (Targeting pytorch_model.bin or model.safetensors)\n", + "possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"pytorch_model.bin\"), recursive=True)\n", + "if not possible_weight_files:\n", + " possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"model.safetensors\"), recursive=True)\n", + "\n", + "if not possible_weight_files:\n", + " raise FileNotFoundError(\"Could not find weights. Check your Drive path!\")\n", + "\n", + "weights_file = sorted(possible_weight_files)[-1]\n", + "print(f\"🧠 Loading weights from: {weights_file}\")\n", + "\n", + "# 3. RECONSTRUCT MODEL\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path, tie_word_embeddings=False).to(device)\n", + "\n", + "if weights_file.endswith(\".safetensors\"):\n", + " from safetensors.torch import load_file\n", + " state_dict = load_file(weights_file, device=device)\n", + "else:\n", + " state_dict = torch.load(weights_file, map_location=device, weights_only=False)\n", + "\n", + "model.load_state_dict(state_dict, strict=False)\n", + "model.eval()\n", + "print(\"✅ STEM Sight Line Expert is ready!\")\n", + "\n", + "# 4. FIXED INFERENCE FUNCTION\n", + "def run_final_test():\n", + " uploaded = files.upload()\n", + " for filename in uploaded.keys():\n", + " print(f\"\\n🔍 Analyzing: {filename}\")\n", + " display.display(display.Image(filename, width=450))\n", + "\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=1.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # FIX: Handle the tensor output directly\n", + " sequence = processor.batch_decode(outputs)[0]\n", + "\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"═\"*50)\n", + " print(f\"🤖 AI SUMMARY: {clean_output}\")\n", + " print(\"═\"*50 + \"\\n\")\n", + "\n", + "run_final_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 576, + "referenced_widgets": [ + "b09ab07a213a4ba480dad6e3a0d22be8", + "688803336ef44fd988595360679a514a", + "bef0f13e442049f7989e7e7a80227305", + "47bc34f9ca184b4993cfdcd291cba5ce", + "8b1025a0ca13413ab47830a5665d5cfa", + "07313d9a1b8f41d08e0cb0bbba7834d5", + "6121656d5d7a487e9bfcee14b71e17e2", + "6cdea3f2343c499ca31780076295a83b", + "e2f80df2031045a4acf87df89a97ec26", + "c37617a0c5864cb6bf3d16a1c31586bf", + "19e03097a2fe4218af1553fad566713f" + ] + }, + "id": "vkKB1Z7sX5Yk", + "outputId": "df41fdf6-1044-47eb-cef3-3d4e783a7c66" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading weights from: /content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/checkpoint-625/model.safetensors\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 16961.png to 16961.png\n", + "\n", + "🔍 Analyzing: 16961.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 450 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "══════════════════════════════════════════════════\n", + "🤖 AI SUMMARY: Proportion of the total labor force ages 15-64 who participated in production in Indonesia'. The x-axis shows Year and the y-axis shows Labor Force (in %).\n", + "══════════════════════════════════════════════════\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import os\n", + "import glob\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "\n", + "# 1. SETUP PATHS\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "base_weights_path = \"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed\"\n", + "\n", + "# 2. ACCURATE WEIGHT FINDER (Targeting pytorch_model.bin or model.safetensors)\n", + "possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"pytorch_model.bin\"), recursive=True)\n", + "if not possible_weight_files:\n", + " possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"model.safetensors\"), recursive=True)\n", + "\n", + "if not possible_weight_files:\n", + " raise FileNotFoundError(\"Could not find weights. Check your Drive path!\")\n", + "\n", + "weights_file = sorted(possible_weight_files)[-1]\n", + "print(f\"🧠 Loading weights from: {weights_file}\")\n", + "\n", + "# 3. RECONSTRUCT MODEL\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path, tie_word_embeddings=False).to(device)\n", + "\n", + "if weights_file.endswith(\".safetensors\"):\n", + " from safetensors.torch import load_file\n", + " state_dict = load_file(weights_file, device=device)\n", + "else:\n", + " state_dict = torch.load(weights_file, map_location=device, weights_only=False)\n", + "\n", + "model.load_state_dict(state_dict, strict=False)\n", + "model.eval()\n", + "print(\"✅ STEM Sight Line Expert is ready!\")\n", + "\n", + "# 4. FIXED INFERENCE FUNCTION\n", + "def run_final_test():\n", + " uploaded = files.upload()\n", + " for filename in uploaded.keys():\n", + " print(f\"\\n🔍 Analyzing: {filename}\")\n", + " display.display(display.Image(filename, width=450))\n", + "\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=1.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # FIX: Handle the tensor output directly\n", + " sequence = processor.batch_decode(outputs)[0]\n", + "\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"═\"*50)\n", + " print(f\"🤖 AI SUMMARY: {clean_output}\")\n", + " print(\"═\"*50 + \"\\n\")\n", + "\n", + "run_final_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 594, + "referenced_widgets": [ + "7b3529c830544f788bc1b13ccbdebe3a", + "db87582c911a41f1a2544c014e0f6905", + "29d279c079ee456d90b362caf90e5dd9", + "f95cf3c2b7784f16aaa0c007de387f85", + "5ec317fc3ca5460891e13f33d5a2b806", + "6e4f133dc02b4d87961d994ff403016d", + "0c07bece50ae4b9abb5b4f86cdecd8ba", + "e2e28ecf4587496d93a940da577db485", + "6d6c0242f8244b5d9a94cda038291188", + "5f845f4b826f46cfb67c365a84122f1a", + "79ee6c7dd1024515a3562f3569b2910e" + ] + }, + "id": "y3HYEwH9YL1W", + "outputId": "e131d1a4-f5ea-4ec8-9625-c831d8508534" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading weights from: /content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/checkpoint-625/model.safetensors\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 17106.png to 17106.png\n", + "\n", + "🔍 Analyzing: 17106.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 450 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "══════════════════════════════════════════════════\n", + "🤖 AI SUMMARY: Service exports vs imports of East Asia (developing only)'. The x-axis shows Year and the y-axis shows Exports(% of total merchandise exports).\n", + "══════════════════════════════════════════════════\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import os\n", + "import glob\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "\n", + "# 1. SETUP PATHS\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "base_weights_path = \"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed\"\n", + "\n", + "# 2. ACCURATE WEIGHT FINDER (Targeting pytorch_model.bin or model.safetensors)\n", + "possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"pytorch_model.bin\"), recursive=True)\n", + "if not possible_weight_files:\n", + " possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"model.safetensors\"), recursive=True)\n", + "\n", + "if not possible_weight_files:\n", + " raise FileNotFoundError(\"Could not find weights. Check your Drive path!\")\n", + "\n", + "weights_file = sorted(possible_weight_files)[-1]\n", + "print(f\"🧠 Loading weights from: {weights_file}\")\n", + "\n", + "# 3. RECONSTRUCT MODEL\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path, tie_word_embeddings=False).to(device)\n", + "\n", + "if weights_file.endswith(\".safetensors\"):\n", + " from safetensors.torch import load_file\n", + " state_dict = load_file(weights_file, device=device)\n", + "else:\n", + " state_dict = torch.load(weights_file, map_location=device, weights_only=False)\n", + "\n", + "model.load_state_dict(state_dict, strict=False)\n", + "model.eval()\n", + "print(\"✅ STEM Sight Line Expert is ready!\")\n", + "\n", + "# 4. FIXED INFERENCE FUNCTION\n", + "def run_final_test():\n", + " uploaded = files.upload()\n", + " for filename in uploaded.keys():\n", + " print(f\"\\n🔍 Analyzing: {filename}\")\n", + " display.display(display.Image(filename, width=450))\n", + "\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=1.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # FIX: Handle the tensor output directly\n", + " sequence = processor.batch_decode(outputs)[0]\n", + "\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"═\"*50)\n", + " print(f\"🤖 AI SUMMARY: {clean_output}\")\n", + " print(\"═\"*50 + \"\\n\")\n", + "\n", + "run_final_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 548, + "referenced_widgets": [ + "ad17922337e944edbb51d6e5c96afbe7", + "4a6a3d478f38437cb53a1d5f7c48924e", + "bb33d64e14004e01a3e8d084f1941cce", + "43139d112a7a494ca64a174103d700aa", + "c51144374872428aacdd013d30745443", + "85a7326982f34e15b62d752e73a0447c", + "7be5f58e8ef8427c99c820c3a3eeffd1", + "377d1890d8574396ad2bd47ad5ed0b7a", + "d37905c3a9c14763bbdedf9fe713e387", + "b0c8c700c3054b42971fd6c57a5ad679", + "d619d5ccedae4f80a56907e87a1e7860" + ] + }, + "id": "xSX2ngBmYZQs", + "outputId": "8c5bb3b4-2e32-4c50-cf47-5c2812973b21" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading weights from: /content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/checkpoint-625/model.safetensors\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 17322.png to 17322.png\n", + "\n", + "🔍 Analyzing: 17322.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 450 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "══════════════════════════════════════════════════\n", + "🤖 AI SUMMARY: \"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=1.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # FIX: Handle the tensor output directly\n", + " sequence = processor.batch_decode(outputs)[0]\n", + "\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"═\"*50)\n", + " print(f\"🤖 AI SUMMARY: {clean_output}\")\n", + " print(\"═\"*50 + \"\\n\")\n", + "\n", + "run_final_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 614, + "referenced_widgets": [ + "08516ff14e424a3383875c9784ce12bd", + "0ae95c2129de4e34acaf3c7e5fde5e00", + "d52c52364182424598be6a52c7ff2025", + "3f570bcdd82a4c2a96671251736c1fb9", + "3d65e23fee5e413990b141fd4d5584d9", + "9865f695c44e42bdb3cb5387f2ed6453", + "0099d50a4321407da0ae8a5bd24df8a2", + "e4d75dc2be1d4a17a0c3fa6825c3d193", + "a9837e5d38f24253a64925187e383d28", + "9203cf9115a4429abea578e44c5a530f", + "65f7245c8323475b91a0b36400c4bd04" + ] + }, + "id": "CwJNQOLuYlHv", + "outputId": "5b2e5c8a-451c-4d35-87d6-cd16c0adfc3c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading weights from: /content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/checkpoint-625/model.safetensors\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 17767.png to 17767.png\n", + "\n", + "🔍 Analyzing: 17767.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 450 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "══════════════════════════════════════════════════\n", + "🤖 AI SUMMARY: Earnings from tourism in West Bank and Gaza'. The x-axis shows Year and the y-axis shows Amount (in US$).\n", + "══════════════════════════════════════════════════\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import os\n", + "import glob\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "\n", + "# 1. SETUP PATHS\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "base_weights_path = \"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed\"\n", + "\n", + "# 2. ACCURATE WEIGHT FINDER (Targeting pytorch_model.bin or model.safetensors)\n", + "possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"pytorch_model.bin\"), recursive=True)\n", + "if not possible_weight_files:\n", + " possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"model.safetensors\"), recursive=True)\n", + "\n", + "if not possible_weight_files:\n", + " raise FileNotFoundError(\"Could not find weights. Check your Drive path!\")\n", + "\n", + "weights_file = sorted(possible_weight_files)[-1]\n", + "print(f\"🧠 Loading weights from: {weights_file}\")\n", + "\n", + "# 3. RECONSTRUCT MODEL\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path, tie_word_embeddings=False).to(device)\n", + "\n", + "if weights_file.endswith(\".safetensors\"):\n", + " from safetensors.torch import load_file\n", + " state_dict = load_file(weights_file, device=device)\n", + "else:\n", + " state_dict = torch.load(weights_file, map_location=device, weights_only=False)\n", + "\n", + "model.load_state_dict(state_dict, strict=False)\n", + "model.eval()\n", + "print(\"✅ STEM Sight Line Expert is ready!\")\n", + "\n", + "# 4. FIXED INFERENCE FUNCTION\n", + "def run_final_test():\n", + " uploaded = files.upload()\n", + " for filename in uploaded.keys():\n", + " print(f\"\\n🔍 Analyzing: {filename}\")\n", + " display.display(display.Image(filename, width=450))\n", + "\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=1.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # FIX: Handle the tensor output directly\n", + " sequence = processor.batch_decode(outputs)[0]\n", + "\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"═\"*50)\n", + " print(f\"🤖 AI SUMMARY: {clean_output}\")\n", + " print(\"═\"*50 + \"\\n\")\n", + "\n", + "run_final_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 575, + "referenced_widgets": [ + "3b8bc16a083a447997c06d51abb8ea4d", + "2e7dc4ab0e0d4dc38eb112f57a252032", + "c64e9a950306452caa7a9c487f739a88", + "77dcdc4d0f764b19974e79cd08fee06c", + "dda0fea2a62d40b09b0bc4f287ae63a9", + "e239c0c27c0d45b2b063a4d10c04781d", + "f68aae9a642243f68b32248d1546913e", + "98bab1803a4b4178a3dab2d5e0a7730f", + "96049c060f744c5eaf5a3531577c01be", + "fb99b7100db9410c8c7c1b2d2ca7982a", + "f855e1a1ceef4e3a986b6960963520c6" + ] + }, + "id": "MI7knhiKYvJ_", + "outputId": "15db14c8-a498-4aba-8cfb-dd0323ddd318" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading weights from: /content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/checkpoint-625/model.safetensors\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving line-chart2.png to line-chart2.png\n", + "\n", + "🔍 Analyzing: line-chart2.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 450 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "══════════════════════════════════════════════════\n", + "🤖 AI SUMMARY: Feefficial relief reopulation'. The x-axis shows Years and the y-axis shows Population(% of total).\n", + "══════════════════════════════════════════════════\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import os\n", + "import glob\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "\n", + "# 1. SETUP PATHS\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "base_weights_path = \"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed\"\n", + "\n", + "# 2. ACCURATE WEIGHT FINDER (Targeting pytorch_model.bin or model.safetensors)\n", + "possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"pytorch_model.bin\"), recursive=True)\n", + "if not possible_weight_files:\n", + " possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"model.safetensors\"), recursive=True)\n", + "\n", + "if not possible_weight_files:\n", + " raise FileNotFoundError(\"Could not find weights. Check your Drive path!\")\n", + "\n", + "weights_file = sorted(possible_weight_files)[-1]\n", + "print(f\"🧠 Loading weights from: {weights_file}\")\n", + "\n", + "# 3. RECONSTRUCT MODEL\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path, tie_word_embeddings=False).to(device)\n", + "\n", + "if weights_file.endswith(\".safetensors\"):\n", + " from safetensors.torch import load_file\n", + " state_dict = load_file(weights_file, device=device)\n", + "else:\n", + " state_dict = torch.load(weights_file, map_location=device, weights_only=False)\n", + "\n", + "model.load_state_dict(state_dict, strict=False)\n", + "model.eval()\n", + "print(\"✅ STEM Sight Line Expert is ready!\")\n", + "\n", + "# 4. FIXED INFERENCE FUNCTION\n", + "def run_final_test():\n", + " uploaded = files.upload()\n", + " for filename in uploaded.keys():\n", + " print(f\"\\n🔍 Analyzing: {filename}\")\n", + " display.display(display.Image(filename, width=450))\n", + "\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=1.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # FIX: Handle the tensor output directly\n", + " sequence = processor.batch_decode(outputs)[0]\n", + "\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"═\"*50)\n", + " print(f\"🤖 AI SUMMARY: {clean_output}\")\n", + " print(\"═\"*50 + \"\\n\")\n", + "\n", + "run_final_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 640, + "referenced_widgets": [ + "a7fa8434c3404763a6eb4ea92bce6bdf", + "1663ac9f8f73408082fbd7c14d259403", + "fdb5458e6f6441cbb224faf40faf7132", + "4de993f4ee5147b38c4d5db2e0c3b571", + "900e900edbba4880a803a3cb9b311dc7", + "316e23d8479241169033086106309834", + "97c64eef9bbe44c6b3973de56df737ea", + "690a5d0aad60456c97a109f84cb9f2df", + "9c2de1e17731465e9f33cc59f2a5f0e4", + "e8280299dd73420b9fb12a994950c096", + "4cc565d0a25549f8beda3ce6b6fba015" + ] + }, + "id": "Wt342Lz7Y-Rr", + "outputId": "0088ab01-2fcd-4fab-d4f7-6e19fffe5197" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading weights from: /content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/checkpoint-625/model.safetensors\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving Line-Graph3.png to Line-Graph3.png\n", + "\n", + "🔍 Analyzing: Line-Graph3.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 450 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "══════════════════════════════════════════════════\n", + "🤖 AI SUMMARY: average monthly rainfall'. The x-axis shows Years and the y-axis shows Average monthly (in %).\n", + "══════════════════════════════════════════════════\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import os\n", + "import glob\n", + "from PIL import Image\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel\n", + "from google.colab import files\n", + "import IPython.display as display\n", + "\n", + "# 1. SETUP PATHS\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "base_weights_path = \"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed\"\n", + "\n", + "# 2. ACCURATE WEIGHT FINDER (Targeting pytorch_model.bin or model.safetensors)\n", + "possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"pytorch_model.bin\"), recursive=True)\n", + "if not possible_weight_files:\n", + " possible_weight_files = glob.glob(os.path.join(base_weights_path, \"**\", \"model.safetensors\"), recursive=True)\n", + "\n", + "if not possible_weight_files:\n", + " raise FileNotFoundError(\"Could not find weights. Check your Drive path!\")\n", + "\n", + "weights_file = sorted(possible_weight_files)[-1]\n", + "print(f\"🧠 Loading weights from: {weights_file}\")\n", + "\n", + "# 3. RECONSTRUCT MODEL\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path, tie_word_embeddings=False).to(device)\n", + "\n", + "if weights_file.endswith(\".safetensors\"):\n", + " from safetensors.torch import load_file\n", + " state_dict = load_file(weights_file, device=device)\n", + "else:\n", + " state_dict = torch.load(weights_file, map_location=device, weights_only=False)\n", + "\n", + "model.load_state_dict(state_dict, strict=False)\n", + "model.eval()\n", + "print(\"✅ STEM Sight Line Expert is ready!\")\n", + "\n", + "# 4. FIXED INFERENCE FUNCTION\n", + "def run_final_test():\n", + " uploaded = files.upload()\n", + " for filename in uploaded.keys():\n", + " print(f\"\\n🔍 Analyzing: {filename}\")\n", + " display.display(display.Image(filename, width=450))\n", + "\n", + " image = Image.open(filename).convert(\"RGB\")\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " task_prompt = \"\"\n", + " decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors=\"pt\").input_ids.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " decoder_input_ids=decoder_input_ids,\n", + " max_length=512,\n", + " num_beams=4,\n", + " repetition_penalty=1.5,\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " )\n", + "\n", + " # FIX: Handle the tensor output directly\n", + " sequence = processor.batch_decode(outputs)[0]\n", + "\n", + " clean_output = sequence.replace(task_prompt, \"\").replace(processor.tokenizer.eos_token, \"\").replace(processor.tokenizer.pad_token, \"\").strip()\n", + "\n", + " print(\"\\n\" + \"═\"*50)\n", + " print(f\"🤖 AI SUMMARY: {clean_output}\")\n", + " print(\"═\"*50 + \"\\n\")\n", + "\n", + "run_final_test()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 565, + "referenced_widgets": [ + "c8a5a120cab146df8e872f53539ef394", + "01603fc26c79471f83d3eb1a3594d5c4", + "bf64b60b5ab944eeb8d7e047c5eeacbb", + "3bbb8654ce864ebab657525b2dc953a5", + "56b28d695fc84c619c30d77f98927d26", + "8ef86695b0c844ff959cae54af10e109", + "d2238e0de3c0428fa95aad02f285b1cb", + "80f75fa1faee4d0a95a9b344c36b9d59", + "bea6379547e14dbd80009d916fa9833f", + "33e832d6857040c7865535432a24e76f", + "2689674209f0462e9091ff4c7b04a669" + ] + }, + "id": "uwa4r5cFZMgH", + "outputId": "1f7bd5b7-c181-4e29-d52b-c4e9e217a72a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading weights from: /content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/checkpoint-625/model.safetensors\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 17256.png to 17256.png\n", + "\n", + "🔍 Analyzing: 17256.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 450 + } + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "══════════════════════════════════════════════════\n", + "🤖 AI SUMMARY: Employment on health care (as % of GDP) in Cuba'. The x-axis shows Year and the y-axis shows Health expenditure (as % of GDP).\n", + "══════════════════════════════════════════════════\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import shutil\n", + "import os\n", + "\n", + "# 1. Define paths\n", + "final_local_folder = \"/content/STEM_Sight_Line_Final_Local\"\n", + "os.makedirs(final_local_folder, exist_ok=True)\n", + "\n", + "# 2. Save the model and processor into this one folder\n", + "# This will save the config.json, preprocessor_config.json, and the weights together\n", + "model.save_pretrained(final_local_folder)\n", + "processor.save_pretrained(final_local_folder)\n", + "\n", + "print(f\"✅ Model consolidated in {final_local_folder}\")\n", + "\n", + "# 3. Zip the folder for download\n", + "shutil.make_archive(\"STEM_Sight_Line_Model\", 'zip', final_local_folder)\n", + "print(\"📦 Zip file created: STEM_Sight_Line_Model.zip\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 85, + "referenced_widgets": [ + "29b05c8f0ddb47c0bb2ba6fff4b44527", + "614ad15059164e2cbec45cb5aa2b3a5a", + "a198b007614d4ee8a55c2ebdf0706274", + "7b643cb936064643bfacaabfe4cb7bc2", + "94092f9f2953449abb78811c89edf6cf", + "eed9ee3ef0244b52ac821e5fb5577c07", + "2d903d35cc714664a1596b132ecad0cf", + "8b91ef3bce6f4226b9c3b5fc90b94003", + "e5d611675068424c9a403f84e4840aab", + "b41b97d92fb04e308212e41b153849b6", + "644b8c1dcbfc4497a82235e9f8c5d08b" + ] + }, + "id": "R8F1CA1xZ_Pg", + "outputId": "0eed4115-0e80-432f-a6cf-889d10a86e69" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Writing model shards: 0%| | 0/1 [00:00" + ], + "application/javascript": [ + "\n", + " async function download(id, filename, size) {\n", + " if (!google.colab.kernel.accessAllowed) {\n", + " return;\n", + " }\n", + " const div = document.createElement('div');\n", + " const label = document.createElement('label');\n", + " label.textContent = `Downloading \"${filename}\": `;\n", + " div.appendChild(label);\n", + " const progress = document.createElement('progress');\n", + " progress.max = size;\n", + " div.appendChild(progress);\n", + " document.body.appendChild(div);\n", + "\n", + " const buffers = [];\n", + " let downloaded = 0;\n", + "\n", + " const channel = await google.colab.kernel.comms.open(id);\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + "\n", + " for await (const message of channel.messages) {\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + " if (message.buffers) {\n", + " for (const buffer of message.buffers) {\n", + " buffers.push(buffer);\n", + " downloaded += buffer.byteLength;\n", + " progress.value = downloaded;\n", + " }\n", + " }\n", + " }\n", + " const blob = new Blob(buffers, {type: 'application/binary'});\n", + " const a = document.createElement('a');\n", + " a.href = window.URL.createObjectURL(blob);\n", + " a.download = filename;\n", + " div.appendChild(a);\n", + " a.click();\n", + " div.remove();\n", + " }\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "download(\"download_26e0f22d-db04-485a-9e4c-bc137b71aa82\", \"STEM_Sight_Line_Model.zip\", 969068226)" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# --- STEP 1: UNZIP LINE DATA ---\n", + "# Path sahi se check kar lena: /content/drive/MyDrive/PlotQA-Stemsight/line_plots_train.zip\n", + "!unzip -q \"/content/drive/MyDrive/PlotQA-Stemsight/line_plots_train.zip\" -d /content/dataset_line_plots\n", + "print(\"✅ Step 1: Line Plots Unzip Complete!\")\n", + "\n", + "import torch\n", + "import os\n", + "import multiprocessing\n", + "from datasets import load_dataset\n", + "from transformers import DonutProcessor, VisionEncoderDecoderModel, Seq2SeqTrainingArguments, Seq2SeqTrainer, TrainerCallback\n", + "\n", + "# --- STEP 2: LOAD MODEL & PROCESSOR (Starting from VBAR Weights) ---\n", + "master_path = \"/content/drive/MyDrive/STEM_Sight_VBAR_Final\"\n", + "processor = DonutProcessor.from_pretrained(master_path)\n", + "model = VisionEncoderDecoderModel.from_pretrained(master_path)\n", + "\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model.to(device)\n", + "model.config.tie_word_embeddings = False\n", + "print(f\"✅ Step 2: Model Loaded on {device.upper()} using VBAR Weights\")\n", + "\n", + "# --- STEP 3: DATASET PREP (10K Samples) ---\n", + "# ImageFolder automatically metadata.jsonl se 'text' ya 'ground_truth' utha lega\n", + "full_dataset = load_dataset(\"imagefolder\", data_dir=\"/content/dataset_line_plots\", split=\"train\")\n", + "\n", + "# Exactly 10,000 samples select karna\n", + "dataset_10k = full_dataset.select(range(min(10000, len(full_dataset))))\n", + "\n", + "# Column detection (Automated)\n", + "all_cols = dataset_10k.column_names\n", + "# Image aur file_name ko chhod kar jo bacha wo text column hai\n", + "text_col = [col for col in all_cols if col not in ['image', 'file_name']][0]\n", + "\n", + "print(f\"✅ Step 3: 10k Samples Ready. Using '{text_col}' for labels.\")\n", + "\n", + "# --- STEP 4: FAST MAPPING (Dot-Line Logic) ---\n", + "def preprocess_fn(examples):\n", + " # Image to Pixel Values\n", + " pixel_values = processor([img.convert(\"RGB\") for img in examples[\"image\"]], return_tensors=\"pt\").pixel_values\n", + " # Text to Labels\n", + " labels = processor.tokenizer(examples[text_col], padding=\"max_length\", max_length=512, truncation=True).input_ids\n", + " return {\"pixel_values\": pixel_values, \"labels\": labels}\n", + "\n", + "# 9k train, 1k validation\n", + "split_ds = dataset_10k.train_test_split(test_size=0.1)\n", + "\n", + "# Multi-processing for speed\n", + "train_ds = split_ds[\"train\"].map(preprocess_fn, batched=True, batch_size=8, num_proc=multiprocessing.cpu_count(), remove_columns=all_cols)\n", + "eval_ds = split_ds[\"test\"].map(preprocess_fn, batched=True, batch_size=8, num_proc=multiprocessing.cpu_count(), remove_columns=all_cols)\n", + "\n", + "print(\"✅ Step 4: Mapping Done! Ready for Training.\")\n", + "\n", + "# --- STEP 5: COLLATOR & CALLBACK ---\n", + "def collate_fn(batch):\n", + " pixel_values = torch.stack([torch.tensor(item[\"pixel_values\"]) for item in batch])\n", + " labels = torch.stack([torch.tensor(item[\"labels\"]) for item in batch])\n", + " return {\"pixel_values\": pixel_values, \"labels\": labels}\n", + "\n", + "class PrinterCallback(TrainerCallback):\n", + " def on_log(self, args, state, control, logs=None, **kwargs):\n", + " if logs:\n", + " if \"loss\" in logs:\n", + " print(f\"📉 Step {state.global_step}: Training Loss = {logs['loss']:.4f}\")\n", + " if \"eval_loss\" in logs:\n", + " print(f\"🌟 Step {state.global_step}: VALIDATION LOSS = {logs['eval_loss']:.4f}\")\n", + "\n", + "# --- STEP 6: TRAINING ARGUMENTS ---\n", + "training_args = Seq2SeqTrainingArguments(\n", + " output_dir=\"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed\",\n", + " per_device_train_batch_size=2,\n", + " gradient_accumulation_steps=2,\n", + " max_steps=2000,\n", + " learning_rate=2e-5, # Stable LR jo tune manga tha\n", + " fp16=True,\n", + " eval_strategy=\"steps\",\n", + " eval_steps=200,\n", + " per_device_eval_batch_size=4,\n", + " predict_with_generate=False,\n", + " logging_steps=10,\n", + " save_strategy=\"steps\",\n", + " save_steps=500,\n", + " save_total_limit=1,\n", + " remove_unused_columns=False,\n", + " report_to=\"none\"\n", + ")\n", + "\n", + "# --- STEP 7: START TRAINING ---\n", + "trainer = Seq2SeqTrainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=train_ds,\n", + " eval_dataset=eval_ds, # Fixed: Using the split eval dataset\n", + " data_collator=collate_fn,\n", + " processing_class=processor.tokenizer,\n", + " callbacks=[PrinterCallback()]\n", + ")\n", + "\n", + "print(\"🚀 Starting Training... Loss will appear below.\")\n", + "trainer.train()\n", + "\n", + "# Final Save\n", + "model.save_pretrained(\"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model\")\n", + "processor.save_pretrained(\"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model\")\n", + "print(\"🔥 Model Saved Successfully.\")" + ], + "metadata": { + "id": "e8USN04wH-v6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "560e2cb728284299a03e4bc889d849c3", + "96e7f9abef604ef18778ae4da1fe36d5", + "4771e4a6b9f64d058501e3336b21a29c", + "5055f70d624544c58f4c524271b8f81e", + "9ebb8a083a5843a792480ded754c504b", + "6de6964f4c874545ae25ae8b80df032f", + "9f2e9df44c094cd49a421644377b4725", + "08f220db27e647a89970fca5ff228ef7", + "25c6c73094434c8295112032282c63e4", + "4d94e6c273544363ac538bc79ac76a3a", + "ba5f112677ba430695b581c77d62efc4", + "9b01fa33f45141dc9ac23ed4a48cb9a6", + "c3a1e47eac8e4ac7b91b9de82fb46b8a", + "53bffddffb634d7faf5e2c5a5e0f98ed", + "a1bcc57e877d4a3e95828a2c1080ba36", + "3aa3c33f8bdc4d9282c36390192a1ef7", + "2f49b2f0b2584568bfc5e70017cd518d", + "43f07491f87a441d9ffcbc6e5da17d0e", + "4dc99187896a403f9fb4fcee832872f2", + "e97fffcf5a59404b980a28c13783f16a", + "96e469d4a5a746669f1b2ba811726c7d", + "265e1797768a4617bab73e771541b338", + "ee9dd6c809664ca7a5cf2f1ef7dd7d2b", + "82b39f409d5c4d10b917cbcc25de5064", + "28c1810e8c2a423c9529febf1c93b354", + "b365f29a187d45409fbea45257169ad0", + "2650407791ca4c108556d155269fb8bb", + "dfbda15a7af54c9784359b7017b0b776", + "3e3a89cb21c148d393d23c25250cd91b", + "7fdb3e8b5c1a49298431fc0753ba4cd0", + "63b8dc8ad87f444c8635129d180560bb", + "07cb104596c64e31ae1a3e2108f0aa4f", + "f668b0169d484f4282d7db189c1a5b5e", + "3ef9e0aa986145368cc965ea28851824", + "5bc24a49ef4c4ff9b96710836e0f3088", + "1d45b73b747246618011fe8650730982", + "e5cab34a73224f0683cc3e947df0ae29", + "6cdae9dbc1de46c582921791176f9a98", + "4401d8de7c5943a78190577fb2c2feed", + "97f530fc82234759939243ee13d12a43", + "a22a19dce28e4836a6a49d33b9ceeb61", + "8cfcf1021e98432fb24b9f2510b4a0a2", + "98f02499da814e88814c4c44a66cc447", + "bdae954be96245e2ae4b87c144b75055", + "5868a6c294af4ac9ba904d06cd051858", + "6693a1e004e444e8bccd8820de0c98b3", + "d6c236aa7cdc4b2493d3715151e72124", + "cd6058a2139648b082fb00b2348aa172", + "cf2633681ba647c8b23416e483f38900", + "b9a4d5c7c1c8491fbf6443d9df150a6a", + "e2bd6a87a70b493bb25bca42ae0a309c", + "4738c3d7924b4ed587f0c16a0caa280b", + "9325a9f9e27d466a9dbe687084293834", + "8ad8f27b2c834ab09b92660b2a195d6c", + "689e033314be444d94240ec03ea518e1", + "bddf5088d63544738994cd3e70a32284", + "cbc5776ceb16433ab2402ab417958bf3", + "b39b9bf7269643b48f81a693698be33a", + "3e07baa15aff4278abf776e13b2adc44", + "33f6ae421c74459f8091ce66cf69337b", + "5ae4e1b48dd04f8eaf2b641b6795c5a6", + "2fb5c6acf41b45108f83e438ca3e4db4", + "ff7672fce675407899b08effde4e554a", + "2701341522794325a557f158f72cd715", + "a9a24ad7482e40b490fae3955a41480b", + "f2f549a88b3b47c59259279ab4ae6dca", + "8c8a9aaf24d843b595932a7a5a21c1a1", + "89c25de74e5d41379c39ec975f86bf41", + "d3080e268f0e4897bc96421eb603daa9", + "b096dfd363934479a3dd5cd7ccea049c", + "91667310026341d88a10728ff178ce0f", + "55eb010cdb044b68926d95db598d7661", + "332682337104496088ec0ec7775847ca", + "b37de576989244019c8e3b61a056451c", + "8afbb57d568143e183de30f31b373be4", + "e54c87c9304445c3823884c1c4e60e06", + "bc536fdbaf0c4907803ec18c5472041b", + "a4a30d1231a54b74a8b49066a132f4ab", + "ac3aba56f64b43d6b4e6d5ac4e9696ee", + "ba991519c8b4455c97a045db08602bd6", + "8f97cb298e5846d9898ae6bd5610ec37", + "28f7ff5df3bf489590bbf22b311e4ead", + "c3d064982f9949f3931ef49bd9ccd114", + "45a9817e92934c82a0b9f3491dafa0f4", + "ea34eb19e7a648c78a069c3b6b09de54", + "f176755d901446c29159c8c564d179ce", + "e7c40d7cec73496dac3e9db1c2307573", + "9a6ccf013fe7487fb4308fc32d361179", + "fdb834a47a8f4b5d8fba766d6c8fbbdb", + "483e0f120f984b4bb3c8925955427cf1", + "e4392119a19343329ee66662ff45718b", + "c012795417c44f0f94ffa075cfebabfb", + "4b03b3eafe16429a8f80c90b4358394a", + "7306075b2da94ca9960129f7e8ae726c", + "5b65c97ee4944db98fc93acb17aaef57", + "4bbdb5e290864b14bbb8869c29db2396", + "0f1e696c0609487a982510cd18d106fc", + "d22a4c85280243b1b6448f6eba620e78", + "682c5ffec4c94f0b9fb064387a6c49cc", + "6c4206bdc4454238ac6bedbb781c22d9", + "078b9b51c1a94f97a15dd31325448067", + "735e62f7e4d944dda251d6a1db25b639", + "4c768aa4844a4a16867a5de6f868abed", + "161930452e1849eb8352c4f13297b624", + "8a6accc0fca24a3b89a87b52fdf7fd14", + "5d06c3ef70804f06979f0c083d593d52", + "e2639bf4482f4d8992acdc45cc4b08fa", + "ba18bf0891aa44cc9bb9a77d4dc2fad1", + "f2554a4b21f046c18f5fbaeb34e22255", + "7cf2674cfaed4c6ca159732efd454fec", + "5ba34b038e684ecd923c370b82964bcb", + "e233aecdfc214e55bf801a26b120e4fb", + "0948f84f3607468681d41c94df57a731", + "3d34808f76d74943b80b046929b5d6ce", + "ba91b53a497245a395300b27863f218e", + "d5bf13b6f3ab419f8bc917a66498202e", + "9c23f1bd25634f75a7dea80517c47b9e", + "eef8078b691949bf8e4432a8f580fbdc", + "295c5a7aebab49efa7a9bac53d63bdfb", + "4a05499f7dda4099b787bd7a8d015cd0", + "73ba5ebb05234723862c360fea80c7e2" + ] + }, + "outputId": "db040969-22a1-4ba6-8f46-315de93799a0" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "✅ Step 1: Line Plots Unzip Complete!\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Loading weights: 0%| | 0/484 [00:00" + ], + "text/html": [ + "\n", + "

\n", + " \n", + " \n", + " [2000/2000 1:53:22, Epoch 0/1]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining LossValidation Loss
2000.0164220.003915
4000.0060520.002039
6000.0076640.001684
8000.0055570.001134
10000.0024610.001000
12000.0033220.000875
14000.0038000.000695
16000.0013030.000588
18000.0015870.000482
20000.0015770.000450

" + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📉 Step 10: Training Loss = 29.0974\n", + "📉 Step 20: Training Loss = 16.4636\n", + "📉 Step 30: Training Loss = 14.6269\n", + "📉 Step 40: Training Loss = 12.3845\n", + "📉 Step 50: Training Loss = 10.0350\n", + "📉 Step 60: Training Loss = 7.7574\n", + "📉 Step 70: Training Loss = 5.5127\n", + "📉 Step 80: Training Loss = 3.4271\n", + "📉 Step 90: Training Loss = 1.7121\n", + "📉 Step 100: Training Loss = 0.6704\n", + "📉 Step 110: Training Loss = 0.2218\n", + "📉 Step 120: Training Loss = 0.0759\n", + "📉 Step 130: Training Loss = 0.0275\n", + "📉 Step 140: Training Loss = 0.0178\n", + "📉 Step 150: Training Loss = 0.0132\n", + "📉 Step 160: Training Loss = 0.0187\n", + "📉 Step 170: Training Loss = 0.0192\n", + "📉 Step 180: Training Loss = 0.0132\n", + "📉 Step 190: Training Loss = 0.0261\n", + "📉 Step 200: Training Loss = 0.0164\n", + "🌟 Step 200: VALIDATION LOSS = 0.0039\n", + "📉 Step 210: Training Loss = 0.0095\n", + "📉 Step 220: Training Loss = 0.0122\n", + "📉 Step 230: Training Loss = 0.0118\n", + "📉 Step 240: Training Loss = 0.0132\n", + "📉 Step 250: Training Loss = 0.0113\n", + "📉 Step 260: Training Loss = 0.0113\n", + "📉 Step 270: Training Loss = 0.0078\n", + "📉 Step 280: Training Loss = 0.0100\n", + "📉 Step 290: Training Loss = 0.0091\n", + "📉 Step 300: Training Loss = 0.0136\n", + "📉 Step 310: Training Loss = 0.0078\n", + "📉 Step 320: Training Loss = 0.0079\n", + "📉 Step 330: Training Loss = 0.0134\n", + "📉 Step 340: Training Loss = 0.0083\n", + "📉 Step 350: Training Loss = 0.0106\n", + "📉 Step 360: Training Loss = 0.0065\n", + "📉 Step 370: Training Loss = 0.0063\n", + "📉 Step 380: Training Loss = 0.0070\n", + "📉 Step 390: Training Loss = 0.0086\n", + "📉 Step 400: Training Loss = 0.0061\n", + "🌟 Step 400: VALIDATION LOSS = 0.0020\n", + "📉 Step 410: Training Loss = 0.0037\n", + "📉 Step 420: Training Loss = 0.0081\n", + "📉 Step 430: Training Loss = 0.0052\n", + "📉 Step 440: Training Loss = 0.0113\n", + "📉 Step 450: Training Loss = 0.0062\n", + "📉 Step 460: Training Loss = 0.0059\n", + "📉 Step 470: Training Loss = 0.0073\n", + "📉 Step 480: Training Loss = 0.0119\n", + "📉 Step 490: Training Loss = 0.0062\n", + "📉 Step 500: Training Loss = 0.0125\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Writing model shards: 0%| | 0/1 [00:00" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 17040.png to 17040.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "

" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⌛ Analyzing '17040.png'...\n", + "\n", + "✨ Model Prediction (JSON):\n", + "{\"gt_parse\": \"This is a line titled 'Percentage of fraud firms (not-registered or running illegally) vs registered firms in World'. The x-axis shows Year and the y-axis shows % of firms.\"}\n", + "================================================================================\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 1. Image upload trigger karein\n", + "print(\"📤 Apni Line Graph image select karein:\")\n", + "uploaded = files.upload()\n", + "\n", + "# 2. Model ko evaluation mode mein set karein\n", + "model.eval()\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model.to(device)\n", + "\n", + "for filename in uploaded.keys():\n", + " # Image load aur display setup\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " # Image ko screen par dikhane ke liye\n", + " plt.figure(figsize=(10, 6))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded: {filename}\")\n", + " plt.show()\n", + "\n", + " # 3. Processing & Prediction\n", + " print(f\"⌛ Analyzing '{filename}'...\")\n", + "\n", + " # Pixel values prepare karein\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768, # Pure caption ke liye zaroori hai\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " # 4. Output Display\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction (JSON):\")\n", + " print(prediction)\n", + " print(\"=\"*80)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 705 + }, + "id": "c51NwIxc2tS4", + "outputId": "54b385ba-439e-4cd9-9af6-563f667c63fe" + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📤 Apni Line Graph image select karein:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 17434.png to 17434.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⌛ Analyzing '17434.png'...\n", + "\n", + "✨ Model Prediction (JSON):\n", + "{\"gt_parse\": \"This is a line titled 'Mortality rates in Channel Islands'. The x-axis shows Year and the y-axis shows Mortality Rate (per 1000 live birth or children).\"}\n", + "================================================================================\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 1. Image upload trigger karein\n", + "print(\"📤 Apni Line Graph image select karein:\")\n", + "uploaded = files.upload()\n", + "\n", + "# 2. Model ko evaluation mode mein set karein\n", + "model.eval()\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model.to(device)\n", + "\n", + "for filename in uploaded.keys():\n", + " # Image load aur display setup\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " # Image ko screen par dikhane ke liye\n", + " plt.figure(figsize=(10, 6))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded: {filename}\")\n", + " plt.show()\n", + "\n", + " # 3. Processing & Prediction\n", + " print(f\"⌛ Analyzing '{filename}'...\")\n", + "\n", + " # Pixel values prepare karein\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768, # Pure caption ke liye zaroori hai\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " # 4. Output Display\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction (JSON):\")\n", + " print(prediction)\n", + " print(\"=\"*80)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 637 + }, + "id": "xEBbLGEF2yhB", + "outputId": "dd9aa0eb-3431-4851-8be1-b6803eb5cb7b" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📤 Apni Line Graph image select karein:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 17249.png to 17249.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⌛ Analyzing '17249.png'...\n", + "\n", + "✨ Model Prediction (JSON):\n", + "{\"gt_parse\": \"This is a line titled 'Expenditure on health care (as % of GDP) in Burundi'. The x-axis shows Year and the y-axis shows Health expenditure (as % of GDP).\"}\n", + "================================================================================\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 1. Image upload trigger karein\n", + "print(\"📤 Apni Line Graph image select karein:\")\n", + "uploaded = files.upload()\n", + "\n", + "# 2. Model ko evaluation mode mein set karein\n", + "model.eval()\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model.to(device)\n", + "\n", + "for filename in uploaded.keys():\n", + " # Image load aur display setup\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " # Image ko screen par dikhane ke liye\n", + " plt.figure(figsize=(10, 6))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded: {filename}\")\n", + " plt.show()\n", + "\n", + " # 3. Processing & Prediction\n", + " print(f\"⌛ Analyzing '{filename}'...\")\n", + "\n", + " # Pixel values prepare karein\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768, # Pure caption ke liye zaroori hai\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " # 4. Output Display\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction (JSON):\")\n", + " print(prediction)\n", + " print(\"=\"*80)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 670 + }, + "id": "AABuBUEj23YO", + "outputId": "c85fbe81-0a73-46c7-b626-e0d48b623e99" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📤 Apni Line Graph image select karein:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving 17303.png to 17303.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⌛ Analyzing '17303.png'...\n", + "\n", + "✨ Model Prediction (JSON):\n", + "{\"gt_parse\": \"This is a line titled 'Percentage of male workers employed in Industrial sector'. The x-axis shows Years and the y-axis shows Employment (as % of male employment).\"}\n", + "================================================================================\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 1. Image upload trigger karein\n", + "print(\"📤 Apni Line Graph image select karein:\")\n", + "uploaded = files.upload()\n", + "\n", + "# 2. Model ko evaluation mode mein set karein\n", + "model.eval()\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model.to(device)\n", + "\n", + "for filename in uploaded.keys():\n", + " # Image load aur display setup\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " # Image ko screen par dikhane ke liye\n", + " plt.figure(figsize=(10, 6))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded: {filename}\")\n", + " plt.show()\n", + "\n", + " # 3. Processing & Prediction\n", + " print(f\"⌛ Analyzing '{filename}'...\")\n", + "\n", + " # Pixel values prepare karein\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768, # Pure caption ke liye zaroori hai\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " # 4. Output Display\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction (JSON):\")\n", + " print(prediction)\n", + " print(\"=\"*80)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 705 + }, + "id": "_FM8UKzm28pL", + "outputId": "3303f898-738d-43ec-ffea-139b8cb992b6" + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📤 Apni Line Graph image select karein:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving IELTS_Writing_Task_1_152.png to IELTS_Writing_Task_1_152.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⌛ Analyzing 'IELTS_Writing_Task_1_152.png'...\n", + "\n", + "✨ Model Prediction (JSON):\n", + "{\"gt_parse\": \"This is a line titled 'Morney spent on Books'. The x-axis shows Years and the y-axis shows Export or import quantity.\"}\n", + "================================================================================\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 1. Image upload trigger karein\n", + "print(\"📤 Apni Line Graph image select karein:\")\n", + "uploaded = files.upload()\n", + "\n", + "# 2. Model ko evaluation mode mein set karein\n", + "model.eval()\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model.to(device)\n", + "\n", + "for filename in uploaded.keys():\n", + " # Image load aur display setup\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " # Image ko screen par dikhane ke liye\n", + " plt.figure(figsize=(10, 6))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded: {filename}\")\n", + " plt.show()\n", + "\n", + " # 3. Processing & Prediction\n", + " print(f\"⌛ Analyzing '{filename}'...\")\n", + "\n", + " # Pixel values prepare karein\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768, # Pure caption ke liye zaroori hai\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " # 4. Output Display\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction (JSON):\")\n", + " print(prediction)\n", + " print(\"=\"*80)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 705 + }, + "id": "qFZoMktu3FRc", + "outputId": "bec33ac2-953f-47bf-e4fa-4a3e762aedec" + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📤 Apni Line Graph image select karein:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving line-chart.png to line-chart.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxQAAAH4CAYAAADTmqtBAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/XecnGd56P9/nja9bS/aIq1WkiVLrtjgIlywMRhwgOPklYRgm5CEFEjgcJITON8EOIdz8krCCaQ6hxTzIxBCQgsdbJor4IqK1VbSavvO7uzs9Jmn3b8/RjvWele2vN5Vvd6vl5F25p5n7md20T7Xc9/XdWlKKYUQQgghhBBCrIB+picghBBCCCGEOHdJQCGEEEIIIYRYMQkohBBCCCGEECsmAYUQQgghhBBixSSgEEIIIYQQQqyYBBRCCCGEEEKIFZOAQgghhBBCCLFiElAIIYQQQgghVkwCCiGEEEIIIcSKSUAhhLhg3HPPPaxfv/6MvPf69eu55557Vu14w8PDaJrGpz71qRW9/sMf/jCapi16bLXnuNruueceYrHYmZ6GEEKI55GAQghxVlm40J2dnV32+e3bt3PjjTee3kmJC065XObDH/4wP/zhD8/0VIQQ4qxnnukJCCGEODscOHAAXZf7TFAPKD7ykY8ASAArhBAvQgIKIYQQAASDwTM9hTPO931s2z7T0xBCiHOK3IoSQpzTfvjDH6JpGp///Of54Ac/SGdnJ9FolDvuuIPR0dEXfX2pVOL9738/vb29BINBtmzZwsc+9jGUUovG3Xfffdx88820t7cTDAbZtm0b995775LjKaX46Ec/Sk9PD5FIhJtuuom9e/cu+97z8/O8973vbbz34OAgf/qnf4rv+0vG3XPPPSSTSVKpFHfffTfz8/NLjuc4Dvv372dycvJFz3s5z8+h+NSnPoWmaTzyyCP81//6X2lrayMajfKWt7yFmZmZJa//1re+xc6dO4lGo8Tjcd7whjec9NyX85Of/ITbb7+dpqYmotEol1xyCX/5l3+5ZNz4+DhvfvObicVitLW18d/+23/D87xFYz72sY9x7bXX0tLSQjgc5sorr+QLX/jCkmNpmsa73/1uPvvZz3LxxRcTDAb5+7//e9ra2gD4yEc+gqZpaJrGhz/84ZPOfeGzevDBB3nXu95FS0sLiUSCu+66i2w2u2js+vXreeMb38jDDz/M1VdfTSgUYmBggE9/+tNLjrtr1y5uuOEGwuEwPT09fPSjH+W+++5D0zSGh4dP4VMVQoi1JysUQojzwv/+3/8bTdP47//9v5NOp/nEJz7BLbfcwjPPPEM4HF72NUop7rjjDn7wgx/wzne+k8suu4zvfOc7/P7v/z7j4+N8/OMfb4y99957ufjii7njjjswTZOvfe1r/PZv/za+7/M7v/M7jXF//Md/zEc/+lFuv/12br/9dp566ile+9rXLrnrXS6XueGGGxgfH+dd73oXfX19PProo3zgAx9gcnKST3ziE405/tzP/RwPP/wwv/mbv8nWrVv58pe/zN13373kfMbHx9m6dSt33333ipO1l/Oe97yHpqYmPvShDzE8PMwnPvEJ3v3ud/P5z3++MeZf/uVfuPvuu7ntttv40z/9U8rlMvfeey/XX389Tz/99Ismw99///288Y1vpKuri9/7vd+js7OTffv28fWvf53f+73fa4zzPI/bbruNV77ylXzsYx/jgQce4P/+3//Lxo0b+a3f+q3GuL/8y7/kjjvu4G1vexu2bfNv//Zv/PzP/zxf//rXecMb3rDovb///e/z7//+77z73e+mtbWVSy+9lHvvvZff+q3f4i1veQtvfetbAbjkkkte9LN697vfTSqV4sMf/jAHDhzg3nvv5dixY43Ad8HQ0BB33nkn73znO7n77rv553/+Z+655x6uvPJKLr74YqD+/bzpppvQNI0PfOADRKNR/vEf/1FWkoQQZx8lhBBnkQ996EMKUDMzM8s+f/HFF6sbbrih8fUPfvADBah169apfD7fePzf//3fFaD+8i//svHY3Xffrfr7+xtff+UrX1GA+uhHP7roPe68806laZoaGhpqPFYul5fM5bbbblMDAwONr9PptAoEAuoNb3iD8n2/8fgHP/hBBai777678dj/+l//S0WjUXXw4MFFx/zDP/xDZRiGGhkZWTTHP/uzP2uMcV1X7dy5UwHqvvvuazx+9OjRJe9zMguf84n6+/sXvfa+++5TgLrlllsWnc/73vc+ZRiGmp+fV0opVSgUVCqVUr/+67++6HhTU1MqmUwuefz5XNdVGzZsUP39/SqbzS567sT3vfvuuxWg/uf//J+Lxlx++eXqyiuvXPTY879ftm2r7du3q5tvvnnR44DSdV3t3bt30eMzMzMKUB/60IdecO4LFj6rK6+8Utm23Xj8z/7szxSg/vM//7PxWH9/vwLUgw8+2HgsnU6rYDCo3v/+9zcee8973qM0TVNPP/1047FMJqOam5sVoI4ePXpKcxNCiLUmW56EEOeFu+66i3g83vj6zjvvpKuri29+85snfc03v/lNDMPgd3/3dxc9/v73vx+lFN/61rcaj524ypHL5ZidneWGG27gyJEj5HI5AB544AFs2+Y973nPorvR733ve5e893/8x3+wc+dOmpqamJ2dbfx3yy234HkeDz74YGOOpmkuuvtuGAbvec97lhxz/fr1KKVWdXUC4Dd+4zcWnc/OnTvxPI9jx44B9dWF+fl5fumXfmnRuRiGwStf+Up+8IMfvODxn376aY4ePcp73/teUqnUoueeX9oW4Dd/8zcXfb1z506OHDmy6LETv1/ZbJZcLsfOnTt56qmnlhzvhhtuYNu2bS84x1P1G7/xG1iW1fj6t37rtzBNc8nP4bZt29i5c2fj67a2NrZs2bLoPL797W9zzTXXcNlllzUea25u5m1ve9uqzFUIIVaLbHkSQpxzlrvI3LRp05Ixg4ODL7jP/NixY3R3dy8KRAC2bt3aeH7BI488woc+9CEee+wxyuXyovG5XI5kMtkY//y5tLW10dTUtOixQ4cOsWvXrsZe/edLp9ONOXR1dS3pv7Bly5aTntdq6+vrW/T1wrks5AYcOnQIgJtvvnnZ1ycSCQAqlUoj+FrQ2dnJ4cOHgXpJ4BcTCoWWfGZNTU1L8hS+/vWv89GPfpRnnnmGWq3WeHy5n50NGza86Puequd/72OxGF1dXUt+Dp//mcLS8zh27BjXXHPNknGDg4OrM1khhFglElAIIc4qoVAIqF98LqdcLjfGnC6HDx/mNa95DRdddBF/8Rd/QW9vL4FAgG9+85t8/OMfX5JEfSp83+fWW2/lD/7gD5Z9fvPmzS932qvGMIxlH1fHE9cXzv9f/uVf6OzsXDLONOu/aj7/+c/zjne8Y9ljvNy5nOihhx7ijjvu4NWvfjV/93d/R1dXF5Zlcd999/Gv//qvS8afLMdmLb3YZyqEEOcSCSiEEGeV/v5+oN4Tobe3d9Fz5XKZ0dFRXvva1y553cJd8gVKKYaGhl4wkba/v58HHniAQqGwaJVi//79i+byta99jVqtxle/+tVFd5afv5VnYfyhQ4cYGBhoPD4zM7PkDvrGjRspFovccsstJ53fwjG/973vUSwWF61SHDhw4AVfdzpt3LgRgPb29hc8n9tuu43777//pK/fs2fPi34ep+KLX/wioVCI73znO4sSmO+7775TPsZyKxmn4tChQ9x0002Nr4vFIpOTk9x+++0v+Vj9/f0MDQ0teXy5x4QQ4kySHAohxFnlNa95DYFAgHvvvXfJnf9PfvKTuK7L61//+iWv+/SnP02hUGh8/YUvfIHJycllxy64/fbb8TyPv/mbv1n0+Mc//nE0TWu8duFu8ol3j3O53JIL1FtuuQXLsvjrv/7rRWMXKjad6Bd+4Rd47LHH+M53vrPkufn5eVzXbczRdd1FJWo9z+Ov//qvl7zu5ZaNXanbbruNRCLB//k//wfHcZY8v1Bitquri1tuuWXRfwBXXHEFGzZs4BOf+MSScrgruWNvGAaapi0qJTs8PMxXvvKVUz5GJBIBWLY8by6XY//+/Uu2b0H9Z/TEz+Dee+896c/si7ntttt47LHHeOaZZxqPzc3N8dnPfvYlH0sIIdaSrFAIIc4q7e3t/PEf/zH/3//3//HqV7+aO+64g0gkwqOPPsrnPvc5Xvva1/KmN71pyeuam5u5/vrrecc73sH09DSf+MQnGBwc5Nd//ddP+l5vetObuOmmm/gf/+N/MDw8zKWXXsp3v/td/vM//5P3vve9jTvnr33tawkEArzpTW/iXe96F8VikX/4h3+gvb190cX7Qk+EP/mTP+GNb3wjt99+O08//TTf+ta3aG1tXfTev//7v89Xv/pV3vjGNzbKhZZKJXbv3s0XvvAFhoeHaW1t5U1vehPXXXcdf/iHf8jw8DDbtm3jS1/60rIXs2tVNvbFJBIJ7r33Xt7+9rdzxRVX8Iu/+Iu0tbUxMjLCN77xDa677rolQduJdF3n3nvv5U1vehOXXXYZ73jHO+jq6mL//v3s3bt32aDrhbzhDW/gL/7iL3jd617HL//yL5NOp/nbv/1bBgcH2bVr1ykdIxwOs23bNj7/+c+zefNmmpub2b59O9u3b+fLX/4y73jHO7jvvvsW9e0AsG2b17zmNfzCL/wCBw4c4O/+7u+4/vrrueOOO17SOQD8wR/8AZ/5zGe49dZbec973tMoG9vX18fc3NyKV1GEEGLVnbH6UkII8QI+85nPqFe96lUqGo2qYDCoLrroIvWRj3xEVavVReMWysZ+7nOfUx/4wAdUe3u7CofD6g1veIM6duzYorHPLxurVL3k6fve9z7V3d2tLMtSmzZtUn/+53++qFypUkp99atfVZdccokKhUJq/fr16k//9E/VP//zPy8p3+l5nvrIRz6iurq6VDgcVjfeeKPas2fPkpKsC+/9gQ98QA0ODqpAIKBaW1vVtddeqz72sY8tKj2ayWTU29/+dpVIJFQymVRvf/vb1dNPP33aysY+/vjji8YtfOY/+MEPljx+2223qWQyqUKhkNq4caO655571BNPPPGi81FKqYcffljdeuutKh6Pq2g0qi655BL113/9143n7777bhWNRk/pXP7pn/5Jbdq0qfGzc9999y07DlC/8zu/s+x8Hn30UXXllVeqQCCwqITswudy4me/8NiPfvQj9Ru/8RuqqalJxWIx9ba3vU1lMplFx+3v71dveMMblrzfDTfcsKgkslJKPf3002rnzp0qGAyqnp4e9Sd/8ifqr/7qrxSgpqamlp23EEKcbppSkgEmhDh3/fCHP+Smm27iP/7jP7jzzjvP9HTEBepTn/oU73jHO3j88cd5xStesabv9d73vpf/9//+H8Vi8ZSS1IUQYq1JDoUQQghxlnp+tbNMJsO//Mu/cP3110swIYQ4a0gOhRBCCHGWuuaaa7jxxhvZunUr09PT/NM//RP5fJ4/+qM/OtNTE0KIBgkohBBCiLPU7bffzhe+8AU++clPomkaV1xxBf/0T//Eq1/96jM9NSGEaJAcCiGEEEIIIcSKSQ6FEEIIIYQQYsUkoBBCCCGEEEKsmAQUQgghhBBCiBU75aTsgwcPruU8hBBCCCGEEGeZzZs3v+iYl1TlKRAIEA6HVzwhIYQQQgghxNmvUqlg2/YpjX1JAUU4HKajo2NFkxJCCCGEEEKcG6anp085oJAcCiGEEEIIIcSKSUAhhBBCCCGEWDEJKIQQQgghhBArJgGFEEIIIYQQYsUkoBBCCCGEEEKsmAQUQgghhBBCiBWTgEIIIYQQQgixYhJQCCGEEEIIIVZMAgohhBBCCCHEiklAIYQQQgghhFgxCSiEEEIIIYQQKyYBhRBCCCGEEGLFJKAQQgghhBBCrJgEFEIIIYQQQogVk4BCCCGEEEIIsWISUAghhBBCCCFWTAIKIYQQQgghxIpJQCGEEEIIIYRYMQkohBBCCCGEECsmAYUQQgghhBBixcwzPQEhhHg5fN/H8zyq1Sqe5xEMBjFNE8uyAHBdl3K5jKZp6LpOJBJB07RTPr7jOBSLRSzLwjAMQqEQmqahlKJSqeB5HkopwuFw4z0dx8FxHGzbxjAMwuEwuq6j68/dw1FKUSqV8DwP3/cB0DSNUCiEaZqYpvzzvBpc16VareL7PrquE41GX9L3f6WUUtRqNVzXxXEcwuEwhmFgmuZpeX8hhDid5DeWEOKcVi6XGRoa4oEHHmBkZISbbrqJzZs3c/HFFwMwOjrKfffdRzwep7W1lV/+5V8mGAye8vGHhob4+Mc/zkUXXcSGDRt4wxveQCAQwPd9vvKVrzA5Ocn8/Dy/8Au/wI4dOwA4ePAgTz31FE8++SSdnZ388i//Mi0tLUSj0cZxPc/jvvvuY2xsjLm5OQBisRhvfOMbGRgYYMOGDav4KV24jhw5wne+8x3m5+dpbm7mXe9612kJ1lzX5eGHH+bQoUM8/fTTvPnNb2bjxo1s3rx5zd9bCCFONwkohBCrLpfLMTMzw+joKIFAgO3btxMOhwkEAkvGlkolhoeHmZubw7Zttm7dSjweJx6PLxnrui6jo6PMzc0xOzvLjh070HW9sUJRLBaxbRvP8xqv8TyPcrmMaZpUq1WUUi/pXDzPo1gsUq1WsW170XO1Wo1KpUKlUsF13UWvqdVqlEolyuXyovkAzM7OMjExwdTUFJqmcf311wMQCoXo7u5e9txfrvn5efL5PPv372+siDyfZVn09fXR0tJCc3Pzqs/hTPA8r/E9qlQqp+19lVI4jrPo5/Jkn7sQQpzrJKAQQqy6TCbDrl27+P73v08sFqOrq4u2trZlA4pCocCPf/xjnn32WfL5PHfffTd9fX3LXlQ7jsOePXvYt28fu3bt4rd/+7dpa2sDQNd1DMNA07QzvqVkYQ6GYTTmdKLx8XF++tOfMjMzw8aNG7nrrrvWfM6ZTIajR4/ymc98Btd1l3xOSilisRivec1ruPjii0mlUmfFZ3k2WghKT9yqttxntbDNbrmfASGEOJ9IQCGEWHWRSISOjg4sy6JarXLw4EECgcCyQUK1WuXo0aMUCgU8zyOdTpNKpZY9rud5TExMUK1WaWtro7Ozk+7ubjzPo7u7G9u2icfjhMPhNT7DFzY4OEhXVxe33HILlmXR0tKyaJtNrVajUCjQ29vLunXrTvv8tmzZwrZt29i+fTuhUAiAQ4cOMTExwUMPPcTY2BhHjx7lxhtvJBaLnfb5ne3S6TRTU1N87Wtfo6WlhSuvvJKLLrqIRCLRGGOaJtdccw2XX345d9xxB01NTS9pq50QQpxLJKAQQqy6UCjUuIgul8tkMhlqtdqiMUopbNumUqmQz+dxHAeAfD5PtVpd9ri+7zM3N4fruiSTSUKhUOOC+MT8hDMtHA4TDodpbW1d9nnXdalUKgSDwTNykbkwt76+vsbn5vs+lmXx1FNPMTc3x+HDh7nuuutO+9zOBbZtUywWGRkZoVarsXnz5iXb2nRdJ5lMkkwmz9AshRDi9JGysUKIVZdMJtm0aROhUAjbthkfH6dcLi8Zl8lkmJ6eZnZ2llqthud5TE5Oksvllj2u53kcOXKEWq1Gf3//sluozgXVapVsNrvkIvRMGhgY4IorruDKK68E4Omnnz5pYCeEEEKcSFYohBCrbmE/+YYNG9A0jZGREYrF4pJx2WyWbDYLwIYNG0ilUo2k6+ebmZlhcnIS3/eJx+P09vYSCARwHIf5+Xkef/xxJicn2b59O93d3fT29p7SXEulEseOHWPfvn2k0+nG47qu85rXvOakwc0LmZqaYnR0lGeffZZ4PM7OnTvJ5/PkcjmeeOIJxsfHyWazlMtlcrkcs7OzRKNRmpqaeN3rXodlWfi+z759+5iamuLgwYOLjr9wflu3bl217V0nltW1LAulFNlslmg02tjKUywWeeSRR5ibm2N+fn7R69vb22ltbeX666/HMIzG4/l8ntHRUfbs2YNSijvvvJPDhw8zNDTExMREI5k9FovR0tLCbbfdtuj12WyWI0eOcODAAQzD4M4771z0PNRXu370ox+RTqeJxWJs2bKFjRs3ntJ5z83NcfToUfbv308+n288rut643O+7LLLGufy6KOPMjIywtTUFNVqlXQ6zY9+9CP27NlDOBwmHo9zxRVXMDg4yOHDhxkfH+fAgQNcffXVdHZ20tXVtSifYnp6mgMHDjA8PEypVFr0/vF4nI0bN/LKV75y0ZwzmQyZTIaHH36YtrY2tm/fzrFjx5ifn2dqagqlFIZh0NXVxfr16xvVx4QQYq1IQCGEWDMdHR3k83mGhoYolUo4jrOoDn+hUKBUKmFZFh0dHXR0dLB3717y+Ty1Wg3Lshq9GwqFArOzs/i+TyQSob29HdM08TyPUqnE3r172bdvH7FYjHA4/KIBxUIVnlwux+HDh9m9ezdjY2MEAoFG0u2mTZuWDYReTD6f59ixYzz22GO0t7dz+eWXMz8/z8zMDHv37qVUKlGr1RpVgPL5PKlUis7OTnzfbzx+5MgRjh07xu7du9F1HU3T8DyPubk5KpUKPT09GIaxqis1JyYQ12q1RmWrha1ru3fvJpPJLAm0Wlpa6O7u5tJLLyUSiTTmVK1WmZyc5Mknn8RxHG6++WbGxsbYv38/IyMjja1uCz8D11577aLXl8tljh07xuOPP45lWbz1rW9dElBAvVTv4cOHaWlpoaWl5UUDioU+EdlsluHhYfbt29cIZBe+/9PT09i2zebNmwkGg9i2zbFjxxgZGSGdTjcqiE1MTDAzM0MgEKC5uZkNGzbg+z7pdJoDBw7w4IMP0tnZSTgcpqurq/Ee5XKZqakp9uzZw9GjRxcFFAs9STzP46KLLiIajTbycEqlEul0mkcffZTe3l7i8TgHDx4kk8kwNjaG7/tomsb09DS+77Nx40aCweCyn5sQQqwGCSiEEGtC0zRaW1sbKxATExMcOHCAiy66CNM0UUoxMzNDuVzmoosuor+/n0Qiga7rTE9P85Of/ITLL7+8kcg9Pz9POp3G932am5vZtm0bhmEsyc04VUopdu/ezaFDh/j2t7/Nq171Knbu3MkrXvGKxsXzZz7zGaamplbl89i0aRM7duxg586dPPjgg9x///00NzczMDDAz/3czzVWCAKBAHv37uWpp57ixz/+MR0dHbz3ve+ltbWVQCDA5OQkjzzyCN/97nfxfZ/BwUGuuuqqVakitFCWN5fLoWka7e3tNDc3o5TiS1/6Evv27cO2bW666SZuuOGGRa/927/9W5566ilqtRrXXnstV1999ZLjp9NpPvjBD7J582Y2bdrEXXfdRSQSAeCv/uqvOHz4MJ/61Ke47rrruOqqq172+bzYuT7yyCNks1kKhQK/+qu/SkdHB1BfFZmdneUf/uEfKBaLVCoVbrnlFtrb27n77rsZGxtjZGSEz33uc7S3t3Pddddx6aWXNipjnRiUnkytVuPf/u3fGBkZYXh4mPe9731s2rSp8XylUuFv/uZv2LNnDwcPHuSd73wn69evX3KcQ4cOcezYMa655hquuuoq3vOe95DNZkmn0/zDP/wDpVKJYrHIa1/72kZFNCGEWG0SUAgh1kwikWgEBAvbe0680Jqfn6dUKtHS0kJ7ezuJRAJN06hWq43k6wWlUol8Pk9LSwuJRGJVmpONjIwwPT1NMpmkp6eHDRs2EIvFCAQCmKbZuDN96NChl/1eCysJgUCAYDDYKCdqWVaje7fv+xQKBSYnJzly5Ajd3d309/fT0dFBLBbDMAza29tZt24dvb29jIyMEAgEVuXie3JystEbIxgMMjg4SCgUolKpMDk5yeTkJOVymcsuu4yenp5FSfBKKfr7+6lWq0xMTDAxMUE6nV7Sy8I0Tbq7u1m/fj2bNm0ikUgQDAZRStHb20u5XGZ8fJyZmRny+fyaVpha2NLU3NyMbduLGg8uBHfNzc24rsvk5CS1Wg1d1wmFQo1k+oVxwWCQSCSy6DNZWHlZzkLAMjo6ilKKSy65ZEnjQ8MwGBwcZHR0lJGREcbHxwmFQo2gZ0EsFqOjo4PBwUF6e3sbncA1TWtUQJucnFzSQ0UIIVaTBBRCiDWTSqUad20XAgrf91FKoZQik8mQz+dZv3493d3dJBKJxqrD3NzcoqTlQqHA/Pw8XV1dq1I5RynFkSNHmJ2dpaenh4GBAQYGBoB6FaRgMMg111xDU1PTqgQUp2JhO9PY2BhDQ0O85S1vYePGjTQ1NTVWIBa21BSLRe6///7GljCl1EtapfB9H9/3G0Hb0aNHG6Vjt2zZwo4dOwgGg+RyOXbt2sXU1BSe53Httdcue6f7oosuwrIsvvzlLzM2NsbY2NiiMqpQr/51ySWXsGPHDrZs2bLouYGBATzP4/7772d6epq5ubk1Lf9rGAZbt25d9rlIJIJhGKxbt46ZmZnG1qfVkk6nGRoaYmxsjA0bNnDTTTctKZVsmiaXXHIJvu+ze/duhoeHG9vCTtTc3Mxll13WCEqgXvHMMAw2bdrExMQEk5OTLxjgCCHEyyUBhRBizbS2tlIul9myZUujh4Tv+5TL5ca2DM/z6OjoaHTSvuKKK5ifn2d4eHjRdqbJyUmGh4cbF/kvl1KK+fl5qtUqPT09ja03CzRNY/369Yv2ta+1hc8on8+jaRodHR3Llp61LItoNIqu640chaamplO+AD9w4ACjo6N897vfbQQk5XKZQCDAnXfeyfr16+nr6yMcDpNOpxsdz1OpFF1dXY1SvSdqaWmhWCyiaRrFYpHp6eklQYNpmnR0dCxb4repqYnW1lY0TSOfzzMxMUFnZ+cpnc9a0DSNeDxOsVhcUWL+C8nn80xPT+N5HslkkosuumhJ+eCFgGB6ehqoJ2IvbD870Yk/C8+f/8IKz+zsrAQUQog1JQGFEGJNaJqGZVmEw2Gam5vJ5/ONZGLXdcnlco3E65aWlsY2oNbWVkqlErlcjnK5TLlcbiS/1mo1mpqaXnbPCdd1qVar2LaNUmrZhFVN0wiHw8tePK+VhWDLcRyUUo2Lyedf0E5NTZFOp3Fdt5FcvNC1+VQsbL9auBMP9bvasViMjRs30t7e3lgF8jyPWq1GIBAgGo0SDAaX3W4WjUYb29s8z2ucw4kW8guWSw42TRPLsoD692fhe7PWKpUK8/PzFAqFRRfdrusyPz9PpVJZ9fdc+Hwsy2psl3q+E3/+AoFA4zXLjTtZJ+6Fz3m574UQQqwmCSiEEGsqGAyybt06JiYmmJ2dZWpqCsdxSKfTOI5DIpFg06ZNaJqGbdu0tbUxMTFBJpNplHFdKLlqmiYDAwMnbRh3qkqlErOzs4tyNM4GC5V/bNvG932++MUvrsn7LCRyX3311ctezD6fpmmLyscu93wqlaJSqaxKcvjpNDExwY9+9KNGQ7/nC4fDq7Ii9nwLORrLdY8/UTAYpLW1dVVyhoQQYq3Iv1BCiDVlmmZjBcL3/UZlp/HxcZqbm+ns7Gwkkeq6TltbG/F4HKUUk5OTVCoVCoUC8Ny2mLVM1j1b6LrOLbfcQmtr6wvmjCQSCdra2lbccftUAoCFQOdk5WmVUuTzebLZ7KrcCQ8EAoTD4TUNThzH4aGHHmJ4eJi9e/dy00030d7e3njedV2efPLJRmnj1aaUIpfLveixbdsmm83S09Oz6nMQQojVIgGFEGJNmaZJKpUiFAqhaRq5XI5cLsf09DSJRGLR3V9d10kmk0QiEXRdJ5vNYtt2I6BIJBLEYrEVXzyf+D6GYWAYBr7v43neki1DSilc1z3tqxiGYTR6TiyU010Ius4EXdcxTRPbtimXy7iu25jjiUqlUuP7tPD5Pn/OSqllP2ug8X2A+s/Mws/LwvE0TWu8/sT3X0guP9lxT8b3fZ599lnGx8eZm5tj69atbNu2rfG8bduk02kmJiaWXPQvBL8rpet6I/9lYeudaZqLjrnw81er1Rrbrl7OewohxFqSf52EEGsqEomwbds2+vr6aGpqIp1OMzw8zIEDB+js7FxUW1/Xdbq6uujq6qKtrY3Z2VmOHTvG4cOHCYfD9Pf3r0pzrlgsxrp162hvbycUCjEyMkK5XF40RinF4cOHGR4eftnvd6pM06Szs7OxDWat7o6/FOFwmL6+PmzbZnp6momJiUbgcKLZ2VkmJydRShGLxejs7FzyvXJdl6mpqWWbBc7NzTEzM4NSilAoRDKZbAQzCyVzHcdZ8v6VSoXx8fFGZahTXSHxPI+hoSFqtRrXXHPNSbdznewzWZjfSiQSCTo7O9F1nVwux7PPPrvk58/zPA4cOMDExARQL3DQ1tZ2zm0pE0JcGGSFQgixpjRNwzRNEokEqVSKsbExstksnueRSCQWXcgtbH2Kx+OsW7eOTCZDtVqlXC6zYcOGVbugWrjD3NHRgeM4TE1NMT09TWtrKy0tLVQqFfL5PM8888xpDSgMw6Czs7NR3Wnfvn24rruk63Mul2N+fp65uTlisRiDg4NrdqEZi8XYsmULu3btanR+BhrbsBzHoVwuc+jQIYaHh+np6aGnp4eOjo4l+/5t2+bAgQOEw2EikQhdXV2N7VTDw8OMjY01XrtwwW5ZFqlUCsuyGl2zLctqvP/s7CwPPfTQSwomoP4zEAwGG93STyxRPDs7Szqd5tixY8tWeDoxoHAch3w+/5JWspqbm+nr6yORSFCpVNi7dy9dXV2LtvK5rsvTTz/NxMQE7e3t9Pb2NrpsCyHE2UZWKIQQp0UymaS5uZmjR48yMzPTSOR9fv19qN/B3bBhA7lcjqmpKfL5PNFolK6urlXb9qFpGj09PbS0tDAxMcHo6Cjj4+ONC8xjx47xk5/8hD179qzK+50K0zQbTeu6u7v52c9+xq5du/A8r7H9ynVdZmdnOXDgAI888gi7d+9e0zklEgm2b99OKpXCdV127drF5ORkYy6VSoXZ2Vn27t3LgQMHGBwcZGBggJ6eniUBRa1WY+/evTz77LMcOnSIarXaeP2BAwcYHh5m06ZN9PT00NTUhGEYjaTkYDCI67ocOnSokVDvui7j4+N8+9vfJpPJvKSgStM0kskkhmEwNTXVqD62cMyFLuoLlbZOFIlESKVSjVWTubk5arUaruue0tar9vZ2BgcHaWlpoVqt8vTTTzeCkoX/arUaP/7xjxkfH6evr4+NGzfS19cnKxRCiLOSrFAIIU6LZDJJe3s7mqY1trR0dXU1mnGdKBKJ0NHR0SgjCtDd3c3g4OCqbHmC+gXlK17xCnp6erAsi8OHD/Pkk08SCoVwXRff93nb295GuVzmi1/84svO23gptm/fTl9fH9/+9reZmZnhj/7ojxY9H4/HaWpq4nWve12jd8Na0jSNX/mVX2F0dJRPfvKTTExM8I1vfAOg0Ryvr6+PrVu3csMNN5y0clEikeCNb3wjk5OTPPTQQzzwwAONYKmtrY1rr72W22+/fdHrw+EwXV1dvP71r+fo0aP84Ac/4Nlnn2303Oju7ua3f/u3eeqpp8hms6f8WQQCAX71V3+Vp556in/7t3/jk5/8ZON7HI/HicVivOpVryKfzzM+Pr7k9ZZl8drXvpajR4/yk5/8hH379hGLxVi/fj1XX301mzZtesH3D4VC/Nqv/Rq7d+/mO9/5Dv/4j/+4KFjWNI2NGzcyODjIq171qmUDbyGEOFtIQCGEOC0SiQRdXV1s27YNwzCIxWLE4/FFQcOCUChES0sLmzdvbpSIbW9vX7Zxm67rhEIh+vr6GuNO3DoSDocZHBwkGo0u2ve+sLXK8zw2bdqE67qL7qgbhkFvby+O47B169bGdqgTL1i7urqwLItisbjoIjgSidDe3s6WLVsaDedODISampoYHBwkkUgsqiy0IBqNEgqFGBwcJBwOL+nSnEqlaGtro729/ZT3/i/0A9m2bRv9/f2NFYBT1d7ejmEYDAwMLNsPYf369Y0Vn5Md1zRN2traGkHE/Pw8nuc1mgiuW7duyet1XScQCNDd3Y2maRw5cmTR9qSWlhYGBgYoFotks1mARZ9JNBqlv7+f5uZmEonEokTvzs5O+vv72bx586J5Njc309zcTHt7O8VisbFF60S6rjfyf/L5PFAv8RoKhRoJ6clkknXr1nHxxRfT1ta26BgL75/L5RgcHCSXyy36XE3TZHBwkPXr1y/5GVkIyBd+LpuampasBum6TktLC319fdRqtVMqDyyEECulqVPcdHrw4EGSySQdHR1rPSchxHnoZP/ULHdHeTXHLvf8icdZSZnThYpDL+U9X+j5l3JeJzvmi3kpn+lLPcYLHTOdTrNr1y6++93vUi6Xefvb305fX98LdsF+OZ/H84+xmt//l/tzs9LjLFctayXHle1SQoiXYnp6mlwut+Smy3JkhUIIcVq81P3tqzX25T6/ktetxnuu9sXfaiWzr5aXeqy1+D6t5XHX8jhn4udHCCFeiCRlCyGEEEIIIVZMAgohhBBCCCHEismWJyGEEGsmEonQ39/Pq1/9amzbpquri2g0eqanJYQQYhVJQCGEEGLNxGIxNm3a9KJlVIUQQpy7ZMuTEEIIIYQQYsUkoBBCCCGEEEKsmAQUQgghhBBCiBWTgEIIIYQQQgixYhJQCCGEEEIIIVZMAgohhBBCCCHEiklAIYQQQgghhFgxCSiEEEIIIYQQKyYBhRBCCCGEEGLFJKAQQgghhBBCrJgEFEIIIYQQQogVk4BCCCGEEEIIsWISUAghhBBCCCFWTAIKIYQQQgghxIpJQCGEEEIIIYRYMQkohBBCCCGEECsmAYUQQgghhBBixSSgEEIIIYQQQqyYBBRCCCGEEEKIFTNPx5uUSiU++9nPUqlUGo+1t7fzmte8hng8TjgcBmD//v389Kc/pVAo4LouAJdddhnr16+np6cHwzDwfZ9vfetbTE9PUywWUUoRCoW48cYbaW1tpaWl5XSckhBCCCGEEILTEFDUajUKhQL79++nVqthGAbVapW5uTl27NiBZVmEQiEqlQpTU1Ps27ePSqWC53k4jkMikSAQCNDd3Y3v+1SrVYaGhhgfH6dareK6LsFgkI0bN2KapgQUQgghhBBCnEZrHlDs37+f0dFR/st/+S+0t7ezbt06Hn74YdLpNPfffz+33nor4XCYBx98kFwux+DgIK973esIBAIMDQ3x9NNP8/3vf59LL72Uqakp9uzZQzKZZMOGDdx6662MjIwwMTHB97//fSqVChs3blzrUxJCCCGEEEIct+YBRWtrK5ZlEY/HG9ubUqkUlUqFyclJlFJ4nsfo6CiBQIDOzk6i0SjhcJi+vj727duH4zjk83nS6TTHjh2ju7ub1tZWQqEQ7e3tAPi+T6VSIZfLEYvFMAxjrU9NCCGEEEKIC96aBxTr1q1j3bp1ja+VUsRiMaLRKJqmAeB5HiMjI/T29tLV1YVlWQSDQdatW0c0GkUpxfz8PFNTU4yMjHDRRRfR2toKQFNTE7quo+s6tVqNbDZLKBSSgEIIIYQQQojT4LRXeVJKMTIyQjqdpqenh2g02nguEAiQTCYXBQPRaJRkMkmhUKBarQIQj8cXvU7XdZqamjBNk1wuh+d5p++EhBBCCCGEuICd1oCiVquRz+fJZDJUq1V6e3uXBAaGYTRWLgAMw8AwDDzPw/f9xjhdf27qmqZhmvXFloXqUEIIIYQQQoi1d1rKxi7I5XIcO3aMY8eOkUwmufbaawEoFAqncxpCCCGEEEKIVXJaAgrf95mbm2P37t08/PDD3HDDDfT09AAsWo2wbZtCodBItAYol8sUCgWi0SjBYLDx2Ik9LXzfJ5/P09zcTDweX7R6sVKu61KpVKhWqziO87KPJ4QQQgghxGoJBoMEg0EikciqXPu+HGseUHieh23bTExMMDk5yezsLBs2bKC/v78xRtM0AoEAvu9TLBbxfR/f93Ech1qthuM4hMNhQqEQlmVRqVQaAcXCmGq1iqZpq/ahKqVwXZdarYZt2y/7eEIIIYQQQqyWhVSBs8GaBxQL1Zn+/u//nq1bt/Ke97yHjo6ORWMMw2D9+vXYts3BgwfZtGkTAIcOHWJ+fh5d1+nq6mqUmp2amkLTNLZt28bExATj4+N4nkc0GqW7u3vRqsdKmaZJKpUimUy+7GMJIYQQQgix2lbjmnc1rHlAMTExwdDQEOVymbGxMR599FF2797dSKLesmULbW1tbN++nUOHDrFnzx6++93vYpoms7OzRCIRLr30UkzTpL29nUsvvZQHH3yQmZkZqtUq8/PzVKtVduzYQV9f36ot+Sx8g86Wb5QQQgghhBBnozUPKCYnJzl06BC6rjM5Ocnk5OSi59/85jdz1VVXcckllzA7O8vw8DDDw8ON59/ylrdw5ZVXYpomHR0dtLa28rWvfY3h4WH27NkDQCKR4N3vfvei3AshhBBCCCHE2tOUUupUBh48eJBkMrlku9KLKRaLVKtVbNtmubda6J5tmialUolcLnfS5zVNQynFzMzMokRpXddpbm7GNM2zZi+ZEEIIIYQQ56rp6WlyuRybN29+0bFrvkIRi8WIxWKrNlbTNFmJEEIIIYQQ4ixxZmtMCSGEEEIIIc5pElAIIYQQQgghVkwCCiGEEEIIIcSKSUAhhBBCCCGEWDEJKIQQQgghhBArJgGFEEIIIYQQYsUkoBBCCCGEEEKsmAQUQgghhBBCiBWTgEIIIYQQQgixYhJQCCGEEEIIIVbMPNMTEEIIIYQQ4uXwfIXjKaqOh+srPB90DXRNIxLQMXUNy5T76GtFAgohhBBCCHFOmy+7HJmp8OjhHBPzNTJFh3jIJBUxuWlLE+uagmxsD5/paZ63JKAQQgghhBDnJF8p0nmb4UyVx48WGM3WyFdcqq5CVV0cT/HEsTyZcpigpdMaswhZslKx2k5LQKGUQimF7/v4vo+u62ia1vhzged5eJ636LUL4xbGKqVwXRel1KJxhmE0xgohhBBCiPOfr2A8a3NwqsxPjuYXPVdzFTXX4akRh0LNoyMeIBY0JKBYA6cloPB9n+npaZ566il++MMf8qpXvYr+/n5e8YpXLBr36KOP8pWvfGXRY9u3b2dgYIBrr70Wy7JQSvHZz36W0dFR5ufnAYhEIrzlLW+hq6uLrq6u03FKQgghhBDiDPM8xSNDOUaz1RccN5Wrcf+zc3QkA6QiskFnta15iFYul8lmswwNDTEzM9N4rFKpNMZ4nsfY2Bjz8/NomkZrayvt7e0kk0my2SxHjhzB8zxKpRKTk5MUi0UAurq6SCaTWJbF8PAwmUxmrU9HCCGEEEKcJRQwV3IoVL0XHFdzFLNFB8f1T8/ELjBrHqKl02nGxsb49re/TXNzM9dee+2ibU4AtVqNH/7wh2iaxvXXX88NN9xAOBxmamqKL3zhCzz++OP8/M//PFNTU+zatYt4PM7AwACvf/3rGR4eZmxsjG9+85sYhsH27dvX+pSEEEIIIcRZQClFtuJSrJ0soNAAhe35OGWF66uTjBMvx5oHFO3t7cTjcZqbm5mbm2usUpxI0zSi0Siu6y55LhqNkkql0DSNbDbLgQMH2L59O52dnY3jm6aJYRiUy2XS6TRNTU1YlrXWpyaEEEIIIU4z2/UZzdY4NlvlWKZKqeZSX6vQTvIKDcvQiB0vHytW35oHFJFIhEgkQktLC4cPH142oNB1nVQqRaFQoFQqMTs7SyAQIJPJEI1G6erqQtd1qtUqc3NzRCIR4vE4UA84PM/DNE08z6NQKJBMJtf6tIQQQgghxGniK4XvQ8XxKNY8jmWq7J8qcThdwXF9Tlx3WC5kCJoaLTELy5CAYi2cFVkpgUCAnTt38thjj/Hwww/z/e9/H8dxUEpxzz338Iu/+IuLVhzi8TixWKzxtaZpNDU1YRgGuVxOErOFEEIIIc4jNVeRLbs8NpTjWKbCnvESrq9QCl5sE5MGdCeDvGZrMy0x2cGyFs6KgEIpRalUIp/Pk8vl2LRpE47jsHfvXkZHRzlw4ABbt2496es1TWvkZTy/nKwQQgghhDg3eb7iyEyF6bzN0EyF0UyNbNnB9p673jN0jUjAoCliUqh61Fyfsu0TMDRCls5ge5gNrWH6W0OELOMMns3566wIKHzfZ25ujlwuR61W45JLLsF1XQ4dOsTo6CimaTI4OHjSYGGhzwWwJOF7pRaOJwGKEEIIIcTp5R9feXA8xf6pEofSFZ46Vlw0RgM0DUKmRlPYYKA1xMR8jXzVxXV9ogGNZNjgit4YPc1BupP11QnfP38qPS1c967W9e9KnRUBhW3b/OAHPyAcDvP2t7+dSy+9lFAoxJVXXskDDzzA4cOH2bdvH1NTUwAUCoVG6Vg4nuGfzdLS0kIymcQwXn706bouxWKRcrmMbdsv+3hCCCGEEOLF2R4cy/mM5GC8oEgXParO0iCgPQqdMY0d7RrxgEc0WMZtrudaeL6BroOu+UT1LH5B41j5/MqfCIfDhMNh4vG4BBTw3ApFa2sr0WiUUChELBYjFouhaRqFQgHP87Asi1gsRqlUolAoAPWeFrlcDtd1MQyDeDy+Kt2yNU3DMAypFiWEEEIIscY8X1FzfeZKLrmqx6FZl6kipEuKsvNcnkTY0glaOm1xi+64QVdcZ31zfZXiQmuAbVnWqlzzroazJqDI5XIEg0HK5fKipahisUgulyMajdLa2kpPTw+zs7OYZn3q6XSa0dFRPM8jEonQ1ta2KlGaaZrE4/FGNSkhhBBCCLE2yrZPOl/j0HSe4UyVA5POssnWrTGL7lSQm7c20ZkI0Bw9Ky5lz6gzvToBpyGgGB0dZWpqiscee4z5+Xny+TxQr+z0+OOP89rXvpZNmzZx7bXXMjIywne/+10ef/zxRsBgmiavfOUr6erqoqOjg56eHv71X/+V/fv3s2/fPsrlMpqmcdNNN7Fhw4ZV/VDPhm+QEEIIIcT5yPMVjufzs9Ei49kaz06WmSs5lO3FZWDDAZ22mMWmjgjbuqK0xS1a4xYhU5drtbPEmgcUtm1TLBaZmJhYlItQrVYZHx+nXC5jGAbr16+nUChw4MABpqenG+N27NjBwMAAsVgMy7JIpVKEw2EymQzj4+NAvRfFxo0baWlpWevTEUIIIYQQL4OvFFXHp2L7FGsuQ+nK8b4S5UXjLEMjYOq0xy3WNQW5qDPCls4wqYhsRz/baOoUyxgdPHiQZDJJR0fHS3oD3/dRSuF5y7dENwwDXddRSuH7/pLMe03T0HUdXa9HoUopXNddUn3JNM1F5WOFEEIIIcTZp1zzeGqkyJ6JEgemSsyX3UZPiRMNtofZ3B7h5q1NxMMGIVNH12QHyekyPT1NLpdj8+bNLzp2zVcoFpJFXqzy0kLg8GI0TZNEaSGEEEKIc0jN9SlUXUbnaswUHPZOlJjO2+SrHq6nGlucUhGTRMhgoC1Mb1OInqYgibBB0NQxdAkkzlaSySKEEEIIIVbdwm4Sz6+vSkzlbJ48VmAkU+XobHVRnoSmgaFptMfrSdc3bUnRErNke9M5QgIKIYQQQgix6hyvnivx6FCOY3NV9oyXqDp+fXvTCeOSYZPuVJDLemNs7YrQErMIW7IicS6RgEIIIYQQQqwa11Nkyw6ZosNs0eFQusJU3iZbdheNiwUNEmGDgdYwnckgG1pDtMcDxEIvv0GxOL0koBBCCCGEEC/bwhanmuuza6zIrrEi+yZKVBy1bE+JnqYg27qj3LqtmWjQQBYkzl0SUAghhBBCiJelXPOYKTrsmywzlatxcLpMruJScxcHE93JAK0xi0t6Y3QlA7THA4QtHYklzm0SUAghhBBCiJfMVwrfh7LtkS27DM9W2T9ZYiJnMzlfawQShg6WoRO2dHqag6xLBblkXZRE2CQWkkvR84F8F4UQQgghxEtWc3yKNY/v75/nWKbKsxMlfFXvJ7EQTGhAS9SirznE1RsSbO4Mkwpb6DqyKnEekYBCCCGEEEKcMtv1Gc5UGc/WGMvWODxTaTSnO1F73KIjEWD7uhhtcYt1qSCxoIlpSChxvpGAQgghhBBCvCClFL6qb3Mq1TwOTJXZO15i/1QJ139unKaBDhiGRncqwLbuKDdsThENSuWm85kEFEIIIYQQ4gUVqh6j2RpPHSswlq0xMlel5viLggmAgdYw3akA1w2maI6aJMMm4YB+ZiYtThsJKIQQQgghxBKup3A8n3Sh3k/icLrC0dkKMwWHQtVrjAtbOpGATnPUYnNHhK5UgHWpIOGATsiSYOJCIAGFEEIIIYRYRClFxfHIVTy+vz/L6FyVg9OVJeM0oCVm0t8S5tqNSTa0hkiE5fLyQiPfcSGEEEII0VCxPX42WuTwTIUjs1VmizZVe/HeJlPX6G8Jsb4lxBX9MVIRi6aIbG+6UJ2WgEIpheu6lMtlisUi0WiUQCBAOBxG057L9HccB9u2KRQKeF59Kc0wDAzDoKWlBV3XUUqRzWaxbbsxRtd1kskklmVhWdbpOCUhhBBCiPOG5yts16ds++QrLofSFQ6lyxyZqS4aFzQ1AqZOMmzS3xJic0eEzR0RwgFJur6QnZaAwvd9pqameOyxx/jmN7/JjTfeyODgINddd92icdPT0xw4cIBvfOMbZDIZAJLJJB0dHbzvfe8jEong+z6f/exnOXr0aGNMNBrl7W9/O729vfT09JyOUxJCCCGEOG/kKy4H02V+cjjPaLZGumDj+0vHDXZEWN8S4qYtTcRCBmFLR5cqsBe8NQ8ostks8/PzPPnkk2SzWTZv3kwgEMA/4afU8zzS6TQHDx7kySef5OqrryYUCgEQDAaJxWJYlkUmk2FychLLstiwYQM7d+5kfn6eSqXCvn370HVdAgohhBBCiFNQdTzKts/hmQrTeZuh6Qpj2Rr5qot3QjDRFDFJRUz6mkNs6gjTHg+QCBsEDB1DognBaQgoCoUCU1NT7Nmzh1QqxdatW5eM8TyPyclJjhw5wrPPPsvP//zPs2HDhiXj5ubm2L9/P5FIhLa2Nl73utcxMjLC2NgYX//612lubsb3fTRNW7SVSgghhBBC1LehQ32LU7HqMVt0eHK4wPh8jaOzi7c36RoYukZb3KK/JcTVAwl6UkHiIUnBFYut+U9EV1cX7e3tbNmyhfHxcYaGhpaM8TyPoaEh4vE4b37zm0mlUssea2Zmhp/97Gdce+219Pb2AtDd3U0kEsEwDEqlEhMTE7S3txMIBNbytIQQQgghzjm+UhRrHo8M5Tg0XWEoXaHi+Ljec12uNQ0iAYPB9jCbOyJctT5OLGgQsnRMWZEQy1jzgGIhUToUCpHNZpcdo5SiVCph2zamafKzn/2McDgMQCKRIBaL0d3djed5VKtVwuEwkUikcfxgMEgoFEIpRblcXrSdSgghhBDiQldz68nWM0WHuaLDoXSFsfka2bK7aFwybBIPGfQ1h+hrCbK+JUxLzCJoSvUmcXJnxZqV7/sUi0VGR0cZGxvje9/7XuO5bdu2sXHjRt761rc2HotEIo2AA+pVnhKJBIZhUCgUViWgWFgSFEIIIYQ41xWrHs9OlPjxkXrS9fzzAokFA60hBtrCvGZbEyFTxzLqKxJyXXR2O9Nb/c+KgGLBxo0bufrqq+nt7SUYDALw4IMPsmvXLq655hoKhcJpm4vneZTLZSqVCo7jnLb3FUIIIYRYDRUXijYcmlPMln1Gsy7ZskvVWXzjtS2i0RSG/qRGT9ImFXLJpqvouoZscDp7hUIhgsEg0WhUAgqoR1WGYZBIJOjv72fbtm1Eo1EAnnzySUqlEsVikVqtBtRXNE5chVBKLepbsRqUUvi+j+u6uO7yUbwQQgghxNlEKYWnoFTzmCv7ZMo++2YU2SrMlp9bZdA1CFo6YVOnt9mgPaox2KTRFKr3mlC+t6jSkzj7eJ531mzzP2sCikQigWmai5raQT2pu1AoUCwWqVTqLd8LhQKlUqkxxvd95ubmaG1tJZVKrUpQYZomyWSSZDIpy3xCCCGEOCfYrk++6vHEviwHpysMzVRQCk68ktE1SEZMtnZGuLg7yhX9cekncQ4606sSJzprAopwOIzrumSzWTzPw3EcisUi6XSa2dlZOjo6qFQqjI2NMT8/TywWY9OmTWSzWdLpNL7vEwwGaWpqwjRf/mmd+E06m75hQgghhBDPV6p5TOZsjs5WmCnYHJiqMFdy8J93T3RdKkBr3OLi7igdiQDt8UC9epMhSddi5dY8oFjYnuS6LrZtN/IRHMehWq1iWRaaphGNRsnlcszPz1Mul9E0jXQ6TSaToVAo0N7eTrVapbOzk1wuRyAQoFqtkk6nmZiYwDAMIpEIyWRyrU9JCCGEEOKMU0rhq3pPiVzF5VC6zONH6z0lSrXndnvoWr0UrKFp9LWEGGird7q2pDGdWCWaOsX9PAcPHiSZTNLR0fGS3mBoaIhjx47x7W9/m3K5jG3bQL0yUygU4pd+6Zd45StfSaVS4ac//Snf+c53qFareJ6H53lceeWVbN68mVe+8pWNsrAf//jHmZiYIBKJ4LouoVCIX/zFX2TdunV0d3e/9E9BCCGEEOIcM1dymCnYPDKUYypvM5KpUXN9XF+xcHWnAYPtYXqbg1zRF6crFSQeqveU0JBdGOLkpqenyeVybN68+UXHrvkKRSgUIpVKsX79+mWTm+PxOJqmEYlE6OzsZOvWreTz+UYexcDAAL29vei6jmEYmKbJli1baG5ubhwjHA7T1dVFPB5f69MRQgghhDhjXE/heD7TeYfJXI2xbI3hTJX5skvx+KqERj2xOhE2SUVMLu6O0pUMsK4pSCJsSk8JserWfIVCCCGEEEK8PAuXa2XbJ1t2eWDfHIfTFY7OVpeMNXRoi1ls7YqyoyfKjnUxwoHVqYIpLhxn1QqFEEIIIYR4eXIVj0PTFfZMFJmct5nO25Rtb8m4izoj9DQFuXpDgkTYIBY0CMiKhFhjElBcQJRro9waqpIHz0X5LppugmGihRNoZhDNDJzpaQohhBCC57Y3lWoe6YLDULrMgaky0zkb54TyTUFTI2DqRAIG61tDbGgNsaUzIgnX4rSRgOIC4s+N4U4dpPbkl/Dnp/DzaYxEG3qyk8Ar/gtm5yaM9o1neppCCCGEoJ50PT5f4/v7s0znbaZy9pIysJoGWzoirG8Lce3GFE0Rk7ClI7nW4nSSgOICoFwbLzOCe/RxnCM/xc+M4tcK4Nv45SzKc7D3fAdVzqKUwmjpk5UKIYQQ4gyoOj5lu769aXy+xuhclbFsvQzsQjChaxAPmbQnLLqSQS7ujtAas0hF6gnXuqxMiNNMAooLgefgTR/CGX4K58BDoI63addA1cqoWhm/MAu6gRZJYaQ6QQIKIYQQ4rTxlcLzFYWqR6bk8OSxAiPHg4kTGRpYpk5b3GJLR73T9aaOCCFL8iTEmSMBxQVA1YrYT34ZLzP6XDABcOKyqfLxRndTK2Ux+y7HCMZO+zyFEEKIC1Wm6PD0SIEnjxWYmLcp2z6u/9zvbI169abL++IMtIa5ZmOCkGUQMDUsQ1YkxJklAcUFQHkefm4aVSu84Di/VoJcGvyl/UKEEEIIsboqtkfJ9pjOO6TzNgemykzmbLLlxb+Hm6MmsaBJR6JeCnZdKkhT1JKka3HWkIDiQuB7ePkZcKv1Wxwn6zxil/F9H3wPpZR0zxRCCCFW2Yntv7Jll2OZKt/bl2WmYJMpLb2hp2uwsS3CQFuIazcmiIdMKQMrzjoSUFwIDAM90Y4qZVC10snH6QaaGUD5LvguSjclqBBCCCFWUaHqka+4PDVSYCxbYzRbY67oYHvPBRqGDu3xAH3N9RKwF3VFSYQNEiETQ7Y3ibOQBBQXAE03MZq68XznhQMKABR+bgotEEGPt6F0HU2TOyFCCCHESiwsSLi+T7nmM5mrMVOob2+ayttM553GWE2DSKDeT6K/NczGthCb2iP0NQdlVUKc1SSguABowSjBK99Mbe8D+LnpRVWeFm1/8j1UrUjle/di9l9O+Pq70MIJMINnYtpCCCHEeUEBs0WHR4Zy9aTrbA1fLf4VbGj1BnVXr08w2B7mVRuTmLqGptV/XQtxNpOA4kJgBjA6N2NVi2i6iTvyDKpaqK9WGIH6LRG3BtT/dfNzU7hju6k+8SUCm67DaO6BcFK2PwkhhBAvQa7skik5HEpXmCnYDKUrZEsuJ+xuQgN6m0O0xS02toXobwnRErOwDA1dfu+Kc4QEFBcAzbAwWteDUuihGKo0h5ebRinQgxHQdPxytl7dyffrzzsV/HIOI9aKZoXQgzHZ/iSEEEK8CF8plALXV2RKDkdmqjx8KEem6JCvPpd0rWugaxqmobGhtZ4r8aqBJCFLx5Q8CXGOkYDiAqI396AnOzHXX1nf3uR7aJqOssvYBx7CGXoU98hP64PtKio7RuXh/x9GSy/hm96FnupCi7ed2ZMQQgghzmJzRYdMyeGhQzkm5muMz9vUHB/vhOpOpq6xviXEYEeYizojDLSFCVs6QUuX7U3inHRaAgrf96lUKszOzjI+Pk5HRwfxeJy2trYl22iUUqTTaQqFAul0mq6uLlKpFMlkEl3XUUpx4MABisUitm3XT8I02bBhA9FolEgkcjpO6ZykGRYYFlogvOhx5VQx121D1YpgV3CnDoBrg+/hFzOAwhl6DGPdxZhoaNEmNN04MychhBBCnEWUUvgKKo7PbMFmOFMlnbc5lqmSLbuUah5Q311sGRqtMYtUxGRrV5SepiDrmoLEQwaWITsAxLlrzQMKpRS+75PJZHj00Uf5+te/zs0338ymTZtoa1t6t1spxbPPPsuhQ4f44Q9/yG233cbll19OPB5H0zR83+db3/oWR44cIZPJABCNRrnnnnvo6+uTgGIFNCuEteEV6NEmjJZ+vO/+Jao4W3/SqeBnJ6g89CmCO25D0w3MvstQVkhyKoQQQlzQFnpKOJ5ituDw8KEcPxsrMpmzl4w1dI1YyOTS3hiDbRFesSGOKY3pxHlizQOKdDrNzMwMDz74IL7vs3PnTuLx+Au+5vDhw0xNTbFx40YSiUTj8cnJSY4cOUI8Hueqq67isssuY3p6mmw2y09+8hNqtRq9vb1rfUrnLT3VhRWKE77h13DH92Lv+S54Tr0qlOdgDz2Gmz5C+Lq3o7etx+zYdKanLIQQQpwx6YLDeLbGUyMFZosOk/M2hdri5nQasH1dlHVNQS7tjdEcsYgGDSRNQpxP1jyg8DwPx3FwXZdwOExra+tJx1arVYrFIp7nYRgGoVAIy7Iaz+fzeYaHhwmHw3R0dLBjxw5aWlqYnJzkmWeeYX5+Htu2MU0TXZelw5dKC0TADGH2XgKahju5H5WbRtmles5FYQavlMUd34upfPx4G1owWt9KJYQQQlwAHM/H9RSFmsdYtsbhmQr7p8rkyi4Vp16WXQOClk7Q1IgEDAZaw/S1BNnSEcHUNXRZmRDnmTUPKLq6uujs7GTHjh0MDw+ze/fuk449evQoP/nJT9i6dSu1Wo1nnnlm0fOzs7Ps2rWLW265hZ6eHgC6u7uJRqMYhkGpVGJycpLOzk6CQemdsCKahtG1GT3VidGxieojn8Yd3Y0q1beX4btUH/0MRudmQtUC5qZrMVLdZ3bOQgghxGkyU3CYztt8b1+WqbxNOm/jq8VjTENjU3uEizrDjdWJgCkJ1+L8teYBhaZpaJqGrusn3XPveR7T09Ok02mKxSJtbW2NhOsTKaVQShEOhwmHw43j67pONBpF13VKpRK+76/pOZ3P6t8jDQJhjOZ1BLbehN7cg737u6hqAZwKKB8/N42993soNPzOTZjrtqPJqpAQQojzjFIK21UUqi5HM1WG0hWm8zZj2Rpl22sEE4YOYcugrzlIeyLA9nVR2mIWrXELy9Clp4Q4r50VZWM9z2N8fJy5uTk8z6O5uXnZgGJBMBgkEAg0vtZ1nUgkgq7rVCqVRpLUy7EQvCz8/YKjmRBpRt9wFWayC2dkNwpQbq2eU1HO4hz5CUSSKLeG0bYRZQZQ0qdCCCHEOWaha7XnP9e9WqNemQmgWPWYyts8M1Jk32SJdMFZ9Hpdg6Ch0RTW2dwRYkNrmB3rYjQKNykfzztNJyMuGAs36hdu3p9JZ0VAUavVeOCBB+jp6eHWW28lkUgwOzt7Rufkui7FYpFSqfSCwc15z/dQXgQu+xUCo48TGH0cc3603gQPcA48iD2yi/npMZzO7bjtF53hCQshhBCnTikYyStmSopnZ31KNrg+JIMasYBGLAjH5n3KtqJo+zje4puMGrCtFbrjsL1dETALmHaR0dGMbHESayoSiRAKhUgkEhJQ1Go1isUimUwGTdOIx+Ok02ny+TzZbJbh4WHK5TJNTU3k83kAHMfBcZ67O6CUolqtopQiGAyuyoeqaRqmaRIMBjGMC7zngvLRQkFMw8aKBPEPPQSlOVQlD04VVBam9mMYATQziNExiGYGXvy4QgghxBlUcXxKVY+jcxWmiz7TeUXFBd+Hig1hE8KWxmxJYXuwEEvoGqQiJomwSXPEZEurQWtEoyspIYQ4fQKBAKZ5xi/lgbMgoCgUCszOzpLNZpmYmGDXrl2Lnh8eHiYSiRCLxZiamgKgXC5TqVSA5/pcFAoFPM8jFoutSoUn0zSJx+MvWuL2gtLTj3J2UrKLeJMH8CrPAqC5NYITz2BQw9RrhLdejhZpOuPRshBCCLGcha3MUzmbKbvKrpkas8XFe5KKNhRsxcImKO2E9QbT0BhoDbO1K8qO3hhtMVMa04kL2hkPKBKJBKFQiPe///2LkqlnZmb4wQ9+QF9fH52dnVx55ZUcPnyYcrlMOp3GNE02b97M9PQ0U1NTeJ5HJBKho6NjUalZsYp0AwIhwte+DXdiP/bTX8WdOogqzwPgZUZQ5Xk0M4CxbjvB7bee2fkKIYQQJ+F4iqOzVX6wP0ux+sIJDhoQMDSSYZOLuiL0NAW5uDtKPGQSCxkYUgZWXODWPKCoVqvYtk0ul2Nqaor5+fnGcyMjI7S0tBCLxdi2bdui142OjvLEE0/Q2dlJX18fLS0tFItFenp6GisVIyMjTExMMDs7SyqVIplMNqo/iTWgaWiaidE2AAr8mSP4lTy+79UrQNVK+HYFd3Q3aDpe91b0WDOaFQK057LbhBBCiNNAKYUCbFfh+QrHq+dAuL6iVPMYzVaZmK9he8tXhzzxt1bY0lnfGmJTe4Te5iC9zSEJJIQ4bs0DiuHhYQ4fPsyXv/zlRp4D1HMUvvSlL/Frv/Zr3HDDDad0rIGBAfr6+vjwhz/M8PAw3/72t1FKEY/Hefe7301HR8danoo4gd62gdDNv4WWaMc99ky9q7byQfm4Iz/DmxvDSx8mfP3dmOu2gRk601MWQghxgfEVeL5iZK7KXMlhdK7GZM5mruRwLFPF89WSHhIn09sc4ndu7kFH7o8J8XxrHlC0tbVhWRZ33nkn3jI10wYGBpZ9XSqV4sYbb6S5uZlEItHoY2EYBq973esaCdpQT0rp7OwkEoms2XmIxTRNA83A7LsMPdKEquTxZofx5ycAhaoV8dKHqe25Hy8zgrX1JrRAGM2UhoNCCCFWz3OrED7Zskuh4lG2PTIlh2LVI1/1yFVcqo5PoepRrHlUnXq3a8WJ0cRyUUL9sWhAJxLQMTQkP1CIZax5QNHS0kJLSwsbN258Sa+Lx+NcddVVSx7XdZ2dO3eu1vTEy2R2bsZPdOBlx1DKwy/OgmuDU8Wfn8QZegw/N4nRsx091gq6CdrJmxwKIYQQy1m49K/3iQJf1VcXlFK4nqJke4xna0znbeZKLscyVTJFh5mi84LH1U449snEQwbR4AVe8VGIF3DGk7LFuU8LxQld9fMYHYM4XRdhP/Glek4F4M9PoEpzlL/6fwhsuxnrolejp7rBkMR5IYQQL1264JAtuYxkKsyVXGYK9a7VFcfH9VVjG5PrKfwXaUwbtuqBQrbscJI0Ckwdrt2YZGO75GgKcTISUIiXTdN1CMUwmvtQnos/fQhvbgw/M1JvjGdX8bJjuON7wLSwNl2PHkmhhWJneupCCCHOQr5SFKseNden6vgUa/W/l2o+2bJDoeoxU7ApVD1yZZfZooPtnTx4CFs6lqkRDRiEAzpBUycWNIgEDCIBnbFsjXzFI12wsV0fX0HQrFd1aolZ9LeEaItLfyUhTkYCCrFqjNZ+9KZ14Dm4R5+klhmpP6E8VDGDc/Bh3NE96LE2aBtAD0YB2Y8qhBAXKnWSFQTPV0znbWaLDtN5m6OzzyVVe7560S1KJ9KoN6FLRUz6WkJ0JQO0RC0GWsOEjgcae8dLDM9WefDQPPNlF8f1SYYNtnRGuKw3ztauKBHZ8iTESUlAIVaXbmCtvxI90Y4WbcLe/e36SgWgnBrKz1B58B8x111M8PI70FvXo4UTZ3jSQgghzoSS7TNfdpnK1ShUveP5D/Vk6kLNw/YU9vFVCsdTLxhMWIZGKmLSErVIhA06k0FSYZOmqEkyZBIwNYJWfXXCMjTCloGu1QOODa1hupIBtnZHjm+Vqh8vEjCIhwyCljStE+KFSEAhVpWmaWixFkCD/ire1EFwbfzCDPg+uDbe9GHQdIy2jZiBSD1JOxiVlQohhDgPKaUawYDjqUYfCNv1yVfr1Zgm52vkKi6T8zVmiy7Fqodzknquhga6rhE0dQxdwzI0AoZGKKDTGgvQGrNIRQzWpUKkovUAI2zpL9gzIhYyiIUMWmVbkxArIgGFWBNatAlz4GrCoQTu1EEq9/8VqlYCzwHfxZvYT3nyAMFr3461/gqsTdeCJsvJQghxPkoXHObLDqPZGpPzNpmSw9GZCjW3vvKgANSLV1sCiIVMEmGDDa0hWmMWHYkA/S1hYsH6agIcL/aqLV8IVgix+iSgEGtC0zSUAj3VhWmYBK/6L7iju/Em9qFqRVAKlMI98lNUIY0WCKM392AkO8/01IUQQqyA49X7POQrLkXbY67oUqrV+0DMlx0qx/tAlGoeFcen7Pj4J2ksp0E9afp4kNAcNYkEDJoiJolw/e/JsEHY0okEDBJhE8vQ6luYZLVbiNNOAgqxZjRNQ4s2oQUjBC6+BZTCL8yg3Fp9pUIpvMl9+PkpjPaNmLqBHm0CIyC/EIQQ4izln9AHov5n/e81x2c6bzOdr69AHJutMldySRdsqo5/0o7UGqDroKGh66BrGoau0RKzaIqatMct+ppDNEUtepqCRIMGQVNyGoQ4m0hAIdaeEcBoGyD4ircSGLyGyvfvrZeVzacBUOUc1Yc+hTmxD2vgKgKX3C4lZYUQ4iyVK7sUqh4jc88FDGPZGqVaffWh0QfCr/eB8P2Tb2UKmRqxoEFPc4hUxGRdKkh7wiIVMWmOWpi61ggwdI3Gn0KIs4sEFGLNaZoGhoUeSaE0A3Pjq9Cih3CGn6w3wPMcVK2INzuMZpgYLetRTd0YzT1neupCCHFBUkpRcXxqrk/F9ikt9IGwfXJll2LVZaZY7weRq9T7QNQc/6S9ICyjnjwdDRpELJ2gVe8DET2+pak1FiAaNGiJ1su7Ljwnq9VCnBskoBCnjRaIgBUmdPUv4I48gyrN4U4PoSo5APz0YezZY2iBCGb/5fWeFsh+WCGEWCsn6wPhK8iWXeaKDlO5GsOZWr0PRLZG+Xg515ciGjBIhA36mkN0JgO0xgIMtIWIBev5D0KIc5v8v1icfoEIRs8Owre9j9oTX8Sd2Ic3eQBQ4HvYBx+qb4kqzRHY9hqM44GFEEKI1VVzfYpVj+mCQ6HiMZ2vkSk55Cse8xUX2/WxXVXvA+H71ByFd5IgRNcgEtBpiVokwyZdqSCJsElzpN5tOmjphEydgKlhGfqLlnIVQpw7TktAoZTCcRyKxSL5fJ54PE4wGCQaXdx7IJ/PMzc3t+i1qVSKSCSCZVnHKwcpZmZmqNVqeJ4HgK7rNDc3EwgECASkhvTZrL79yUSLpNDCCcx1F4Pv4+emUHYZXBtVmMVDQwvFMNoG0AwTLd4uKxVCCLECSik8HzxV7/3gHu8DUXMVZdsjV3aZzNnkKx6TuRqzRZtcxaVU85fNfdA0MHQIGDqmsdAHoh4oJMPm8T4QFuua6o3lWmL1bUyWIYnUQpyvTktA4fs+U1NTPPbYY3z961/n5ptvZnBwkOuvv37RuB//+Md8+tOfXvTYW9/6Vq666iq6u7sxDAPf9/nc5z7HkSNHyGQyAMRiMe666y56e3vp7e09HackVoGm6QSueDPmputQKNzxvfjpwwCowgzOvh+iyjnMddsI3/q7YMiCmhBCrES+6pKvuBzL1JjK18gUHY7OVinVPIo17yX1gQiZOpGATn9LvQ9EZ7LeByIZNmmLW4D0gRDiQrPmV2hzc3Nks1l++tOfksvl2LFjB6FQaNG+TcdxOHjwIAA33HADHR0dOI7D4cOHKRQK7Nmzh46ODrLZLGNjY4RCIbZs2cKGDRvIZrOUSiX27NmDpmkSUJwrjq82aJqGHk4QuOT16LEWnFAcb+JZcG1A4c2Nojwb/fH/wOzZgdGxCUwpKyuEEM/n+YqKXe/7UKrVO1CXavW+ENmyS8Wud6YuH+8Dka+6ON7yfSAAAqZW7/EQMo/3gdBpilgkIybRgE4ibJ7QB8IgYOrSB0KIC9SaBxSlUomZmRmGhoZIJpNs2rRpyRjP8xgbGyMYDHL11VezadMmyuUypmkyNTXF0aNH8X2fbDbLwYMHiUQitLW1cdtttzE6Osr4+Dhf+9rXaG9vx/M8dF2Xf9DOIVogTGDjK8H3UJ6DnxlB+XnwXVRhBq9awN77AOgmeqIdLdqE0g00TZbPhRAXHqXqnaV9f3FPCMdTZMsO03mHuZLDsUyVuZLDdN5mvuzhnixyoJ7/oGvPNYYz9HpjuVTEpD0RpK85SFPEpKcpSFPEIna8I7UQQsBpCCi6urpob29n27ZtjI6ONlYiThQMBrnhhhvqjdA0DdM0cV2Xrq4ucrkcxWIRgJmZGX72s5+xc+dO+vr6AOju7iYajaLrOsVikYmJCTo6OiSX4hxkbbgSs3srejCGO74X5+BD9SecKu7YHlRpHufQo4Rv/k30ZCdaJHlmJyyEEGdAxfEp2x4jmRpz5XrAMJG1yVc9MiW7EWi4vmr8/WSxhKFrBE2tke/Q0xykPR6gOWrRlQzU+0Do9QDjxH4QQghxojUPKEzTxDRNgsEgoVBo2TGapi15zvM8crkchmEQi8Uaj9m2TTgcbow3TRPLsgiHw2iaRrlcxvf9tT0psSY0Mwi6gdmzAwwTv5ipr1bUiuA5+MVZlPJxDv+k3lm7dztaIIomuRVCiPOMOr7iYLs+ZdunZHvHKzL5FGsupZrHTMGhUPOYLzvMFV0qjk+x5i17PF0DU9eIhQzClkHQqjeUCwcM4kGDlphV7wMRs0iFTWIhg1TYRJfoQQhxCs66K7GF3Ipqtcro6CiRSITm5mZ0/bntLeFwmHA43Pha13Xi8XhjlUICinOXpptYm65Bb+pGM4NUn/hSPaAAVLWAqhap/uTzWOuvQIu3YjSvAz1af61scxNCnGNO1gdCKSjbPtmyw+R8jZG5eh+I4UyN+bJD2X5pv+dMQyMaMOhvCR/vA2GyvjVMU8SkPS4r+kKIl+esCygARkZGGBkZYXh4mFtuuYWLL74Y0zwrpyrWiJ7sIHDxLWAGcCf2YT/9VVA+oFDFDM7Rx/HzaYKveCtG1xaMlv4zPWUhhHjJPL/eC2I6b5OvukznbObKLrmKy0zeoeb62J5P1amXe60eL/u6HI36KkRT1CQRNuhOBUmGTZqjFh2JAGFLJ2TpBEwdy9AIWTqmrEAIIVbBWXWV7nkejuMwMjLC9PQ0zc3NtLS00NLSsmTciasQSilc1wVYtcDD931838fzvJPeQRJrLJjEbV6P57h48U60ag7dLoFno4pzuHYZY3xvvca6FUOZQTCsMz1rIcQFxPPB9qHiKFy//rWuga5D1NIwdQgY9c7TSoHjHx+nwPGo94JwFJO5GvmKy+R8jUypHlBkis5Jcx80wDLA0MDUn/svbGm0RDWSEZ11SZ1UWKc1ZtCe0AmaCyv9x39/+h6+D1X3dHxSQojVpus6uq5jGMYZ36VxVgUUpVKJ2dlZvva1rxGPx/ngBz+4aKvTgmKx2EjUBhoVoNra2kgmkxjGy68+4Xke+XyeYrFIrVZ72ccTK5VAS27FuuwXCR59mODo49Q7artQLVJ97HP40VZKV7wNr6kPL955picshLiA5GownlfsSvvMlhW5KkQDGvEAXNml0x6F7rhGza1fuE+WfOYqkKsppgpQtOt/X+gDccIfJ1VfiYDOGCSDGi1h6IhqxIMaHVHQNB+w0bDrxyvCdPEFDymEOAdFo1HC4TCpVEoCCqgHBPPz8xw4cIAnnniC7du3093dvaT8ayQSafSjiEQibN68mUwmQzqdxvd9QqEQzc3Nq7JKoet6o0P3QkducWZovoeeDKMno2id/TjPfg+/WkB5DigPrZonNPR99PVXoYdMjI5BWakQQqwpX8HEfI2pXI1npsvMlBQVt77ysLBasSvt1y/4ozrFqkfNU5QcRdUF24OSDY7PC65ChCydZNigKWoRCRi0RC0SYYNo0CBmQcCEkAkRUyNgQET+6RPigmFZFqZpnvFgAk5DQOF5XqM6U6VSadztr1arFItFQqEQmqYxNzfH0NAQP/7xj/nVX/1V1q9fT6lUAp6rAhWJROjs7CSXy2FZFsVikenpaSYnJ7Esi0gkQiKRWJV5G4axJPlbnEEtrfixOF5zN974XlAKvzIPSqG5FQITz2AlUgRaO7DC29BCUTQJKoQQa8T1FEPzBWZqPkNziyMCx69vbRqeVwRNnUQJ5iv1qk0nU+//sLgXhKlrJMMmHQmLnuYQTRGTvuYQ7YkAqUj91/eZv4wQQgjQ1CkmCBw8eJBkMklHR8dLeoNDhw4xPDzMN77xDcrlciPXQdd1AoEAv/Irv8Kll17Kv/7rv3L06FGGh4eJRCIYhtHYuhSLxfi1X/s1mpqaCIVC/Pmf/znj4+MEg0E8zyMcDnPXXXfR3d1NZ6dseTlfKd8Dz8Gb2Id77GmqT3wRvzgH7vEtaWYALRgjfN1dGN1bsQauOrMTFkKctyq2x199b4yJeZtMyVlmRP1Xq0Y9SHiBWAKAdakAqYhFb1OQtrhFU9SkvyVMwNSwjveCWOgDYWigHU+mloBCCLFWpqenyeVybN68+UXHrvkKRTQapa2tjR07duA4S//RXdiitGHDBpLJZKNh3YnC4TCxWIxwOEwkEuHSSy+lu7t70fOdnZ2NfhXi/KTpBkrT0JvWYdgVrE3X4Qw/hZ9PQ60Iro3yc7gjT6PcGlo4gdHcgxaMnumpCyHOUQtdqQtVj5rjk6+6lG2ffMVlpuBQsl94S6yCRjCha/Xu06Hj1ZbiIYOgqRMJGLTGLGJBg9a4RSJU7wPRHDWPN5KTsEEIcXZb8xUKIdaCXyujSnNUfvSPuGO78WeGOTGV0WjfiHXxLQQvvR29qQeQPhVCiBe23K9Dpeqdpo/MVJgpOgylq0zM10gX7ONVmBSnuk4QsnT6mkN0xC1aYxYb2sK0xCy6U8FGJ2ohhDhbnFUrFEKsBc0KosXbCL3qF/FmX0X1kc/g56ZQpTkAvOw46umvgl3G6NpKYPutoL386l9CiPOXr6BY85gtOsyVHEbnamTLDtN5m1LNw3YVFcfHdn0cTx0PJl5YvZSrzh2XtdHXHCIWMrAMrdEHwjJ0DF22Lgkhzm0SUIhzUn37k47e0g+BMGbPdlzDwPdsVK0EThV/fhJ3Yh/K9zDXbUOLNqGH4md66kKIs4BSCttVOL7Cdn1qrk/NUcyVHWYLDpmSw7FMlWzJYSpv4y1pTK0aQcALhRXhgE5HPMBge5j+lhCWoclqqRDivCMBhThnaZoGVgijuY/I6/8b9s++gf3s93COPN5I1HaPPoE3dRBVKRDccRv6pmvP8KyFEGcDX8H4fI3ZosPoXJUjM1UyJYeJ+RrqlPpBaAQMDf94s7rlR8C6VIhbtjbRnghgGRJICCHOTxJQiHOapmn1Tc66gdl7CVo4Ab6HNzeGPzcKgLIruGO70UwLvzhLYNtr0AKReo1GIcR5zfcVrq/IFB2KNY+ZgsN82SVfdZkpOlRsj0LVI1/xqDr+SXtCxIIG4YBOWzxAKmwSDxl0JgKUbY/pgsNQukyu4lKq+YRMjXBAZ2tXlIHWMOtbw4QtXVYmhBDnLQkoxLnv+C9po20Deqobb3I/aDp+fho8BzwHf3YYF1DlHGb/5fXkRysEyPYDIc4XSqnjSdT1RGrPV7ieouooxudrZIoOR2aqTOZqzBTqAcZy8UO9HwQYWr3Ckq5Dc9QkFTEZaIvQlQzQFrfY0BoiX/E4Oluh5nj18q64xII6ibDJJT0x1jUF6UwGTvtnIYQQp5MEFOL8YgYIXXcX7uR+9GQH9sGHUfk0AN7cKF5+Gt+pYq2/kuAr3lpfqTDk/wZCnA9cH+aK9ZyHdN7m8EyFTMlhPFvD8xW+As9XeErh+yff0tQWs2iPBxhoC9Eat+hJhWiOWQTNerM5XdcwNA1Dh6aISbwnxkVdUfzj77EQkARMHUNuWAghLgByJSXOK5qmQTCKnurG3HAVfmkeL3AUf/Yo+F49WXv2GK4VQk+2Y/Zcgh5rASskKxVCnEOUUuQrHhXHp1jzKNbq/SHqW5occmWXqbxd385UXb5XhGVoBE2dWMggfrw/RCJs1lcjwiYdiQCJsElL1CIaNDCXyYHQNAjoGgH5bSqEuIDJP4HivGSkutCTneB7uKO7qM2N1AMKpfCzY6hKDj87RuiGX8Psvhg9GUIpJUGFEGeZk7VK8hRM5mxmijbHMlWOztYrMqULy3WtXkrTIBI0aIla9DUHGWgN0RYPsKk9jGnoywYPQgghlicBhTivWYOvwmgfQDMtnKNP4U3uA0DZZbzZEWqPfha3fYDQNb+MFmutJ3ULIc4anq+ouj4T8zbzZZfRuSqzRYdsqZ5Ybbv152uOj3uyjGqgNWYRDxn0NgVpjQdojpp0p4IETZ2gqRGy6v0hAqYu9RqEEOIlkoBCnLc0TUOLNqMZFmbPJahyvr4ykZ+ur1b4FbzZYXBreBP70NsH0XQDAmE0TT/T0xfiguMrheMqbK/eOK7q+FQdn0LVZfx4QDEyV2W2UG88Z3tLAwgNsMyFxnEGlq4RNDU6kgGSYZPe5hBtcYvmqEVHIoCpS/QghBAvlwQU4vwXjGFd/Br0pm7Mnu2Uv/d3qEoOAFWex60UKH/z/xK4/I0Ett6Ese5iMKUqixCnm+spJnI1JnM2UzmbQ9Nl5kouE7laI4P6hXpDaNTzIroSATqSAbZ0RGmL17c0xcNmow+EhBBCCLG6JKAQ5716XoSGnupCMwIEL78Dd+oA7tHH6z0slI9vl3GO/BQ/P0Pw6p9HT3VhpLrO9NSFOC/VS7pCumBTrHpkivXO1MWqx0zRplTzKdseuYpL1fE5SRoFsaBBNKDTHLNojVnEggZdySDRoE4kYJCKmIStetK1qddLwAohhFh9ElCIC4YebUaFElibrwcriDe5H2WXwfPAs/GmDuFlRjF6tmMqHz3WDLqFpsv2JyFWaqE3hLfwp69wfIXtKsayNTIFh5G5KiNzVXIVl1xl+YpMulZPpDaOBwaGrtEStWiOmvQ2B+lrCdEatRhoD0vgIIQQp5kEFOLCohuYfZeiN3VjdF9E9ZHP4E0fgloJUOBUqPzg7zF7dhC84uewNrwCLdZypmctxDnLdhX5aj33IVN0OTJbYTpvM1NwcFwfT9W7WS/0iTiZrmSQ5qjJhtYQnckg7fEAHQkLy9QxTgg0JJQQQojT77QEFL7vUy6XmZ6eZmRkhO7ubhKJBJ2dnYvKdE5NTXHs2DGq1Sq+7wPQ09NDS0sLqVQKXddRSrF3717y+Ty1Wq1+EqbJ5s2biUajxGKx03FK4hylaRqYAbRICqNtAGvgavRIEufok+DW6p21ayX8uVGcocfQglGMlj705l4pKSvEi/B8RaHqUXE8yrZPruxSsj3mSg6ZokOh6jGdd8hV6hWaltvKZBoakYBOxDJIhg1CAYNY0KA9HiAeMmiPW6QiFsmwQSJsYkhStRBCnHFrHlAopfB9n0wmw09/+lO+/vWvc/PNN7Np0yY6OzsbYwCGhob48pe/TCaTwXEclFLcdtttXHbZZSQSCTRNw/d97r//fo4ePUomkwEgGo1y11130dfXJwGFOCV6MIoWiBC87I246a14syP4xdl6QAH42XHs7DiaYaH6LiXQtA6FLkGFECzfG0IBjqeYyttM5mpM5WwOTpXJll1mi6fWG8LQIGzpdCaCdCUDbOoI0xYPsL413OhSLYQQ4uyz5gHF1NQU6XSaH/3oRwDceOONJBKLa/07jsPjjz9OOp1mYGCAX/qlX8I0TUZHRxkfH+ehhx5i8+bNTE1NMTQ0RCKR4JWvfCWveMUrmJqaIpPJ8Nhjj1GtVunr61vrUxLnET3RhhWIoL3uv+Ls/yHOkcfx58frZWUBe/8PcScPoJwaZt+lmB2DZ3jGQpx5rl8PHkYyFebLLpM5m8mcTaHqki279bKvrqLi+LjLlHaFeqWllphFMmzSmQzQnQqSipisSwUImjqWoRMO6Me7WWtILCGEEGev05ZDYVkWwWCQpqamJc95nsfo6Ciu69La2srAwAChUIhQKMTExASZTIZarUY2m2VkZIRIJEJHRwebN28mHo8Ti8V44oknGtugLMtCl0Ra8SLq25+CEDYwu7ag8mlUtYhjl1DVIrg1VDGD7zm4Y7vRQjG0YAw90VbvVyHEy6CUwnEcXNelVqvh+z5KKQzDwLKsxn9n+t8y/3gS9ULjuKrjU7brVZhGMlWyZZfJXI3JeZtizaPi+MseJ2hqWIZOyNIbDeQ6kwFSxwOKdakgyYhJdzIgK4FCCHGOWfOAorOzk87OTnbs2MHRo0fZtWvXkjGO4/Dss8/S09PDlVdeSTAYJBwOs2XLFp555hnGx8eZmpriyJEj7Nmzh1tvvZV169YB0NXVRTQaxTAMSqUSk5OTdHV1EQwG1/rUxPlCN9BiLQQueT3Wpusof+cv8NKH8dKHAVCVPPbTX8ObG8OcOkj4+nvQwvEzPGlxPshkMszNzXH06FEqlQqe5xGPx2lra6Orq4vOzs4zHlDUXJ/ZosvwbIWZosOh6XI9qbrogHrhvhALNGBdKkhr3GJzR5SuZD2huiVmYeiSSC2EEOe6NQ8oFu40vdgdJ6UUpmkSjUbR9ef2qofDYaLRKJVKhVqthlKKcDhMOBxuHFfXdWKxWCOoWEjoFuJULPysKdNCC8cJXvlm3LG92M9+Dy8zAnYZUPiZEVynip1ow+jYjLX+ijM7cXHOqlQqlEolhoeHyefzVCoVXNdFKUW5XGZmZoZyuYxhGI1V2NNx1971FNMFm1zZJVdxG30i5kouhapLxfHJVVzK9vK9IbTjORDJsEkybNIet4iHTFpiVqMnRCpiEgkYRAJ6ozKTEEKIc9tZVTbWNE1CodCiO3KBQIBQKEStVsN13cZjlmU1xmiaRjgcRtM0qtXqsgmDQrwYTTcgEMba+Cq0QARvbhRVyeF7DngOqjiLV57HHvoxludidm4GK/Tc9ie5MBKnqFarMT8/z/T0NOVyedFzjuOQy+UoFAq0traiadqqF5tQSqGgUarV9xWegprjM56tJ1RP520Oz1QoVF+4N4Suaeg6GJqGaWg0RUzaEwE64gE2todojVn0NocxdCR4EEKI89RZFVAIcbYwurcSef37qf3433DHduMcfARQ4Lu4Q4/hzx7DnzpI6Lq7MNo2gCY5O+LUzc3NMTQ01Ch9vRzf9zly5AjlcrlREW+1VF2fiu1zeKZCpugwMldjNFslX/Go2F4jyHB9ddIu1RrQnQrSHLPobQrS3xKkOWLRnQoeX3k43htC1zAkjhBCiPPaWRVQuK67qAcFgG3bVKtVgsEgpmk2HnOc58oQKqWoVCoopQiFQquyNcDzPBzHwXEcPG/5u3Pi/OfE+1CtDsyMoZcz6LVCfbWiNIc7dZDqwUfRstM4bZtAN1ESWIgXoZSiUChQLpdfdHtmtVplfn6eo0ePYppmI2HbMAwM49QKA3gKqi6UHbA9RdGGku1TrPlM5x2KNZfZokum5FCxfbxlusvpGkQsCBoQDUDI1Aib0B5XxIIeLWGHhA4h5eLXHGTTqRBCrL2F3wfBYPCMF7M4awIKTdNwXbeRA7GwbWlhr3E4HG4kWlcqFSqVCvBcn4tisYjneY0cjJfL931KpRLFYvEF7yKK81x8A7qZIpKbxZzaXQ8oAFUt4E4VsKtV3Ob1lC7/JZQVQZlSDECcnFIKz/OYm5ujWq2+6HjXdZmbm+Ppp58mEokQCASIxWIEg8FFN09O/EWiGv9TV3EVcxXFZBHmq4rRHORqioL94vPVqAcTpg6tEY1USKM3Dq1RjeawRtj00TUfcMAB24F08SV9JEIIIVYoGo0SDocJBM58dbyzIqAwDIO+vj40TWNoaIgNGzagaRojIyPkcjkMw6Cjo4NSqUR/fz/T09MYhtHoTTE5OdkIJrq6uhblV7ycOSUSCWKxmCR5X+A0vwt9XTfe8ON4Iz/D3vsAOPWAVi9MEXBKBH72b1gX3YC5/gq0WItsgRJLzMzMkM/nGR0dbdwQORW+72PbNq7rous68/PzjRWKpqYmwuEwiUSCSDSGZgSYLikypXozudG5GqWaR77qY/v1/hG2B95J/knTNWiKWLTEzOO5DyGaIvWyrgEDTF0jYICl14MM6Q0hhBBnjmEYiwoZnUlrHlCUy2VqtRqZTIaxsbFGd2vXdTl06BAdHR0Eg0F6e3uZmZlhcnKSw4cPEwgEGBkZQdM02tvbCYfDNDc309/fz+joKJ7ncejQoUZju9bWVlKp1KqVi9V1/YyXaxRnkWgct5pDUx7e5H78wgyU58GzoZrHmDuCme3DSrVixJJoVhjNDJzpWYsz6Pl9JsrlMsVikVKp1Cgw8VKO5Xneou2Xuq5jWRae56HrOgoNDIdcUSNb9JgtukwXXIp2fZvTckKmjmlohCydoKkRNHXaEgFaohatMZO+5hCpiEVnUn6WhRBCnJymTrEk0sGDB0kmk3R0dLykN9i3bx+HDx/mS1/6UqPsa+PNNY1f//Vf54YbbgDgO9/5Dp/+9KcXRVpvfetbueqqq1i3bh26ruN5Hh/60Ic4evRoY1w8Hud3f/d36ejooKWl5SXNT4hTpZQC16a2+9u4R5/A/tk3Fj2vhZNo8VYir/+vGM19GE3rztBMxdlAKcXk5CTZbJbh4WHK5fKi3K8Xs1ASe2Fb56nw0Sj6IUp+kKIKkfWiVJRFSQXhed0eNGCwLUxr3GJDa4j+lhDNUYv2RABNWzz6bLj7JYQQ4vSanp4ml8uxefPmFx17WhrbRSIRYrHYssnNmzdvbvyyuvjii3nnO9+56PkNGzbQ3NzcWNLRdZ2f+7mfo1AoNMZYlkVXV1ejN4UQa0HTNJRhYvVdihaIgG7gHHoUVZwFQNllKMxQe/yLmOsuJnDRjejJTrSA/FxeKBbyuYrFIrlcrtFPYqFp3QLTNDEtC80K43oe5VIJAw9QeJiEo3GisQQbulvxfJ/JTJ58oZ7P5dZK6MrDWCb1WVOKkGZj6B4RVSOplXHQqan6exlmgHg8RioeoSkRpS0eJBLQiYdM4iGDoKWjaxJAiAuLUop8Pk+pVGJ2dhbHcfB9n2AwSDweJ5lMkkgkGoVhhBBLrfn/O5qammhqaqK/v/9Fx/b29tLb2/uCY3Rd5+qrr16t6Qnxkmi6gdG6Ho4nX3szR/Dscr35neegKg7O0GMou4Le3IsVjIJhgm7KRdp5SinVWEVwXZd8Pk8mkyGdTjM3N7fkRoppmgQCQQKhMDUjime7VJSLiYOOj6MFscw4erSV5s5eXM9n1p3FdyxqbhFbeZjKOT5eodU3O9X/1CCAR0BbeM8KvtJw0dECccxghLZkiK42na7WILFwEMN47maNEBca3/fxfZ9cLkc2m+XYsWNUq9VGXmZrayu+7xMOhxs3NuXfciGWWvMtT0Kcj5Tv1XtSDD+NO7GPyo8+Ca4D6vhdY8NCM4OEXv2rmL07MPsvR5NE7fOS67pUKhUmJiaYm5tjYmIC13UXVasDGqX9NmzYgBdIUNbjfOWZWbIld8mWJu14DlckYKAUVBwP368HLigfS/MIaC4pvURYd0joFeJalYC2NDejMQVNA0073ohOxzB0WpqbiUajNDU1kUqliEQiRCIRuWASF4xCocD8/Dy7d+9uVItc+P/tQqBtmiY7duygqamp0WxSiAvBWbXlSYjzkaYbKE1Hb+7FBKzNr8ZLH8bPjoNbq69WeA7usadQtRJ6JIUWa0WPJM/01MUqWFiRyOfzlMtlMpkM8/PzlEolbNteFEiYpkksFiOZTBKJRGhra2O0oHMs61JyNGq+Djwv2PQV+ArX8+odrRVwfB0CdHyl///Z+7MgObL0vhf8HV9j33MDkEhsBaCqgK6la2t2V3ezF1Iih7cvRVILdSn1w9iYzCQzmUw2Jr2MpCc96EEmk0maa6Zruja6lDQaaiElURRFdjeb7GZ1V1d17VVYCnvuGRn76tuZB8/jiEwkCigUlgRwfmZhGRnu4eEeEe5xvvN9/++PFCZG2iLlSErpiFoqIGOGRIGH53mJh08YhlsBiwQZG9WFUUgYxIOp8XjMeDym2+3iui7ZbBbHcbBtm3Q6jW3bd63ZhUazV5BS4nkenU6HtbU1hsPhDc0SVDOEKIqo1+PSVqXT1EGFRrMdHVBoNHeIEAKzsh8jVyFtpxm/9V/wh22i/vVMhX/uB4Rr5zEK01gLzyLSheS5mocPFSio8qaVlRU2Nze5du3aTZ+TSqWYm5tjfn6eYrGIZVmc7bR4+9omQ++TxdaBlOwmpkYYRMIkUyhSytnsq6U5WLbJu+D3WnS7HTqdDvV6PQkYdqPXi00jGo0GEJeU5nI58vk8+XyeqampJMC4Gfq7rNmL3Kr4QnlN1et1rl69iufd3JhFNVgIw5BDhw4lrTp3Q58PmscVXfKk0XxGZBSBPyTcuERYv8Toh/8XUWcDOWzHK5g2Rn4K+/iXsA59HufEqwg79WB3WnNHBEGQlDbV63X6/T6+798wGMlmsxSLRfbv35/cdxwHKQyuNTx++HGb751t4oc3u/xef9w2DHIpk9mCQzlrcbCSTnwiMo6JbQpc28AxBaYBMgySFrNBEOB5Hr1ej06nw3A4pNVqMRwObxpkqMGScuWONR8OhUKBdDpNqVQim80mRnt6AKXZi0RRxGg0YjweMxqN6PV6eJ5Hv99nOBzieR6+7yfLbzUUEkJg2za5XC4xE1PnhLpvWZbWWGgeKXTJk0ZzHxGGAW4Wo3IA4aQw9z2FsC8RrH8Mflz+FLWWCdbOg+ViTR9F5CoYmdKD3nXNbaCM5VQJUb1ep9ls0mg0tpVIKLO5VCpFsVhM6q1tN0Vk2GwOQvpewPn1AWtdDz9xl9tt8BE/ZhqQT5scm8owW7QpZWwOVlJUcxaVrL17RybL3Pav7/ukUikcx2E4HGJZFsPhkMFgQBAESeChdB8qGPF9n9FolNSRe55HOp1ONCOZTIZ0Oo1lWZimmfw1TVMPqDT3nMlmCCpjOPn9jaIo8cGaDCgGg0HSwvnTmNaqEinlcp9KpfA8j1QqRSaTwfM8bNvGtu3kPLAsKwnOQWcvNI82OkOh0dwlYsGsRPbq+Jd+wuhH/1+i+mXkuH99Jcsl9eKvYC08j/PU1x7czmpum+FwyPr6OteuXaPZbNLr9XadzSwWi+TzeY4dO0Y+nyeXywHQHoacWR3w7mKXxcaYy5sjom3Pv/kgo5g2Ob0/y//jK/tvutatBim77avKqtTrdXq9Ho1Gg2azmWgubgchBOVyORF1q/vFYlEPnDT3HCllEiz0+/0kA9ftdun1eoxGoxv0TPcax3EolUoUCgWy2SyVraYHuVxOZy40DyU6Q6HRPACEEEhApPNY+58m/TP/G+N3fpdw41Is1gYIffwLPyYatJCBh33kJYxc5YHut+ZG1EBlY2MjqbPu9/s3mHO6rks6naZarVKtVslmsxQKBXq+YGl1wMX6iEbf52pjTKPn0x+HRFtP3znM2TnUMAV87kCO4zOZWI59h4OR3Z6nSjOq1SrFYpFqtcp4PMb3fTqdDqPRiOFwSK/Xw/f9XQ35pJTJe9Lv99nY2MC27aQcJJVKkcvlkhlcPaDSfBpUBkIFv8PhMMmajUYjfN9PhNSqtC8Mw6SUabJb081wHCcp8btVMO04TrI/N0O1jR6NRliWxfr6epK1yOVyOI6TlEg5jpMEGhrNo4AOKDSau4gQAuw0ZvkARmGacOMSRCFRtw5hLNYO1y8gAw9h2pi1BYSTAjutf1geMGoAE4Yhw+GQTqfDyspK0lZyEmOrrasKIPbt20ehVMFNpfHDiEZnzMWNIW9e6bLZD9jsbR+EGEJgGfEAO5KSMJJJoGEIsAxByjY4OpVmvnz3Oyyp/bdte9vjQRCwubmZzPIKIZLgQrXBnXTuVoLvfj/OwgkhkkAil8tRq9XIZrNJ2Ycqn1LBhQ4yNOo7tdstCALG4zGDwYBut5uULvX7fUajEYPB4Jbb3/ldUzfDMMhkMkmpngoWgiC4oW2saZpks1mklAyHw23nweT+Kt3GaDS6YR9KpRLpdDrJZKpywZ3ng/a60Dys6JInjeZeIGU8A+2PCBuLDL/3vxOunrueqRAGmDbOEz+Duf9pUl/6dqzF0DwwhsMhw+GQS5cu0Ww2aTabySzn5GXStm2q1SozMzMcPHgwbqkqDD5aHXKtMeaNy13aw4DOKCDYChR2XmUXKi5Hp9OUMzbtYcB7iz3awwA/lFSyFsdnMjy9P8ez8zkyroll3J/Bxc7BkRpk9ft9ms0m/X6fRqNBr9f7xMHc5OBI3crlMplMhmq1mgQcmUxGG+o95ozH46RUaTJgUEH9JwUct8JxHFzXJZPJUCgUEufrbDaL67qkUqk4sywla2trtFotLl++nGQrMpkMtVqNubk5pqensSwLz/PodrsMBoOkVXS/36fb7X6iJmO3oMY0TTKZTFI2qMTdal81mgeNLnnSaB40QsQlLE4aozCFc+LL+HaKwLSIGosQhRCMCTcuIWWEf/4HmFNHMEtzcbChZ6fuOZMlFZ1Oh1arRa/XY3NzMxFtTpLNZkmlUlQqFXL5PLl8kfpQMOz6rHU8rm6O2Oj5bHR9hkGIF2zNcgKmIajmbApb3Zpmiw5zRZesazD0Igppk6EXEUaSrGsyW3TYX0qRso37FkwA22ZGlZB0MrOgOtwMh8Mkc6E65YzH422GfpOZDCEEnU6H8XiciLtd103KQFzXxXXdxPNCz84+OiihtOd5BEGQlNCpMiV1myxpUuV3N+tENonqRuY4DpZlJSVGlmUlzQgcxyGVSmHbNqlUKvmuqdI/KSXFYjHJ2KnvseM45PN5isUiqVRqW6ZNbUc1a1DXDPUdV9kV1fhgtyBIZUNU2ZbjOLRaraSDmtpPtd/q+PT5odmL6IBCo7nHGJkS7vPfAicNpoXXWQdvCEBYv0zY3UCGAanP/68Y+RpYLkipfzTuIeqHPQxD+v0+165dY3l5mU6nc9PnlEolqtUqR48eQxomfih4/VKHK5sj3rjSYeRLgujGWVPDiNu6HqmlOVRN8YWjRbKuQcq+PjP/4uHC3T/Iu4SaRc1kMsljqjPUxsYGvV4v6XqlBoU7B05Kb6EyHAolXi2Xy1QqlWQgdTP0ObH3uFWmQA2slbag0+kkoul2u50M3u8EIURixqgG/aohgiq9u53vjBCCYrFIsVhkbm7uE9edLBVUJneqA9R4PKbVatHpdJKsnsp87oYSlqv3Z/I1LMuiXC4nvjCTGYxPOg6N5kGhS540mvtENGgje5uMXv/3BCtnCa+9Gy8QBsLNYM6ewJx9gtQX/jeMbAnhZD55g5o7pt1u02g0WFxcZDAYJH4SO0WZU1NT5PN55ubmMN0sobA5Vw9YbMbdmjrDkFEQbRNbAziWIGWbnNqfZV/R4cm5LIWUScoxybsmhogDjYeVyeyOatmpWs222+0keGi1WklJy24oQexk69lUKkU2myWbzSZ154VC4RPNxDQPDpWBmPR5UO1alXO8EkyrdVWr19sRTquslSpTUsGtynCpFq3q+6GyCOr+/Rhk79R9qGNUGRnP82i324zHY3q9XhJQ3ey8gDg4mGw7q84RJfBOpVIUCoWkfbN6LzSau4kuedJo9iBGpoh00lj7T4EE2Vkn6jUg9JCjHuHmVWTgEa6cQVbmMavzYDpaW3GXUGUWo9GIVqtFvV5nc3OT8Xi8LZBQJQaO41AoVUhn84ROgbZn0BlLLtRHLDXHXG2MCCcmVk0jFlMXUhaFtEU5a/HEdJrZgsPhWgrLEA91EDGJKo3aWecdhmESFCjRqWrrqWaiVeA2eZssL7NtO5nVDYKAdDrNeDzGdd2k5GNyEKlnZe8tk9m8nT4Pk4HkpM+DMk7s9XpJOc/NUN8lVX6kBtEq0FSlP6o8Tg2g1WN7QcC8W6mgQh2/bduJf0UqlUoCrkkTysn39mYdpUzT3OaDkU6nyWQySWcpdVPv36QPhkZzL9EZCo3mPpL8OK+dxzv7x3hv/jZRa/n6CsLAqC5gH32F1Mu/hlGc1a7ad4l6vU6r1eLjjz9mMBjc0IkF4lKDWq3G1NQUMzMzhE6ezUHEm1d6fLDUZ63j3dDuVVFKm5SzNl84WuDYVIZjM+kbWsE+6IHPvWa3nxNlhNdoNJL2sqrs5dOgfC5qtRqFQoFcLkehUNBZi3uMmnnfWbI0HA6TWfdPmmm/FZZl4bpu4jqtRNOqI5Kanf8k9vJ5dbMhluoYpTpYNRoNBoMB7XY7CaY/DUpnoUq3MpkMlUolCTg0mjvhoc1QnD9/nrfeeiuZ1QDYt28f09PTPPfcc9i2TRRF/OhHP2JjY4O1tTUg7uTw+c9/nunpaR3waPY06ofPKMzgHH8VvCHh6jn8839KnLaIkN0Ngis/ZRSMcZ75s5iVeUR+ak//aO5FVN3+cDhM3K37/T69Xm9bRsIwDFzXjbsQZXM4+Srd0GJxJeJau0lnFFLv+bSHwQ3BRCljUUybLFRTLFRT1LI20wWHQtrCeAw/r92+o8o9vFarUSwWqVQqSRmMEmqrEqmbeV4ASfnMYDDAcZyk9EOVwaj7urf/p0fV8qvgT4mih8Nhog3YKapWQutbGSEqQX86nca27SS7oO6rkiblCaHE0pMC5If58/ykfXddNzk/CoVCIlRX77vyeVHniHr/d0N9dqr8zLIslpeXE1G6Khmb9MFQXa40mrvBnggo1MVseXmZN998M0kDQjyruH//fk6dOgXEJ825c+e4evUqKysrRFGUzG4YhqEDik9gZ92q3BL+qvZ1Ks2sufcYmSIiXcDubSLsNMHie0hvCKGPHPcI65eJ+g3M6SMgTKxMEWlYCEOnrj+Jye5CURTR7XZpt9ssLi4mg9dJ1AAmlcmRL1XJFkqM7SLNhsfH9SEfLvcZ+tsFo6q0yTIEM3mbmaLD5w7keGI6QzW33ddBEwdsalCjUJ+RMgxst9uYppl0j1IlH5Mdo1QQojwvgKT8pVQq4Xle4iugaucn/8Lensm+l6hZ8p1tV5UYOoqiRPegWqKqbIQqWbsVN/N7UOdYPp9PhNKqY5oqY/okIf6jiirvUiWC+Xw+WaZcvifb0hqGkRhu7vS/mNRvBEGwraWzyvDs9MFIpeLM985zRfvDaO6UPRFQjMdj/viP/5hms8kTTzzBN7/5TSqV2D34N3/zN3n99dd55ZVX8H2fzc1N+v0+R44c4W/9rb9Fo9FgbW2Nf/Wv/hWj0Yinn376AR/N3qXX69Fqtbh48WIyc6sEbkeOHKFUKn1iBwnN3cc6/CLmzDGMfJXxu79HcOmNeEEwRvbqDL7/f2DWFsj87F/DrB1CFHXA/EmorIS6LqysrCQaicnSA1VffOjQIdxskSgzxdnVIYvnx5xbX8EPI8KIG7o2WYbgUDXFoVqKY9MZnpzLkHEMLFNgPiL6iPuFYRhMTU1Rq9WSAVIYhnQ6HbrdLt1ul3q9njh274aq1282m1y5cgUhRJK5mDTWKxaLyWzw44rKMkwaw3U6naTsRgns78TvQQiRDFLz+XwS6Ck/BTUTvttNcyMqY6PM9CYDBuXPob73KuAYjUa7flZKl7G+vn6DgZ5ysVed1pRfh8ocaTSfhj0RUCgmHSlVtC6ESAxm6vU6y8vL5HK5xBxJ9ZAuFApEUcT6+jrlclmfDBNEUUS/36der7O+vp7M1Kr2jkEQsLy8TBAECCESZ1vNvUUIAZYNqTzm3Ansbh1h2vhX3oZgDDKCUY+ouYL34Xexj7yIGQYYpVmdqZhAzbSq7jKqlWm73U4MqhSqPaSwUwg7w7qfw2ubtJtDlltjGv2AvhduM6KzTUExY1HL2hTTFken00zlbGYKDvmUiWPpc+XTogaSO4WsURSRy+WwLCup/VZOyaPRKPEpUNmK3Wbb1eetRPiO47C5uZm0pJ30IXhUPC8mXd5VaZIqn1FlMur9UyU0qqRJPXar0qXJMiRVlqS8HxzHSUT4k++veuxxzEB8Fm4WbE1WEiidifo8B4NB0qJXfe7q+nez4FB9Z9Q21OeoAgrl3aHOFZVt0mh2Y08EFMokRqXpVFmOWmaaJuVymfX1dRYXFzl58iTT09MA5HI5AA4cOIBlWVy7do1cLqe/9BOEYUiz2WR5eZmrV69uW6bqYZVuRf0g6IDi/iGcNNa+pxB2CnPqMOH6RaJ+E0IPogDZXWf8k99CBmMcYWDkq0hxf9oh7mUmyziCIKBer1Ov17l48eJN+9qbpsXU9DSkSgRumZ9cGbDW9bmy2dx1fQGkHYOFSorT+7PMV1Icm07rbMQ9Qg2Ustls8pjqIqSy0/V6nU6nk3QZ2jlIUuU7g8GAZvP656pmzpWWI5/PJ604d2MvnV+3yhKoc0CZNE46TasMjyqVuRPUb/Skz4PKQKiWpWo9zb1DdTZT5UqKSb1Yu92m3W4zGAxoNBpJcLHbd0j9/ivPDIUqQ6tUKkm2r1wuk0qlPrGzmv78H2/2REBh2zbPPfcc77//PhcvXuRf/It/kYiyT58+zV/9q381aU8ohLjBZEkIkWgodgouNfFF4+LFi59o2gWxXmU8HlOtVnVA9gAwSvsQmTLpn/+bBFfexnv/fyJHPYjic8E/+8eEyx8ivQHm9FGsfU8+4D1+8KysrNBut1laWkqEjDsHTY7jUKvVCJwiY5HmT+sm7bGkNdqkP47wwxt/aKdyNvvKLqf3Z6nlbA6UXdKOiWMJdCxxf1EajKmpKarVKnNzc0kZhzIO63Q6Sb3/zToOTQ6y1cAsk8kkg+RisZjoMe6Xf8GnRRkxKq1Jr9dLuiypGeqdPg/q/q2CCSV0VzPfSuCuhLxKNL2b34PmwaM+M+WbowJupbtQ50e3293mD7Ibk07mkz4YasJxNx8MLfDW7ImAwjAM8vk8hmEkpkhKHHbixAkcx9n2Rd1NPKx6WN+tYGJnv+2HGTVDtVOQuhPP8+h2uzSbTcbj8X03B9IA2ESlBYJum6ByGLF5CTHuQ+TDoEXoDQmuvYcc95GBH5dFAZg2kZtD2mmkk0Xe0LD00UH5GaishDKpm9RJqBrhUFiEZpqOzDAOMwxxWemHdIYBndH2a4VrgmNCxobZPMznYV8OyllJwQ5Bhkgfhrs3WdHcJ9SgFmJdgLruR1GU/A7sbEAxOaiebMc5HA4TTwDf90mlUvi+n2Qu1Gzs/fS7mBSjq31WpSmTAYXq/KMCiuFweMvfqp3iW3Vck8L5SZ8HZSCXTqdveA9uJ0jRPBjUZzv5Gx6GIaZpJs1YxuMxlmVt+35N/lWNECZR3xPlC6N8MNRt55hB+8TceybNQR/0e70nAgqF6hH/S7/0SxiGweuvv86lS5fodrucPHnyvu7LpDjwZlH8w4IyGLrVxV/V3b7xxhuJM2k2m01+aB70l/XxwUAUjmM+WyP9zm9hNi5h9jfiRcGI8U/+f0jTRdoZhNcHYSBzNcb7n8efOo6371kwH80MUxRFtNtter1eogXa7Xtt2zZuKkXfqtIMXF5bcemOQ8bhYJetxszlBbNZwalpyDsROWcE3oihB4u7V0Rp9ghqQCOlZDQaJTXh6vp9s6zFZPva5eXrfjBKB6BmYjOZDLZt3/PZ+CiKkn1S+600Djv1QJ8WNdPsuu42jYO6vqsWrZOMRiNGoxHtdvuzHppmD6C6PZVKpW3niuqepr5zKsjYSRRFyXcCYGlpKVmmvkMqW6GCU5XZ0NwbVEaxVCo98DHanviUPc/jzTffZDgc8uqrr/K5z32OdDrN4cOHOXPmDM1mk7Nnz7K6urrtJFCo+kH1Zb4bF30lDndd96EvoRoOh4l463bMctR64/GYTqeDZVlJzaxqO6dEWpp7g4gCRDCLkflVqF/Cf/u/IfsN5LgHCIgChN8HGQACMWhiL7+N1V0mX53BKO3HKO970IdxV1Czss1mk16vl9QFq640Ctu2MS2H0C3RDGzqQ5teaDMMTboeTHZ/FYBhwJGpNLWszeFailrWJO8KyimBbYLWWj+c7HTgVkJl1QlHmbKNRqObXg+Vv4Lv+0m5hxp8q2uhKv1QGrSNjY0kc6Cc1mdnZ7dpDJTWQQ3iJn0elJmZKttT2ZTJbMutUH4PKmBQgZDSP0w6jE+WLOnSpceTye/XpFP3Th8M1Tr4kyo2JjPHg8Fgm9P5Th8M9b3UpdWfHRWwPehgAvZIQBEEAR9//DGO43Ds2DEOHDhAoVDg8OHDrK+vJyZ2yqxlsk5WfYF7vR6FQuGudShSLdUeBdQPy850/81QFxWVmVHpUillUmqgZrp2pjb3wpf6UUFKicxlCEszREsfEEYBchz3gxcygjCKR8ZSgj/Aag9h2CQzWMUsV7CLxQd7AJ+Bya41KsOm6n+73e6O2TMBhoE0U4RWisAt0w4tFscm3XHIZOdXQ8Rdm2zLwLUMDtfSzJddnpnPkXVNXB1FPHKowXiz2UyEqkpHcTPPCzXImjQRG4/HpFKppNORlBLHcZLt93q9xMNBDZyq1Wqi05h8DSD5bqvBWq/X+0RjP8XN2q+qAdykz0M+n08GcNlsVs8Ua24Ldb1ttVoMBgP6/T5CiGQiZ/I82XnO7BxjOI6TdFNT54waM6jHtWfMo8GeuLpIKWm320m/6smZmH6/T6vVSi6GhmGwtLSE7/u89NJLNJtNVlZWOHv2LNPT0zz11FOPda/x3bBtmyeeeIJr166xuLh4W33FJ4miKCn/EkJw7ty5ZMZBdYGYmppKMhiau4dI5bFmT5L91v+L4Xf/d7x3/hvSn9DCTH6UUoI3ZPzmb+OM+9gLz9/3/b1bqDaXV65codVqJSaWO1sfmqaFsFNE2RnOdFKs9mxGG5JQQiTDbW+PawlyrslLhwsc3vKRyKXM2KTOFI+w6uTxRhmI1Wo1pJQcOHAgGQCpPv7tdjsJOLrd7q7bUZ4XrVZr2wBeZR0mNTwqA/Hee+9ty2So2dubGc3dCpWBUAGD6rKUzWaT7oaTkzuTkzx6gKa5XbLZLJlMhnK5vO37qXSWu/lg3CyDpoIQFZRMBhDqe5vNZimVSokPhmoAoHm42BMBhWmaSTbi3LlzRFGUdHFqNpuUy2VmZmaQUlKpVFheXmZpaYnf//3fT3rPHz9+nP379+sZmF0wDINisZik+JvNZlIKoPpKl8vlpKe4MjlSZQGTIi3F5OBOGSWpMgCVzpzsDKL59MQDAIE0BSJdANOCMNzKStzsWRFRr0E07CADD0wLIR6OWXc1w9VqtRIfCWVstnPWSxo2WC4rXgovcomky+bYZBiKbaVNriVIOybTeZvZokMla3NkKvaRKGYsbFNg6IHWI83NBtRSSvL5fOJNkcvltgmdPc/b5n2hnjOZYdjt2ji5feUFMCmqvlUGQl2TJ30eVAnVbj4PqvxU+QToTLHms3Kz75DKIti2jed5yTmjSvZ8309K+FRp324TQeo1gMSsbzAYJD4Yyv9i0gdDtbPX44m9y54Yfdu2zenTp/nTP/1T3nnnHd55551k2VNPPcWRI0eYn59P9Azf//73uXz5Mm+++SYQe1H8lb/yV5ifn39Qh7CnUT4eqowrCIKkU4jq5HH48OGkZGxtbY1ut8vm5iabm5u7OnBGUZR0FlGo1ObMzAz5fJ5KpRKbiO1ycdI/eLePECIWWUuJDAMwuHlQISVy2EIOOkhviHAzSANg7w4yJgdonuextLREvV5nbW1t+3oTd6SVIkqVuTjI0fFNgv6Nb4oQkHVNpgsOn1/Ic3p/lrmiiyH0909DYuI56XmhrmsqI6tMEiddpCe5nS5HqtnF7eyPECIRs066FudyuST40Q0yNA8KVa8/ec5AfA1X5VHtdju5r8xydzt3pJRJMLITlYErl8uJD0alUkkaB9zO9/9mAYw+d+4dQt5m/cu5c+coFovMzMzc9Z1QqTQ1KzmJEpOp3uBSStbX17cJjA3DoFarJRdbze6EYZjMmKnZYNXiTQn2DMNIfjyVQNDzPBqNRtK/utFo7GqUo050lXZXfd5d191mkFMsFvUswx0w+M7/G++t/0LU3bjeLvYmiFwVs7qAffIrmNNHsY99Yc9eSEejEaurq6ytrSVto1V5yCSRncMzUpztZhnj4OHSDw1CqY4r9oio5Wz2lVwO1VKc2pelkLbIuiZp28A29Y+K5uaoUiglPlWlTL7v0263t5V5DAYDxuPxpy4hVddblRVRkzrKyTuTydzg86Du7yxj0mj2AioDt7Pd/mT2QflgKK2R0mLshsqEqPbNqrxQ6UHz+fw2HwyVyVAdyZaWlpLmCyoDOT8/Tz6fp1Qq3d835yFH/S4fP378luvuiQyFECJJ2Var1Vuuey+CmscBNci/VXemyeUqCFFOqarXtGplqH5wPc9L0pqTMw6j0SgRLioxve/7SRpTXTB2a1mo2Y6Rq2BUD1530b4pEjloEXgjRK4C4z5GuojIFBFuNv77gMug1Kyt+rGp1+tJ0KoCCQkgTAJpMIxMgjDNWGZoRxnGkYm/dfkyBLiWQdY1yTgGBysp5kouC9UUB6spMo4OXjW3x2T/foW6rlmWxXA4xLIsMpkMg8GA1dXVm7oQT6LqxVXpkipb2tn5ZlLAqtE8LKjB/26oLpOO4zAajRKtpZqsVAHIZJcplfnbqctQ56BqkDAej5OAwnVdRqMRzWaTzc3NRFiuzql0Ok0YhklLW93V7O6zJzIUmr3LzWqDh8NhUhLV7XZZX19P2sbdCqWzqFarVKvVRNStf0Q/mWD5I8KVMwz+5z9FjjqxCFu9Zds+JvXP1kLLxSzvxz7+Raz5Z7CPfxFhPdiWv6qk7uLFi0nmaycSCK08nSjF+UGBXpRivG0OJD6+tG1woOxy6kCOQ9UUnzuQxZqws9bfK81n4WY/kb7v873vfe+WXkXKDOyZZ56hVqtRKBRu+Zr6O6t5VLjZ+RMEAY1Gg16vl7QDVyVTnxYhBJlMhjAME73TbuvUajVOnDiRNJHR3JqHLkOh2bvsJmRUGaVqtUo2myUIAhYWFpIygMnU5mTnE4Xqs+77Ps1mE9u2k64S6XSaQqGQtDzUXMcozSFsF/fz/yvh+gWCpQ/jwAIQqQJGYRqRyhE1FpHjHnLUi58Y+kSddfxzPyRYOUu4fgGjehBz9jhmaQ5h35/2yErkrzQ6rVZrW0YC4iAiEja9yKUVpugEeUaRTS+y8TFRQUTONShlbY7WUtRyDoen0pQzFjnXxDR0SYjm7nGz75Jpmhw4cIB6vc7y8vKuAychBPl8nrm5OcrlcjKI0d9PzePCJ50/qmRJNd5Rou7BYLDNO0a1Dr9ZcKIqIz5pflz5lV29ejVpp6y5u+iAQvOpUBeH3cRZyiPAcZzk5J9MaU72qlbpTtWi0bZt8vk8+XyeIAjI5XJJm2DVYk7dn9yPxwkjU0K6WewjLyHcLHLUJepugpQYhRpmdQGRqxAIE9mrE0mJ9EcQRchxj3CjB5tXYDzAnDsBhoGwHIx0EexU/P9dLIWabDc42ad/eXk5mZWC6/mUSAoiDDyRoiPTbIRZGmGOgC3vEwMcIXAsg2rOYn/J5fT+HDMFh0O11GP5ndA8OIQQVKtVgiCgXq9v68+vljuOQz6fZ2Zmhmw2qzV+Gs0WqgXyJOr8UW1pW61W0pZ2Utu0mw/G7TQ+8DyPzc3NW3Za09wZuuRJc9fY7SRXF4SNjQ3a7TbdbvemMwmTgkNVxzxZElUoFMjlctsCi8cNKSVEAURh3PFJibPFVjAgBEQhwfoFgouvM37v94laq+APrm/EMLduNs6xlzFnnsA59WcQ+QpG6u5lhaSUDAYDer0eV69eTTrm7MxaSUBishYWaIYZlsMSoTSJAEncOhdgoZpirujw8pEC03mH6YKNZcRtX3XnJs39ZrJt9sbGBpcvX04GQkon8cQTT1AqlajVao/1dUujuR0m/Vngehe1SYf5TqeTNEhQ44vJbpO3QgjBV7/6Vebm5u7+ATyC6JInzQNh0rAG4ovApNlSqVRiOBzS6/WSHu/KY0AJGydbiBqGQbvdTlKeqj+1mumbFIk/Lj/WSQtZ00bYN1/PLO+Dg88CgrC1Qrhyhqi9ghy0IArjGx7h+kWiUQ8Z+JgzRzHLBzBnjsXbNz/95UF9hsPhkH6/T71ep9/vs7m5eYOfhJTQly5jadOTaVpRmn7k4ktrK5CAqbxNfqv163zZpZZ32F9yyadM0rYWW2seHOp657ou5XI5aTnr+37SkaZarSbXKI1G88nsrECYHEuoSUaV+fN9P/HXGo1GLC0tJeXUn7R9VfmgufvogEJzz1BCKVUjCfGMgxJiNRoNNjc3GQwGu2otoihKyqjq9ToQX2BmZmbI5XKJqFu1jNvt9R9XjPwUIlfD2v80UXuN8dv/Ff/CjwiHW2LurUKjsH4Z6pcJLr6OdeRlrPnTuPkpjHQBacTeDrf7Pk6mnjudDsvLy1y5cmWbSG7yI5ZAK4q7Ni2HZQJpIDHinISI7TYOVlLMV1xeOFSglrPJuXpgptlbqA6FlUrlQe+KRvNIMunR4jgOxWIxWabaOrdarRu6TO7ENM3EIE9z99ElT5r7yqRjrGoVp3q8K8ftzc3NJIOxG7ZtJ32p1UxgpVIhn89vM8B53F3TpZTxCD70kcM2YXOJqLWK/9F3COtXCNcvbH+Ck0W4GYziHNbMMaxDz2Mf+wJGtnxbr1ev12m1Wly9ejURYKt2wopIChpRjk6UphVl6UYuvoxbwErAMQ0+N5/jQNnlcC3NbMEh4xhkXBPLEJjG4xskajQajWY7qsz60qVLSenhzUqqy+Uyhw4dYn5+/gZzPs3u6JInzZ5FpRwnB/thGGJZ1rYSptFoxGAwwPf9xOdCCbqVoErNRJimmcxMqLIaVRKlyq2Uu+zjNDMhhNia6ncR9jRYLka2iuxvIlIFMEyi3ibSG4I3AK+P9PqEo17sc2GaiFQeozCDka/GHhYTHaGU6F6ZJaqAotlsJuaIAJGEEBNPmnjSohll6UYpWlEaHxvTMqikLHKOST5lcnwmw76Sw0IlRT5lYZk6iNBoNBrNjajsRalUIggCms1m4tIdRVGiycxms5RKJcrl8mM/2Xiv0BkKzQNnt6+g7/v0ej3q9Tq9Xo+1tbXEmfZ2UO7qtVqNXC7HzMwMjuPsWhr1uLAtU9DdIKxfwnv7dwnXLxIuf7jrc4zSfszqPM5zv4R14BRmZX7b9lZXV2m1Wly8eJHhcLhrP35fmnRkmrWgSDvM0JLpRGztWgaVrM2Lh/Kc2p9jf9klnzKYDCEe59I1jUaj0Xwy6rdNmaRevHiRdrvNYDDAcRzS6TQnTpygVCol5sn6d+X20BkKzUPFbie2mlGwLAvf95mZmUnKaJRQW3V32OmmCSQ1laPRCMuyWFpaShw6i8UiqVRqm2D8cWDyfTbSBcTUUcQLfw7ZXse/8ibhyjnC5iKy30jEDlG/gQzGyNd/i+Dq24jyPON9z9IPTdrjiHq9zmAwSHQwikAaBJg0whwD6dAIc4ykjY9F2rGo5mz2FV2emElTztjMFBxKGYuMozQU+mKv0Wg0mlujfi+UP5bruknLesMwEs8LVamguTfogEKzJ1EdHVz3uqOz6vaUSqXo9/tYloUQYls5lKqnVBqNSR1GJpMhm83ieR65XA4pJZlMJun6oDpFqdujjLBTCDuFka8RDTtgOyBMEIIwDGL/isADf0jkDwl7m4hBB1lep2vUaIc2G8OIZrOZdG5SCZAAA09ajKRDI8rRkylaMottCmzToJKzOVB2eWI6zXPzOYrpuKzpUX/PNRqNRnPvsCyLXC5HLpd70LvyWKIDCs1Dg+u6OI6TBAOqPeloNNrmc9FsNndtHTcYDBgOhzQaDSDuGKWcOmu1GsViMbkYPU6DW5HKYT/xRewjLyO9AeN3f4/g2rv4H/8IvAERgpGVZzMq0x4U2LhcJxQmkdxRRoXAlyaLYZVWlGEzzCERWKbBVM7m5FyGQ7U0Lx0u4FoGpgDTFDw+77RGo9FoNI8meyqgGAwGdDodzp49y2Bw3YjLdV1effVVbNtGSslHH31Eu92m1WoBcVR67NixRHCjeTTZmTmQUpJOp7EsK/G8GA6HVCoVxuNx4nPh+36SqVBdpiAWg/f7/SQ12ul0SKVS5PP5bT4XlmU90qlSIYzYhtq0wbSwDpyKRdu5aVrLFxmMxjRllp5bY2gX8SOQYkL3EkUQjGlTokOORpQlMFNkHYfZrVKm2JTOpZK1yLmm7tak0Wg0Gs0jxJ4IKNQsZ7fb5cqVK/zO7/wO6+vryQCuVCrx0ksvYVkWYRjyk5/8hIsXL3Lx4sWkbOVb3/oWx44d0wHFY4QQAtu2sW2bTCYDxN8lpa9oNBqJsZpqX7pTAK5McbrdbvKYcuSuVCrUajUymUwSzE4GFY9kgGFYWPPPIGZOwtEv0nrj+zSaLZY8FyZzCcn7KBGRjzHu0RRTrFCkb2TJuzbTOZvPL+SZr7ic3v94ZX00Go1Go3mc2BMBRRRFrK+v88Ybb/Dd736Xr3/968zOzlKtVpOWX+l0mrW1NS5fvsxgMODw4cN8+9vfptVq0Wg0+N3f/V1GoxEnTpx40IejecC4rott2+RyOfbt25doKbrdbuJzobJhu9Hr9ZLSqMuXL2NZVuJxoQIN5dj9qBFFEUtLSzQaDdbXVhl0PPzAuWG9VNClMK4z1fuYlNfB9TucEnlGdpHB0Z+lcPAkU8efJeua2Lrtq0aj0Wg0jzR7JqBoNpv0+30A9u/fz8LCAuVyedusZr/fZ2VlBdu2E4OSTqdDLpcjDEOGwyHdbpdMJvPYdO7RbEeVRSnjO7heGqXKmAzDYDAY4LruNp+LIAgIw/AGvwvDMPA8LymjCoKAdDqdtKQzTTMx0nsYv3dRFG07vo2NDVqtFq12hyCIiD2rIZQGIYIojHB9D3fcIj9aJ+13cMIBGdElki1Gw3Nk+wblbgZBDeFmwC482IPUaDQajUZzz9gTAUUYhly8eBHHcfjyl7/MoUOHKJVKN5RItFotPv74Y06ePMm+ffuAuDzFMAyOHj2KaZqcP3+ekydPJiUwGg3E7tqlUolSqcT+/fuJooggCNjc3KTb7bK+vk6r1dpW+qSIoihpjapQRny1Wo18Ps/U1BT5fP6hzFr4vs/a2hpLS0tsbm7S6/V29QYZSpuRtBkNR9ijEXZvFddr48ghAjClj+m3sc//Hsa1H9L/YAr3uf8Fc/YJrCMv3/8D02g0Go1Gc1/YEwGFlJLBYMDKygqrq6tcvnwZx4nLLGq1GtVqlS9/+cvJ+qlUilQqduxVs9HZbBbTNOn3+7t2+NE8vuxWu68yGKVSiVwuR7lcZjweMx6P6XQ6jEYjer0e3W53m+uzQpVRqdn89fV10uk0qVSKQqFAOp0mm82Sy+X2pCun53kMh0M2Njbo9XpsbGwkxoEqmJASfEzG0qYR5ehEacY4zM84ZDIL5HMvkO58gNNdxr/8Fow64G+J3/0hUXuN8bu/h3H5TaylDzHnTmCWD2BUDiCMhy+To9FoNBqNZnf2xEhHSonnecnApt1uYxhxmUW5XGZ6epqXXnqJMAwRQmBZ1g2DNNd1EULg+/6us6sazSRKm6MyWYVCIfGvULP0KqgdjUaJqFutI6UkCILEgwFIukFNTU2RzWbxfR8hBI7jJD4Xk34X9xslSg+CgMFgQLvdZnV1lU6nk3RMU6dOhCDCYCBdhtKlK4qMrAyRlaJYy1KopMjNpHGbBczGJaJeg6i1ghw0kd4QQh8Z+oQrZ4ga15DDNjLwIPAQqRzYabAcMEwt1tZoNBqN5iFnTwQUiqNHj/L888/z/PPPJ8Ykv/3bv83Zs2f56KOPWFtbe8B7qHmUUcHq9PQ0U1NTyQDc8zzW19fpdDpJeZTSXkyiAoxr164BcRbEcRxc16VWq1EqlZLyqAehtRiPxwyHQy5dukSz2WRzczMxA9x2HBh0ojT1qMBKUMJ1U3xuPs+J2SwHKinmig6WKTCEwCg9C4c+h/vML+BffJ1g6QPGP/0vyFEXgjEActwnWHyfYPkMwknjHP8S5oHT2EdexijOgO3usrcajUaj0WgeFvZEQCGESDIMwLYOOsVikUKhsG2W2Pf9RDCrGI1G2La9bTufBSXU3W3gqHm8UJ+/bdtks1lqtRqe5237fii3bmDbX6XVMAyD4XBIs9mk1WolWTYl5rZt+57M1CvfjcFgyGDQZzgcUq/XGQ6H27IrAIPIZoxNO8qA6ZJKZTju2mRdg/lcSMEcYfgBg56Jscu+hlaJqHiE4PCXEd01zM4yZnsZEY4hCiEKkVFAsHqOaNQjaq0SzZ4kytYIi/vBMEEYd/090Gg0Go3mUUSNH+7W2Pcz7csDffUthBBkMpmky8xkvXqhUKBarSZdeIQQiXcAkJSh9Pt9stks6XQ6KZf6LCghbq/XYzwef+btaR5+VBCgypmGwyH9fj/RXagOUdvco7c6KG1ubiaPmaaJ4zik02lyuRyu65LP55OLwd26KMTBRITnjVnf2KTX7TAaDSeWT6wL9EnTjjIsR1XKKYuDBZMna4KiC1lnDNEYrwebvZu9YhaKRxFP7cfavISz8jbGqIMY+lsvJiEKCVfPEa6ew+P7eId+Br96lPHhLyGtVGyup0ugNBqNRqO5JWrcuxfMd/dUQNHr9VhfX8fzvGTZxYsXeffdd3n++edJp9MALC8vEwQBn//852m1WqytrXHu3DkqlQonT55MBNufBcuyKBaL5PN5rcnQ3IAKZCdv/X6fwWDA5uYm/X6fdru9LXOhUIJuz/PodruJQFx1iapWq2SzWQqFAqZ5ZxqDVrvD6voGy0tLDAYDAn9MtEumrSWzDGWKligyVyvxZDnHrxwoknNNso5BygJDcPvO1ipwWDiE4b+M3PwzRM0l/LPfJ1w9T9SZLFuU2MtvY2+cJX3tdazDL2DNncA+8WWEdaP3hUaj0Wg0musoTeaDDiZgjwQUhmFQrVbpdDqMx2M+/vhjNjY2gLiUqVAoUCwWcV0XKSVra2usr6/z/vvvJ4LScrlMqVS6a+1iVT29RnO7KJ8LFSCnUikGgwG+72/zuVCibnUf4tathmEgpcS2bYIgIIoiUqlUktK0bRvDMOgOxnHZnzdGEAcrEgPDtDAMgyj0Y71Hpxt3bhoNQW6tJyHAJMQkFBZmqkTWzpBNl9lfyzFdTHOwmiZlGdjWZ8n0pZGygLQconQROeqA5SAaBaLOBtIfIfwRwuuDPwRvgJkvYRoSszyLkS0hMiVEuogw9Xmo0Wg0Gs1eRsjbnH4/d+4cxWKRmZmZu74Tahd++tOf8p3vfIdz584lPf9fffVVTp06xSuvvIJlWURRxD/9p/+UixcvJmUkuVyOv/pX/yoHDx5kfn7+ru+fRnM77HYqtdtt+v3+Np+Lfr9/21mvqakpcrkc09PTlMtl3FSan55dorFZZ3N9GZs4mxcIl3Q2j5NKMe42kcEYQu+G7UVS0JIZBiJHzyzx9OFZ5qtZXjpcwDAEk3Mcd2PGY/I4w/plos2rjN/4T4SbV4k2r9z4BMPEKB/Amj+N88QXsY6+gpEpfub90Gg0Go1G8+lYW1uj3W5z/PjxW667JwIKRaPRSNpYqpnbqakpSqUStVotmcE9e/bsNm2DZVkcOXKETCbzUBqLaR5NVAOBIAiSEiff9+l2u4n+otPp4Hleognaieu6iYmecuVudIZ43pjxaICxlaGIMDEtC8M0iXwvzkhsZSUiKfCw8MwskZVhZmaGUj7LVClLMZcm41pUczaCu6ff2I1o1EN6faLNa0SbVwlWzxJc/ilRbxM5aG2tJcDJYGRLGPkprIPPxAHGwrMYhWmMVP6e7Z9Go9FoNJrrfJqAYk/VElQqFSqVyieuI4Tg5MmT92mPNJo7R3lQOI6TlOJFUZRkKZTfynA4TJapm2pZq8z2+v3+Dds3t90PIQiJtho3qWkCKQwiw0JYaQyniOkWmJ6eYV8lzdGp9L08/BswUjlI5TALM4SlOUS2hBx2wE4RRSHSH0EYgNcn8vpEzSWkN8CsLsTeFVKClAgnDcLQ5ngajUaj0ewR9lSGQqN51LnuQi23Gc11u13a7XbiczEcDpOyvzshkoIQg75dw80VOXHsMAvVNNMFF8OIPSRuW2h9D5BRBDKEMCDqrOF9+B38cz8kWD0P3kTwJIz4ZtrY86cxZ57Aee5/wchVMXKfPPmg0Wg0Go3mznloMxQazaPObq1hDcMgl8slzt2qhfJgMGA4HOJ5XiLu3ukdcTPcTI5MaYqFQoV0NstMNUspa+Hae2NWXxgGEAcKIlfFOvgswsli7nuSYPEDZHedqL16vXQrCggb15D+CAmY1YOY00cxp48i3AwY1p7ocqHRaDQazeOIDig0mgeMYRik0+mkLTKQ6Co2Nup0e13W1jbo9br4fhxQ3GzsrNKNmXyRfYdP8MRsnlxqb5/mRiqPcejzWPufRg47jN78zwRX3yXq1rcCirgVbdRaIWqtEFx7F3P2BNaRl3DTBQwxg3AzSAwdVGg0Go1G8wDY2yMNjeYxxbZtTNPkajtilTSvdWzK/goF6eOKT85S+Njks2lO7svjWHsjI3FbWA4iWyH14q8SnfwqUXMZ/8wfEW5eIbj27rZVw/plos46wcWfYJT34Tz5VayDz2JWDjygnddoNBqN5vFFBxQazR5CSsnQjxh6EZ1hwJVmyHJHsjm2MKSDKVM4oo9gd+mTEAZuKoebypB2Hq7TWwgDTAORqyLsNCJVQA6aiEwJGfrIfhM57iNHXQjGyGBM6A2R4x5BtgQI5KCFUZhGuFmEqzu+aTQajUZzP3i4RhwazSNOJGGl7XFxfcgblztc2hwx8LbavxpphgYUzBEGIdwQVAiEYVKbnadQqt73fb+rOGkMJ43z+V9GjrpYx7+If/aPCZc+JFh8D6It1+9gRNRcZPzGIt7ZP8EozJB68VcwZ49j7XvywR6DRqPRaDSPCTqg0GgeMFEkGQURVzZHLLXGvHOtR2sQ0Oj7jIMoWS80Uni2TZAVEPaRow4WcflTiEWuUCZXKPLkkX3ks/e3JezdZpsWwkljTR/FSOWJjr5CcPHHhBuXCVbPIftNVK9cOewQBR6jN/4jZmUec/oo1qHPY+SnMEpzWl+h0Wg0Gs09QgcUGs0DQkqJF0jGQUSj73OxPuTC+pD3l/r44fXsgxDgWgbZlE0hZZApOli+Q2RE2PgABMImXypTKlWZrhRw7Efn1BZbnaCMXBXpj2MDPjePDLw4TzPugze8Xga12CZqrxK1VxFOBlkbxJ2grBSYFhimDi40Go1Go7mLPDqjDo3mIeSdxR4XN4b8ybkW4yDCjyRhtH2dvGvyypECz8znOFxL41oi1lBMWsiIeFZfCIFpGPf3IO4nloN19BWswy+S+sKvM37/DwiXP2L83u+DP7yerehuEvSaBEsfYuRr2Edewj7+JcyZ4xiluZu3ydJoNBqNRvOp0QGFRnMfiSLJRs+nOfBZbXucWR2w3vHpeSFRdF0VkbYNShmLA2WXWt7m6bksc0WXrGtiCB7bGXYhRJxlMC2k5WDtfxIjW0Kk8oQbF4naK4RrH2+1m91yD+83CZY/RPpjjKWPsA89j1GaxSjtA9OKxeAajUaj0WjuGB1QaDT3mOvu2OBHkmuNERc2hrx5pUu95+MF28XVhoBC2uJQNcWXnigxV3SYytuPbRBxM4QQWHMnkTNPYB9+Ee/sHxNce4+wsQjB+LqHhTcgXDlLuHIWnAxy2MZaeB47XUS4OaQBbGV3NBqNRqPRfHqElHL3/pM7OHfuHMVikZmZmXu9TxrNI4UfRGz0fM6uDrhUH/Hhcp++FzL0IsJIJlmJYtqilLF45UiBfUWHQ7U0GcfANg1M4/HNStwKKSXIKG4pOx4Qrn1MuHqW4No7BFfeijUWCiEQqQIiXUBkyjhPfwNr5ijW0Vf0+6vRaDQazQRra2u0222OHz9+y3V1hkKjuQdEUiIlNAc+nWHIpfqQCxsjrjVGbPS8RCchBDimoJK1mSu6zBQcjkylqeVsqjn7wR7EQ4IQAoSJSBeQbhaEgbBsMAxk4CN7daLuBtIbQugjh+04yOg1CIszyHEP7DRGroJI5RCZki6D0mg0Go3mU6ADCo3mHhBFMA4i3rjc5eLGkNcudHa1orNNQTVr87MnSzy9L8vBSuq+7+sjhTAwClMYhSmsIy9iHXmRcO0C/ru/R7B+AdnbjNeLAvACvA/+AOwU/gd/iP3kV7EOnMJ+4otg6oBCo9FoNJrbZc8FFFJKLly4wOrqKm+99RYnT55kfn6eJ554AtM0iaKIH/zgB6ytrbG6uoqUEtd1eemll5idnWVubu5BH4LmMSaMJGdXByy3xpxfH7LcGtMZBTcEE+WMxXzF5al9WabzDgfKLsW0pctuPiOT75+UYJbnMTJlzPI+gqUPiTav4F94HTnsxJkJgMAn6qzhf/Q9gmvvEi6fwZg6jDlzDLNyAGG5D+hoNBqNRqN5ONiTAcXKygoXLlzgrbfewnVdUqkUR48ejfv2ex4XL17k2rVrbGxsEIYhjuNQrVaxLEsHFJr7TiQlQSjxQsnQi8ubLm6MeHepx9iPiLaiCdMA0xCkLIOZgsPR6TTPHMhRy9ukLEMHE3cZIQQiU4RMEbO8H+HmCAvTRJ167FPRWUN6A4hi/UW4cQkai+CPMAeteBt2KtZcOGkwDF0KpdFoNBrNLuzJgOLtt99mc3OTV155hampqWTZ6uoq58+fp9/vc+TIEf723/7bNBoNVldX+Zf/8l8yHo85ffr0A9x7zePI2I+4sDHkvcU+59eHXG2M8MPoBj+J6YLDXNHlZ0+UmMrbTOcdLENoS4T7hDl7HHPmGM7JrxKsnCG49Cbjt3+XqLsee1gAhD7B0ocEK2cZv/1fcY79DObsCZxT38TI18DNPtiD0Gg0Go1mD7KnAopms8na2hqlUgnbtjFNE2PCpKvX67G8vEyhUKBWq5FOpymXy0RRRKVSAeKgo1qtYtta0Kq5d/hhxMiPWGyOqfd8zqzEZU4bPZ9xECWec2nbIOMYLFRTHKymmCu67CvFfhKOpWe77yfCMAETTBuzvD+uiTJMotYKwcoZosY15LAdt5sNIwh9wvULRMMO0bCDte8kRnkf1uwJMG2EuacunxqNRqPRPDD2xC+i6ly7ubnJBx98wOzsLL7vs7q6um29fr/P8vIyJ0+epFarAZDNZpFSsm/fPkzTZGlpiUKhoAMKzV1HfU8jCSM/otH3eftqlyubY95f7t+wviEgnzKZyTv8zLESh6opZovO/d5tzS4YhWlEfgpr7iRhcwnx3v/AD8aE4/51/wokYf0y1C8TXPoJ0RNfxNz/NGZxDpHKIYWIO0rpFJNGo9FoHnP2REARRRHr6+tcuHCBd999l9/4jd/ANM0bAgqI66IzmQyZTGbbY4VCAcMw6Ha7hGF4P3df85ggJXiB5LWLbS7XR7y/3GMwjvB21DYZAvaVXJ7en+WFhTy1nE3WNbFNPfDcc9gpzOpBUl/4dewTXyZqreJ/+AeEG5diTcUE/pW3CJbP4J/7Ada+J7EOPot94lVEuvCAdl6j0Wg0mr3BnggowjBkaWmJfr9PsVgkl8t94vqGYWwrhQIwTRMhBFEU3eRZGs2dEYSSziigPQxoDwI+Xh+y2Byz1vG3rZdxDNK2yXTeZl/Z5YnpNPtKcfcmzd4j9q8QYLgI2wXDwkgXkb06IlUAO03UifUVctwHb4D0hoTe4Po2Uvm4TW2+Fou3bd0RSqPRaDSPH3tipON5Hq+99hq1Wo2vfOUr5PN5ut3ug94tjQaIy5veW+zzzmKP82sD2sMg6dw0yVzR5chUmm88WaKYtsi65v3fWc0dI9Kxg7ZbWyDqrBLWr+D99L/E2YrVs1trSfCHhMsfEi5/iH/hx5hTh3E+92ewDj6LWdJd5jQajUbz+LEnAoowDLl69SpXrlzh3LlzfP/73080FI7jkMvlEEKwvr6OlJLRaMRoNEqeL6Wk1+th2zaZTOaG7MWdEAQBw+GQ0WiE7/u3foLmkWIcQmcMV9qSxiDiYsOnNQjojcNtwUTRhYIDh8uC2UJALTtg1AkI+4KOoUucHlr8ETLKES58BVF5CqN4GGvzAmZvAzFqI7acRaLeJtIfIQctRhd+QlSYw589RZQuEaWKD/ggNBqNRvMok0qlcBznro19Pwt7IqAQQmBZFv1+n83NTTY3NwnDkOFwiGEYDIdDms0m4/EY27YZDocMh3GbxzAM8X2fXq+XlEvdjTdVSkkQBIzHYzzP+8zb0+x9pIw9JUZ+RGcsWetHfLQh2RxI1q9XuWAIsAyBYxnMFgTVtODkjEEpJcjZQOgRhBA8sCPR3BXMDNSewMjPImwXYZkIN43RvIr0R+CP43Iof0jQqxO264S5acY+RIV9RIU5hJMBw4xvGo1Go9HcRXaTADwo9kRAkc/n+ft//+9ve2xtbY3/+T//J5VKhXK5zBe+8AWuXr3Ke++9x9LSEr7v8/LLL9NsNllZWeHs2bPMzMzw5JNP3pU317IsSqUSxaKeZXxc6I9DuqOQ1880uNoYc3ZtSCRJWsACCKCQtliouDy/kOfU/hzljIUh4mW64c8jiJTwxFMgfwlGfcbv/neCK2/jX3oDvK2uUIDRXcXorWGvf4g5dQRz35M4z/wSZmkOozj9gA9Co9FoNI8ie6XT4J4IKIQQpFKpbY+5rotpmliWhW3bWJZFrVbj5MmTLC4ucu3aNX7nd36HwWDAaDTi1KlTHDx4ENO8OzOB6gPaKx+U5t4x9iOuNEYsNsestD0+3hjTHAQEO/T9UzmbWt7mybkMUzmHAxWXQkr7STwemICNFAb2wWcwshXMqcMES+8TddaJ6pfjMigpIYyQ3XWiFUEgDKLSPqz5U5i1Q4hMGUxLX1c0Go1G80ixJwKKm6GM7VTGoVqtUiqV+O53v8vS0hLvvvsuALlcjt/4jd9gfn7+Qe6u5iFCSrlV4gQ9L+SD5T7vLvb5eG3ApN5aZR0MIdhfdjk5m+FnT5ZIOyaGHhQ+dgjLwZr/HObcSaQ3YvzWfyFc/hCvuQRRBMQeFrLfJOw3CVfOYBTniAZNHGFimk7sYWEYCKEDUY1Go9E8Gggp5S79am7k3LlzFItFZmZm7vU+AbEoutvtYlkWpmmSTqcRQiClpNFo4Hle4jdhGEbirq0N7TS3Q7Pvc3lzxE+vdFlteyy1xoz8CC/cfjocnUqzr+jw0pECtZxNKWORdUzijqM6oHhckVKCjJCjLnLQIdy8QnDxx4RrH+NffhOiCS8cw0K4WUS2ipGv4Zz+udjHYt+TD+4ANBqNRqO5BWtra7TbbY4fP37LdfdshsKyLMrl8g2PCyGoVqsPYI80DzteEOEFknrfZ6Pr8fH6kEv1EY2+T2d0fQCYtg3SjkExbXF8JsO+ksPBSoqsa5Ky9ayyRnlYmIhMCWmnwXbBGyJSeWQwJuo3kYM2ctSFKEAO20hviBy2CK7NxF2k/BEildsKTPoQeEgZIewURrqAyJTim7lnL9MajUaj0QB7OKDQaO42nVHIRtfjDz9qstIac7UxvmEdQ8B0weZILc2Lh4scrqXIuTqI0HwCloNRmMY49U3swMM6/EIs2r74Y4LFD8CPO9IResh+A++t/4qf/hOMfBXrwNPIwCNcOUvUWUf6HmZlH9bC57GPvYJ99BUwP9noU6PRaDSaB40OKDSPLFJKvFDSG4W8v9znUn3IYmPMetdj6F9XXAsBKcvgYCXFgbLDswfzlDIW5YxNyjZ0aZPmE5n8fkjTwpw6gpGtYB38HMHFNwgbVwmuvEU0aEMQB7HS6xG1fXxvCDIiGnYgHAMRUWcD/+LrhPXLIAzMqUMYtcP6e6jRaDSaPYsOKDSPJEEo8YKI1jBgs+fz0cqAixtDllvbsxKuJXAtg0rO5vBUimNTaZ6ay+Lq0ibNHSAME5EtQ7aMUVsABCJXQQ460FxEDlrIcR/CABn68f3kyfEf6Q2Q3pCos06wehZMC6N2CCm1bkej0Wg0exMdUGgeSTZ6Hu9e6/HaxQ6rbY+hH8ZNeHZwan+Ow7UUXzlRImUZOJaBNrjW3B0E1sJzWAefwX3+W/jnfkCw/CHjN/8L0utDMNq+utzxT+jhvfnbRM0l7MMvgOWA0JdsjUaj0ew99K+T5pGhMwzojAIu10esdTwubAzZ6PoM/ZBwK5gQwFQ+7ta0r+RyYibDVMEh65hYhsDQ0YTmLqGE22CCaWPOHEOk8mC6BFd+SnDxJ0lW4mZEox7hyjmGP/j/YOSqCDePka8iUnlEuoCRq8WibWFoV0WNRqPRPDB0QKF5qJFSIoktABp9n8XmmO+ebbHZ89ns+dvWNQRYRuwncWQqzecXCkznbd25SXNfMGuHMKoHsfY/zQi2BxQ3a97tDQnXPiZc+xiztoBRmMKYO4lZ2odR2Y+wHHAyYDpxQCEA4uAiCS90oKHRaDSae4wOKDQPLVJKGoOARs/nRxc7XG2MWG179MchYXR9hGYZglre5vhMmqO1NE/vz5JxTNKOgakzEpr7igAng8iVMcr7iLrrEAa39cywtUzYWUOsno/dtk0bLAeRLmBWD2JWDiLy1VgUXpjBLEyDYd7j49FoNBqNRgcUmocMKSWRhJEf0RoEXGmM2Oj6XKrH5U3NwfXBmSGgnLUppEyOTqc5VE0xX3ap5mxsU2clNPefuAxKYGQrmNNHiIbtTw4obAekhNBPbtKPtRdJyOxktjwu2ohMGdlrIHJVwlwNkS4gbBfhZhBONg5AUvmtpIUOpjUajUZzd9ABheahIwglK+0xP77Y4SeXu9R3lDZBHEw4lsGz8zmOTqX50rGirvzQ7BnM6aM4p/8M4foFoq3WsTeUPwkDI1uCMCTqbd58Y96AaP0C0fqF648JAYaBOfckRmEGa+ZYnLkozmLuf3JL26HRaDQazd1BBxSah4aV1piVtsfb13ps9n1W2x6d0fbZXUPA8dkM+4ouJ2YzzBUdCmkzLi/XEYVmj2AUprHsFO4Lv0K4/jHBxTeItly1RbaEOX0Ua+4k1vxpMCyiYQfZXiMatogai0S9BlFvE9ndgGiXDIeUEEZEm1eJ2muE6xcQbg5hpxDZEka2gpGrYpYPIDJFRHEWoziD4Wbv/5uh0Wg0moceHVBo9ixSSoIovg29iKXWmEsbQ95d6tEdhYy3zOkEYJsCxzJI2waHa3F50zPzOVK2gaV1Epo9hnCzGHYa6+AzCDcblyn1m8jQx8hPYe1/GuvQ89gHnwPLQXpDws2ryF6dMFuOg4TWKpHlQDBCBn7sbREFcWlUFIKMkMMOQBx4KAwrdvYuzhBNH8PI1zBGXQjGyHQBYTpgWmCYsejbMGO9hkaj0Wg0N0FIKW/WX2Qb586do1gsMjMzc6/3SaMB4oDiymaclfijsw3Wuz6Nvk8UbW+K41qCozMZTs1lOT6TYaHqbvOT0JkJzV5EShmXOsloKwDY+lYLEbeBNcz4b/KECJAQSSACKZGDFlG/SbhxkXD9IlFnnXD1bJy96Dc/4dXF9dfZ0nUIy0U4GczZExjlfRjl/VhzJzDyU5i1hXv4Tmg0Go1mL7K2tka73eb48eO3XFdnKDR7CiklAy+iMwxYao05vzZkvRuXN/W9KPGTMA1IWQbzlRS1vM1Tc1lmiw61nI1j6e5Nmr3PTp+KWz9hS/ewFWNIKRGZEoblgmlj5KeQox7RgdPIYYto0Cbq1pHjPrLfQA6ayPEAOeoCMg5g5HW3RxkGyMCDjYtEvTqifplw7TwilcPI1TCyZYSbw8jXYmF3Ko/IlRGG/hnRaDSax5099UsQRRFhGDKZNDEMA8MwEEIghEBKmawzuZ5pmgghMAzdvedhQ32OEggjSXsYcK0x5ieXOpxZHdAa3qiTSFkG5YzN6QNZDlVTnD6Qw9CZCM1jhBAC7BTCTmFky9uWyfGAaNwjWD6D7KwTbVwk3LhI1K0TBt5WZmQioFD3gzFRcxEmkxvCAMvFnDkaaz/mTmKU9mGU9mE6KbBcrmc8tm4InRnUaDSax4g9FVC89dZb/OEf/iHNZhPfjzv3vPrqqzz55JMcO3YM0zSRUvLf/tt/4+rVq1y5cgWAdDrNN7/5TRYWFjh06NADPALNnSKBj9eGfLw+5Icft+mMAoZ+hBdE29azTcEXjhY5XEvxzIEcacfANg3dAFOjmcRJYVgOzuEXEl2FDDwIPKJunaizTtRZjbtM9TaJNq8R9Ruw1ZJ2GzICf0S4ep5w/SLB5be2fDAsRKaEyJQwy/MY1YMY+SrW9FFErorYEeRoNBqN5tFlTwQUURTRbDbp9/sAVKtVfN+n3W5Tr9e5cuUKhw8fxvM8ut0ujUaD8XjM7OwsnuchpeTjjz8mlUrpgOIhQkpJdxQy9CM2uh4XN0Zcro9Y7YwZBxPZJwGFtEVx6/bETJr9JZfpgvMA916j2bsIYcR1gaa1LdiWUYhIFxHZMiJfRaQKsQ6jfICouxGXR426sdeFPyIa9a57YATjeBveIP4L0G8iUjnkqIsxaGFkS8huHZGrYGTKiFQOrC0fDDcbi7zttM5eaDQazSPGnggofN/n/fffJwgCXnzxRV544QXCMOSnP/0p7777Lq+99hpf+tKX2Nzc5OzZswwGA+bn5/kLf+EvUK/XWVlZ4Z/8k3+Cbdu8/PLLD/pwNJ+Cq40RlzdHfPejZhJc7MS1DZ6ey3B6PsfJ2SyljIWWSGg0nx5hmJApYmaKmFOH4fCLybKo30AOWoTLHxI2l4iaywRLHyIHLWS/sfsG/RHSHxF264SL719/3E4hnAzWvicxirNYM0cxpo4i8lOYtYNoUz2NRqN5tNgTAYVt2zz99NNEUYQQgnQ6jed5zM7Ocv78eTqduPVhu93m0qVLTE1NMTs7C0ChUCCKIg4fPoxlWVy4cIEDBw7guu6DPCTNTYikZL3js971OLc64OLGkM1+QHsY4IfXsxJp26CStTi5JbY+MZOhmLbIp0wM7Smh0dwxNzt3jFQeaacQThZr/ymkP0IOu0ivR9TdJGqvIPttwuY1ol4jFnoPO9uE3QmBh4xCguWPEBuXCK69i3CzYKfiNrW5KiJXwazMx8Lywmws+rb1dVuj0WgeRvZEQGEYBrVabdtjvu9jWRa2beM4cWnLeDym1WoxNzdHoVAAwHVdstkslUoFwzBoNBrMzs7qgGIPIaUkkuAFEaMgYrE54lpjzPtLPZbbHgPvup+EKSDtmJQyFvNll5NzGfaVXA6WXR1EaDT3EGE5cUnSDnM76Y+Q/SZh/QpRrw7pAqKzGou9OxvI0NsqifKRUQihB1EU6zb6jW0tnhEGIpWPTfQKM8h+C5GvYY56yOJsXBZl2nGplmGB5YBh6E5SGo1Gs8fZs1fpwWDAmTNncF2XhYUFTDNumSiEIJvNkslkknWFEBQKBUzTpNvtEkW7zJhpHhiRhM4w4MOVAWdWBrxxpcPAi4ikZNIFJWUb5FyTr54ss1BN8dRcBtMQ6DhCo3mAWC6iOINVmAYpcU4pP4yIsLkcm+1tXIq7SHXWCVfOxNqLLa3FNmSEHLYJRx3CtY/xP34t6QxlZEqIdBFz7gRm+QBGaQ5z9iRGtoQoTN33w9ZoNBrN7bPnAgopJb1ej/X1dd5//31Onz7N4cOHk4DiZtzt2eswDBmPx3ieRxiGd3XbjxMbA0l7JLnUDFnr+Kx1fIZeRBhdjyQsA2azMJ2DqSxMO0Pc0KfbHj/APddoNJ+IlES+AeSIMvuJamlkfgFZOATDLow7GMMWwh9gjDoYow4iGEPoIaQk9sK4PvkTDdsIfxxnNJvLiHQeY/E9cHOQrRClCkg7jUyXiZws0skg7cx28z+NRqN5jLBtG9u2SaVSD7yKY88FFADNZpPl5WXOnTvHq6++yunTp2/5nNs0/L5toihiOBzS6/XwPO+ubvtRR2UeIgkf1SOWupKfLktCud3h2hBgCEHGhiNlg8NlwXwBDGOE8KFxEx2oRqPZSziQno1vW4hRB2PUwmpcxhhsYraXEK1FxKiD8LpbvhcqoNi674+R/hg5bDOZY5amQ+TmCYoHiDIVwsphwtw0UbZGlK0iDSt2+laBhTC2NN86tanRaB5tMpkMmUwG133wZeF7LqCIooh//+//PePxmL/xN/4Ghw8f3rZcSslgMGAwGGx7rNPpYNs2+Xz+rpjbWZZFqVSiUCjc9WDlUSaSkrOrQ641Rrxzrct6T9L3JMGOt7CYNjlUTfHcwTz7Sg5zBRvHFFgGusRJo3nYkRFEISL8PMgQseWFQTAmbCwiO2vIzjrB2sex2V7jWlwiFe2SDQ49jGELx+shhQlLP0UaJhg2ojCFka1gVOcxqwuIXBVz+ihGKh+LwDUajeYRRhk6P+hgAvZYQLG+vs7Vq1cxDINqtcrBgwfJZq//KNi2TTabpdfr0e12gVio3e/3aTablMtlKpUKlvXZD0sIgWmatyy10sRBxMiL6IxDOsOQC5s+y62AtZ6kOwZ/a4xgmwLHMpjK2dTyNsem0xyupajmbIppa0+cEBqN5t4hQx9hp5G5ClFhBpEuEg1amLUFZL+J9IfIUQ/pDWMx+KgXByMyhCCMcw7+9e2JaIwYdzDCEcLrxTqMYSM23EsXEG4+7hzlTPhgmLa+1mg0Gs1dZk8FFG+99Rb/+l//a37913+dY8eOMT09ve3Cn8lkmJ2dZXFxMckadDod1tbWuHjxIgcPHuTIkSP6x+I+E4SStY7HB8t9PlgZcHa1j7czJQHkXJNa3uYbT1bYX3JYqKaSZfoz02gefYRpY5TmoDTHzqmaqLmI7NYJlj4ibC4SNpcIVz5CjvvgDXfdnhy0YmO+zavbXydTwsiWMfc9iVGYxZw+gjnzBEa2gshV7tHRaTQazePLnggoxuMxP/rRjzh79ixSSr7//e/zxhtvkMvlAEilUnzta18jk8nw8ssvc/XqVT766CP+8T/+x4m+4Zvf/CYnT57UA9P7RBhJvDDi7OqA5ZbH21e7tIch3VFAMOEnYZuCrGvyzIEch2opDlZSTOVsUvbeSNFpNJr7y27nvZQSI1dDpgrY+SmsJEPRRY66RO1VovZqbLzXWCTq1pH9ZtyidhfkuE8YeMjxAGwX8XEG4eYQThqjNIuRq8XBRWUeI1vCKM4gnCzC3BM/iRqNRvPQsSeunlJK2u02QghmZ2cJgoB2u0273QYgnU4zGAwolUrMzMxQKpXodDosLS0BcebixIkTidmd5t4hpWToR4z8iPYw4ML6kCuNMWdWB0w0bsI0wLUMimmLStbm+EyGI1Mp5iupm29co9E8lgghwEkjnDRkituWRaMuUWuFaPMKUW8TkcoRtVaJOutxeVTkx54XgR9rMIItX4zQJ9rZuta0MQrTGMVZjMIM5rBDlK9hjvtbxnopMJ3tPhjCQNwFXZ5Go9E8ygh5m4rjc+fOUSwWmZmZues7IaUkDMO4XeAuHhJKzyCEQAhBEARIKZOyp8nld0OQrbk5YSR57UKbCxtDfnypw8iLCCK5LZgAmM7bPDOf4+UjRfYVXTKukXR10mg0mttFqo5QRHGbOBnF/0chwdr52Puifolw7QKys064ehYZ+rsLvAEQifdF3AFCgDAwy/tigffsccxK7INhzT2JSGURbu7+HbBGo9HsEdbW1mi32xw/fvyW6+6JDIUQ4lMJqW3bvod7o9lJEEo2eh4bXZ+1jseHy302ej6DcUgYXW8Fm3NNCmmTI1NppvMOx6bTTOdt0o6BKbROQqPRfHpEMvDfPlkkZRQHAZkiRr6GNXUUOe4RdetEgxZy2EF2N+LH+k2iXgOC8fWAZMckSNStI8d9Im9IWL+EkSoQXHoTkcojchWMXDUWdudqGOkiIpUFy423314jXD0XazpGXYSdRrgZzP1PY+QqGIW7PxGn0Wg0e4k9EVBo9h5SSiSxl8TIj1hsjGOn69UBK60xwURKQgCmIShnLQ6UXb5yvEQtZzOVdx7Y/ms0mkcbIQxEfgryU5i1Q9uWhc1lovZq7NrdXiOsX0bKCDnsQOATZzvk9Rsy0WvQWd/+Oqk8ojiLNXMMozCNOXscWT6AUZzBSOWRvU3ClTN47/53wvoVotYqRraMka/hyAhz5glErhaXTulJFY1G84iiAwrNrowDSWsQ8NbVLteaY95f6jHyI7xAbgsmShmLcsbiZ44WOVhx2Vd2yTgmpqF/ODUazYPBKExj5CqYM8cgCiAMkMEY6Q2I1i4QtlaIOusE6x8ju3Wi5uJWYHEjctxH1i/jtZYRhgmmE4u3TRujMIX0hnF2Y9SLReJCEg1bRKMu4ff/D6z5Z3DHfawDpxE79CEajUbzqKADCk2ClLEWYqPr0ewHXG2MOL8+ZK0T/69+bgWQsg0qWZuDVZepvMORqRS1nEM5o8vRNBrNgyUe8FuxyBpQ9U3S9xDCQuSqRP0GIl9F9ltEnVXksIcMRls+GAPY6jKFjCCMYuH3tq0JGHWRUYAc9ZNHEUAUARGyt0lUv0Jw+c3Y6C9bjoMSw9wSe1tgGPH/hhW7fU8uN63Y+Xvrsetu4HrCRqPR7C10QPGY8Uka/LgVrOSNy10+Xh/yxpXurutZBkwXbL5wtMQLh/LMFnRpk0aj2cvEA3Bhu5gzRzFnjl5fFEXIKCRcO0/UWSNcOUvYuEbYWiZc+jDuGLUrkqjfmty8enjiviTcuEjUuEpw+U1EughuDsNJxcFOKoewXISTQTiZuKuUk8Vw0rEhX7I8jXCySNOKg4vb66XyqdDlWBqN5rOgA4rHiM2ez3rX451rPTqjgN4oJOdaZByD6bxDc+BT7/tca4zpjoIbnj9TsJkruTw3n6Oas5ktupTT+iuk0WgeYoQA08SozMcaianD1526By3koB0HGs1l5LBF1Fgi6tWRg87W87duNxvjywgZ+IT1K2DacaZhKwPBVgZiMmuxLRtxQzbDRNgOmC5YNoadirdpORP3XbAchGVvtcG1EZYLloswrbg1r3IMt9zkrzQnMiAajUbzKdGjwceASEq8IGKj63FpY8T7yz2a/YD2MKSYtsi5JvtLAfWex0bPpzcOkwkwyxBYpiDjGOwvuRyeSnNqf45CyiTt7PS61Wg0mocMIRAIRDoP5CFfix+XEsKAaNAibC4i6pfjEiYnS9guEHU3iDobsUaDG9udb0NK5LCbZDLuOL8gBFipOHthORhuZit4SMUZDtOO/TzsOIAwHLXcBScTBxlOJg40LAdhp7f+phCWHQc0wrjeTtcwEEmbXWPH3637iK1OXDuWc/2+zn5oNI8+OqB4DPACyQdLA358qc3rlzuE4fUftPYwoDMMWG6Pd82izxUd5ooOXz1ZZqbgUM3amHoSS6PRPA6YFiJfw8pVsA6cBuKuUDLwkIMWvX///yRqLsdai/uBlOAPkf4QgBAxUW41MWjfNoAXE392PD75XMtBmHbcGtdOxRmNVA5hOUnJVRLEOOk4SHEzcUmWnQY3i1BBjApq3CxiK4Oi0WgebXRA8RjgBREfrvRZbXsEu3g9RcQ92beqjEnbBoW0xXzF5dhUmulCHFRkXRPL1DNNGo3mMUCoKyIgdmRjDROQ2IdfInA/JLjy05voGgQiX8WsHcHIFME0kYEHYQBRiAzGsQFfGCBDb+uxeLmMgtj1Owpjo77AiwXi25j005DbHv7UhAHSMJD+OBaDG+ZWmdSWYNxy4pIr005Kt7Ccrc5Xdvy4YW0t3xLFK9dx04q7Y6nnmBYoJ/KJbcbu5GpbW69vmFvbm3gtK34tTPuuZD+klESNRaLeBuHKOeS4H4vo03mM4ixm9SBG5UAcRGk0ml3RAcVjgBdKzqwMaPR3FxdOXo4NiIOJsstLhwucnM1QyerOTRqNRqMQhgl2CuvIi0BEsPRB7G8hw+2z/qaDUdyHfewLmNUDsRGe10d6I/DHyHEPAi/Wa3h9CDyi0SDOQATxchmMwRvFg9ww2BFUyIk/Ez2odgYZO5ff8Bjxvofhtm5WO9a4M7a0IMLNxkGJm431HtZWBsOOMxxKlC7cbJwRsZzYodx245IsJxMHFW5ma7mLcDNIjBuzNDuzMbtmbNRjEqKIcOMi4epZxu/+HrJbR/pjzNIc1sFnkEdfwc5V4yBG+4loNLuiA4rHgDCKna6H/i3qfAHLFPzfX51jtuiQsg0cXd+k0Wg0N2JY2Ic+j1GYwijtw/vgD+NZ7m49ntnOlnGe/b9hzhzHOvhMPCuPiEXaW2Z61831osRgb/L/6+ttLY9CpL8lGPc98AZxZsMfI70hhB7SGyD9cVyWNY6DFIIxkTeI73vD2JNDLQ89pD+Og5XPHj7cyFbbXTnsIIWAfoNIBQETeguxTZuxXYOROKUrPUZyM69rQLaCEOzrGpFEY2Kn4rIsM9aQ4LhbpVxZ5LBN1Nlg/NPfIeqsxX4ihHGHrtYKUb+Jd+kN0v4Qa/Y45v5Td/890mgeAXRA8RggiMXVpoBg19+LeLbFMq77S2g/CY1Go7k5Qghw0hj5Kcy5J7FHXaKpw0T9FsLNYqQLWPufxijNYaQL2597h68poyjOXAReXAblj+KMggoqwgCCONhQy1W5lAzGcQtcf4wMt5Z7I2SklvtJlkJG4VYgEGdEZBTG4nMZxSVaURjvSxSAnLgfRXGpVhRtbSuYCJSiT4xXbjeU2b6eiMuhVNBgWrFofauLVeSktsqpnDjTYVhgq+UWwk7HWaB+i6i9suU7MuknEsRZJH9EcO1d5LAbB1+GGQc3qjOXMGM/EdWxSxhb/8ePJx27Jh6/3sVra3kSXGk0Dyc6oHgMMAxBOWshge5oFxHFFinboJg20SbXGo1Gc3sY2QpGtoK98Ow9fy1hGLHg2Unf1e1KKeNAJfRgPLjeNnfUj83+vGGSzcAbIMeDOMuxY7kMPBj34/+D8ZZ7uL/VCeteIOPth378+ne4CeDGKG9yY1GA985/R6RyGJWDW8GLvdU5y4kF6HY61nbYqZsvN+04sHHSsb4kyarEXbnuRYLok9ClW5q7iQ4oHgPStsErR4q8v9Tjg+XBrusI4GAlxan9WdK2LnPSaDSaxwolijYdRKqwlZm4nm2IsxRbmYet+0kmI5rIaiTP2Xp+GF7PpkRBPMMfjJGhv6UV8beWD5FhgPRH1zMmwVYGZktnQuhvlXNtZVsC7+4d/4SkYleiEDnqE9UvX2+vm3iEGBOPqQyEuCErEWc11H1jInsx4ZZuOlvC9PizwLQQhh0HJYloPRazY7vXxfAqA2Mp0by15U1yXQAvTCvJ3mCYSMPSQYXmrvHQBRRSSnq9Hr7vMxqNgDjKzmazOI5DKpV6wHu497BMwaFqis2ez3LLozcOCSNJJMEQYBqCvGuyr+RyuJbG1roJjUajeWwQSo8A8QBUPX4Xti1VFyul8fBHW8GBhxxNakDi+9IbxqVagb9DI7K1fDycCC5GW6VU0TY9ipzUpkxqUBJ9ilpnq4QruJkb+uSBEB/HhJ/I5KLPjApALDcODpRJ4VYHLeGkEYYNtrPV/coCJ7XVScvGcK6bHCoTw2hLN4Jlx14lppV4lMSdu2yY9BmBHbqVSc3KjuVc17KIG/QuO7Uw8XKhjvMeEZf8xZkxGfpxyZ1hxMeayl83e9TcEx7KgOKP/uiPuHDhAm+99RYAqVSKb37zm5w8eZJTp7RgaieOKXh6X5Zi2uLIVJrvftRks+/THAQUUiaVrMU3nqyyUEsxX3Z1GadGo9Fo7g7C2DLXi70oxM26TG3rTjWx7JPWC4O4tGqiS5Ycx120ZDCOy6/U8nE/Hmx6gzgoUV20OuuEjcV7J0q/XbaMFAmDifKtya5V2+5c/1/s+H/b3V3Wn1y2lbGIy67SyYBbOazHjzkI20lE7bGx4pYRolpuOdeNFVVXrq0gKHZldxFuOsnS3Ctkr06w+D7jd/8HYf0SUXMFI1vCyNdwX/hzmNNHt/xkNPeChyqg6PV6tFotVlZWMAyDb33rWwgh8H2fc+fO4TgO+/fvJ5/PY1kP1aHdU4QQCAGljMVhkeJrT5YZeCEjPyJlGaQdg8NTKYppC0MLKDQajUZzl7ixpGbnIPkOkfL67LuTQrrZLU8PL56pjsI4wIiCuNQq2NJyhP7W8gAZeETNJcL1C/gfvxZnH3YLKoSBdfA0IlPCyFbi58so3lYUXPcK2crGJMJ19VgUXN8n5TGyYznRbvpGue3Prvv2WWIgVU5mmGD2EcK87huydR/DTPw/4jIt67pPiWFd9ykxJh+ztjIDW34iymvEMLbK6qyJx8wd9ye2b9rxa6vXT56vHrcTgbzs1Qk3LuKd+yHh+sfIfhPCEXLQIgp9vI++h9VeAzuNWdqHcDOf4Y3T7MZDNeru9/ssLS2xublJuVzml3/5lxFC0Gw2+c53vkOxWKTVapHJZHRAsQuFtLVlWKdTfhqNRqN5iFHlNoYDOIg7NOMON68SrpwhWDm7pe/wQKiBvAAzLkOyFp7HrC1g1g7H2Y/AR/qDLSNCj8iL9SBxl61Y4yG94ZYexIv1IqEfe5BsaUii8SAWum+tk3TEUsgdmZnkz27r7DQ2vFn2Z3K9uKVv3P3rBqeSu48wtrIYKoORiTMdWxkOYaouXKmtQDGdaEp2y6AIO86ACGESrp8nWP4I/6PvXfdqESQldtG5HyKHHYzKAYxMUQcU94CHatTdbDY5f/48CwsLzMzMJI87jsMLL7xAPp/n2rVrTE1N4bra0VKj0Wg0Gs3NMUpzGLkK6TAgXD2L98F3iAZNCDyMwhTW/qexDr+AffzV2O3csLg+QL/uHxJrMiYfY6JVrtzhMyKRkz4kyCR7EW2J1om2WvyqYMOPH1Oi9KQtcBBnGZSAnWAcbyMMttoGexD6ccCjNAb++BOyIvcQGcUB25Z5ohy0rpdAJRqNXfQb7NRj7HwMRLDVPnnS+FFuf+1w4zLjH/97zOoCRn7q3h/vY8ZDFVCEYYjneZTLZdLp623zhBAUCgVM02Q4HBJFtzZw02g0Go1G83gjTBtpmJjTRxG2Gw/gh10IA0S2hDl1GGvfSYxs+RPb9X6mCi4VZMgQsTXgjvUUcflWLDb2kjKtpGxLlXeFfpzp2CrtSgTJquRrq7SJKEi6aqmyr20dubbMExPhetLZK0oelxPLk25fE8uT9bY9tnWfiaAKtg/+d3tbbvv921r3Fh+C9EdE7dU4w6S56zxUAYXCdd1tGQjV5cn3/bsWUEh5z5J+Go1Go9Fo9gwCc/Y45uxx7Ce/dtO17um4QAgQFsLZPiy7hxLm64FGsOWwHvhbZV+jOPDw+hMZkrikK/JHcYtf1YVLLd/q4hUvH11vBbyVZcEbxEHGPXwPEx36TV5CBmOirhcf2yM4xnvQLYAfyoDifhCGIYPBgOFwSBDcK1MejUaj0Wg0mvuMlNdb5ybZBImUBkgXpANGCuwIzAgclXXY8iKRcke24vp2ksBBXs9wSBkhohAhw+tmh6GPiOLOViKMndpFGCCiWKwuQm9rvwLElqheJM+LBfhChogowOjVt5zbPyFQMB1CJ8tGs41cXr5/7/U9RE2wZ7NZHVDcCVLKG7IQYRgipcQ0zbv6GkEQ4Pu30aNao9FoNBqN5qEjzo7cw3RIvGllfLhVfiVCLw4kIj8u9YriwEJsBRwi9LaCiwDhj+MgI4oNDUUU60FEFAcghmXBqBvrMm6GncIozhEKk/ARGddZlrVnyvwfyoBiMBgkpnYQD/673S6u61IsFu9KUGFZFsVikWKx+EimxjQajUaj0WgeLDu7U014ldxiveROFOJ//Br+pZ8wfv23tnV5StYVBvb0EdwXf5XS4WcQuepdO4IHyYPOSkzyUAUUKmBYW1vb9iYGQcClS5c4cOAATzzxxF0JKCa3v5c+MI1Go9FoNBpNjIwizJljIEPkoEWwfAbZ30SOe3EbWieDdfAZrH1PYs2dxEhlEYbxoHf7keOhCihSqRTlcpkPP/wQKSWj0QghBIPBgKWlJaampqhUKtqDQqPRaDQajeYxQBgGZvUgwnLj9rOBT1g3CCOJkS5g5Ko4J76MOX0Uc/rIg97dR5aHauQ9OztLuVzm0qVLLC4u8nf/7t8F4szF17/+dY4fP87c3JwOKDQajUaj0WgeI0S+in3sC1gHn7nuTC4MhGEg3Fxsqqe5ZzxUI2/LsjAMg2PHjpHL5VhdXQViY7ujR48yNTWFbesvjEaj0Wg0Gs3jhDAscCyEo12wHwQPVUABYBgGX/nKVx70bmg0Go1Go9FoNBpAq1I0Go1Go9FoNBrNHaMDCo1Go9FoNBqNRnPH6IBCo9FoNBqNRqPR3DE6oNBoNBqNRqPRaDR3jA4oNBqNRqPRaDQazR2jAwqNRqPRaDQajUZzx+iAQqPRaDQajUaj0dwxOqDQaDQajUaj0Wg0d4wOKDQajUaj0Wg0Gs0d89A5ZT/uSCkJgoDRaESr1dq2rFAoUCwWtz1Wr9cZDofJ/0IIqtUqtm1jWRZBEOD7Ppubm0gpk/XS6TS1Wm3bttrtNp1OZ9tjpVKJVCqFZVkIIe7SUT4eSClpNpuMx2PCMERKiWEYlEolbNvGcRwAgiCg1Wrh+z5BEADgui6ZTIZ0Oo1pmgB0Oh0GgwFBECClRAhBoVDAdV0cx9n2+fR6PVqtFqlUCtd1yeVy+vO7QzzPo9Pp4HkeYRgCkEqlSKfTZDIZDCOet+n3+4zHYwaDQfL5ZLNZXNclnU4jhCAMw+Sz9n0fANu2yeVyyXkGMBgM6Pf7eJ5HFEUA5HK5bdvS3D5SSgaDAZ7n0e/3k88nk8ngui7ZbBaAMAwZDocMh0NGoxEApmniOA6FQiE5Z0ejEePxmF6vRxRFCCFIpVI4jkM+n0cIgZSSXq/HeDxOrtGmaZJOp0mn06RSqQfzZjzEhGGI53n0er3k8zEMA9M0k989iK+pQRCwubmZnD8Qn7e1Wi35fEajEcPhkH6/v21bxWKRdDp9w+tPXguEEMzMzCTnv+bT4fs+a2tr28YlqVSKYrGIZVnJ+9rtdun3+zf87jmOg+u6CCGIooi1tbXk9xPi62qlUsE0TQzDoNfr4Xkeg8Fg236kUilSqRTZbFZ/lrdABxQPIevr63zwwQf85m/+5rbHv/Wtb/Erv/Ir2x77N//m3/Dmm28m/1uWxV//63+d+fl5pqamaDQaLC4u8s//+T9PBjAAzz//PH/zb/7NbQOT73znO/z2b//2tu3/5b/8lzl16hRzc3N6EHMH/NZv/RZnz56lXq8D8cXrN37jNzh48CALCwtAHBT+u3/377h27Vqy3hNPPMGXvvQlnnvuOUqlEgDf/e53+eEPf8jGxkYyiPm1X/s1jh07xokTJ7a97k9+8hP+z//z/+Tzn/88x44d4xd+4Rfu30E/YqysrPAf/+N/5PLly0mQf+rUKV566SVeeOEFcrkcEL/nZ86c4cc//jFhGGIYBl//+tc5duwYr7zyChAHev/23/5bFhcXWVlZAWD//v1885vf5NSpU0xPTwPw3nvv8Sd/8iecPXuW8XgMwM/+7M9y8uRJXnrppSTI1Nw+b7/9Nh9//DHf/e53kVJiWRYvvfQSTz31FF/+8peBOJB74403eP311/nggw8AKJfLLCws8Gu/9mvMz88DcP78ec6cOcMf/MEfJAPb559/nqNHj/KLv/iLCCHwfZ8//dM/5ezZs7zxxhsA5PN5XnjhBV555RWefPLJB/AuPNwMBgPOnz/P7//+7/PRRx8BkM1mKZfL/I2/8TfYt28fAK1Wi+XlZf7ZP/tnyecD8NRTT/F3/s7fAeIB7blz53j99df5kz/5EyCeyKlUKvylv/SXePbZZ294/eXlZf7Tf/pPXL58GdM0+Yf/8B/uGnhobs36+jp/7+/9vW1BwKlTp/jzf/7PMzMzk7yvP/jBD/je977HxsZGMqHzy7/8y5w4cYKTJ08ihGA0GvGP/tE/YnNzM9nWzMwMf+2v/TVqtRqZTIbXXnuNs2fP8pOf/GTbfpw+fZqnnnqKr33ta/qzvAU6oHjIiKKIq1ev4nkeX//618nlckgpef/99xkOh7z55ps89dRTjMdjzp8/Ty6X45lnnuHYsWO0Wi2azSaXL18mCAKmpqZYWVlhfX2dr3zlK8ls9QcffIDjOLzxxhscO3aMdDrNBx98gO/7PP300xw9ehTf91ldXaXRaHD27FlmZ2cf9FvzUNHpdFhbW6NSqXD69Gmq1Sr1ep1Op8OZM2eQUnLw4EGWlpZYWVkhDEOeffZZisUinU6HXq/Hj3/8Y44dO0YqlWJxcRHHcTh58iRf/OIX6ff7rK+vs7S0RBRFHD9+nMFgQK/X4wc/+AGtVovnnnuOdDq9bYZOc/tIKVlfX6fValEqlXj11VexLIv19XWGwyGvv/46Tz/9NJZlUa/XWV5eptfr8a1vfQvTNImiiDNnzhCGISdOnMDzPLrdLoVCgeeee44vfvGLybZ+/OMfs2/fPiqVCmtra4zHYyqVCr/wC79AEATU63U2Nzd55513+PznP68Dijug3W4TRRG/8iu/ghCCIAh45513cF2XI0eOUKvVGAwG/OQnPyGfz/ONb3yDYrFIt9tlZWWFxcVFpJTMz8/T6/XodDr8wi/8AqZpIqXkgw8+4Pz58ywuLlKpVLBtm3q9TqVS4dd+7deAOKB87733mJ+fZ25ujkKhoGdFPwXD4ZDz589z8uRJTp06BcDa2hrLy8tcvHiR8XjMoUOHuHr1KpcvX+bpp5+mUChQrVa5cOECmUyGN954gyNHjpBOp7lw4cK2z6fT6XD+/HlWVlZIp9McO3Ys+XzX19dpNBq4rguQDG41nw4pJVeuXGF9fZ2XX36ZfD5PJpPhwoULpNNp3n33XV555RWEEFy4cIHBYMD09DSvvPIKvu/TaDSo1+tIKTlx4gSrq6usra1x+vRpTNOkUqkkY6D333+fp59+moWFBaIoolAo8OSTT3Lo0KFkImhqaoparZZkhzU3R79DDyEbGxuYpslXv/pVpqamkjS853m8//77HD16lHa7zVtvvUWpVGJhYYGvfvWrLC4ucvHiRd59912klLz00ks0m016vR6vvvoq5XKZXC5HEAR0Oh3ee+89pqenMQyDd955h1QqxdNPP81Xv/pVRqMR77//PmfPnqXb7fLqq6/qQcynYDAYsLS0xNTUFEeOHOH555/n/PnzXLp0iT/+4z8mn88D8ez38vIyhmFw+vRpPve5z7GyssLrr7/On/7pn9Lr9cjn8ywtLZHJZDh58iQvvvgi9XqdM2fO8NprryUzcOPxmEajwR/90R8xNzfHSy+9xNra2oN8Gx5qVMnacDhkamqK559/nqmpqeR9/+lPf8poNMJxHJaXl9nc3CQIAv7sn/2zuK6L7/v86Ec/SsoXB4MBo9GIarXK0aNHOXHiBGfPnuWjjz7iP/yH/8DXvvY1wjBMslQzMzN8+ctfJooiLl68yG//9m+zuLioA8Q7RH1Wv/iLv4hpmgwGA/7oj/4Iy7JYW1sjl8vR7/f54IMP+Pmf/3leffVV5ubmOHfuHL/3e7/H6uoqQggOHDiA53n4vs83vvGNZNLnvffeY3FxkbW1NVzXpVgsMhwOOXjwIN/85jeRUnLp0iV+93d/l42NDbrdbnId0Nwe4/GY1dVVfu7nfi7J8Lz55pu02+0k4FtYWGBxcZHLly/zzDPPsLCwwJEjR/j+979PvV7n7bffplwu4zgOa2trnDp1ildffRWAy5cvs7q6Sr1eRwjBkSNHkoBidXWVVqtFoVDAtu1tGX/Np2NtbY1Go8GLL77I/v37qVQqfO9732NtbY2zZ89y+vRpXNfl7NmzjEYj5ubm+Lmf+zl83+fy5ct897vfpdVqEYYhjUaDa9eu8bnPfY5arcbCwgKvvfYa165d49y5c8zNzSXVAIVCgUKhwBe/+MUkG6y5fXRA8ZBhGAbf+MY3AHAcB8MwkhOq2Wwm9X+tVosf/ehH/PIv/zJHjx7FMIzkxPwf/+N/JNt7+eWXiaIIx3GSC+P09DSmadJoNACSGdKXX36ZF198EcdxSKfTvPzyy7z55ptsbGxsq3PU3JparcbLL78MkMxAlstlPM/bFphduXKFer3OyZMnqVQqGIbB7Owshw4d4uTJk6ytrWGaJi+99BIQa2Rs2yabzXLgwIFktgygWCySy+X4B//gH1Cv17l27dp9POJHDzWgiKJo2zl08uRJLly4kKzX7/c5e/Ys1WqVhYWF5PM2DIPPfe5zeJ7HtWvXOH78OJVKhaeeeirRJB09ejSp34b4nH/yySeT11R19k899RTf/e53abfb9/dNeIT4+Z//+UTHBPHnc+zYMbLZLFJKPvroIzqdDidOnODw4cPMzc0l9fRPPvkk7XabjY0NIL6uPvfcc2QymWT7Bw8epFAoJP+7rstf+At/IZn5rNfryfOLxSJzc3M6O/EpmZub49vf/va20pR8Ps/8/DyWZTEej1laWuLChQtcvXqVb3/724mm5fDhwwgh+OlPf8qLL77IkSNH+Mt/+S8nuhiIS1Ln5+dvmDyLoogf/OAHZDIZfvVXf5WNjQ0uX758vw77keOZZ54hiiJM00zOj+npaTzPY3V1FYgnAN5++22eeOIJTpw4gW3bpNNpnnrqKX784x/TbDZZWVlhZmaGQ4cOJVoJgEqlwmg00r+BdxkdUDxkKKHgJFEU0e12kVImItAwDBmNRqTTaQqFQjLQVLXBSoTouu62VF4QBInYM5PJJOuORiNs26ZUKmGaJqZpkkqlEpGbCmQmL76am2NZ1g0p1PF4TL/fJ5vNJj+Ivu8TRRHZbBbbthFCYFlWIqT2PI/xeEwqldqmYfF9n16vl4iDgeRzq1ar2+qGNXeGEOKG77sSVUspk3NFSonv+6TTabLZ7LbPKZfLMRgMGA6HCCG2BYBSSjqdDqPRiFKplAjrd77meDym1WrhOA7FYlFrme4AJZBXqHOx3++TyWSoVCqsrKzg+34iflfnr2VZ5HI56vV6cl4pISfE56Lanud5lMtlUqlUIsrudDpsbm7Sbrdpt9scP35cl1jcIZZl3dCYZDwe0263mZ2dxXVdgiBIrqPqN0xKSaFQIJ1O0+l08H0fwzC2BYBwvUFGrVZLmh90u10ajQamaZLJZMjlcvqz+wyoBgaTqHFJEATkcrnkujoejzFNM7muqqBBfa6DwSApmVKosc9oNCKXy227nvb7fTY3N0mn08n3aGpqimq1SrFY1AH+LdDf+occ1fXpypUrVKtVDhw4sG32RNWHTlIsFrFtm/X1daanp5OLn5QSKWVSNnH06FEcx0lEUdlslqmpqW3byuVyyY9prVbTAcUdoLI7m5ubLC4uMj09TaVSSZYbhkE2m932I2XbNvl8Ht/3t3XxUtvq9XpcvnyZQqGQiLY19x7P8/jwww8ZDoccOnQI27bxPA+Ig+2dP5TpdJogCBgOhzfUXEspOX/+POvr6xw+fPiGiQRFt9vlvffeI5VKceDAAR1Q3AWUBunKlSvkcjkOHz5Mq9Wi0+ncMAixLItMJsN4PE6uoZOMx2M2Nja4du0aUkoOHz6MaZp4nsfbb7/NmTNnEiHozMwMv/7rv87CwkKyHf153hnq/Ws2m5w7d47Dhw8nAUImk9kWfAshqFQqZLNZms1mcs7u3NZgMODcuXPUajUqlQpCCFZWVnj//feZmZnRZTL3ACklURSxtLTEeDxOAkP1majJtcnBfjabTTSD5XJ527YgFnxvbGwwPT29bSKhXq/z+uuv8+Mf/zh57Ctf+Qovv/wyTz31lB7f3AIdUDzkXL58ORHtzs7O8swzz9xxu8HV1dXkpK3Vajz77LPk8/ltnRE0d58gCGg0Grz33nt88MEHfPvb377jHyYpJfV6nXPnzvGDH/yAv/gX/yKHDh3Sg5L7xGg04g//8A9ZWFjgS1/6Etls9obBye0ShiE//OEPEULw6quv3tDGWbGxscHv//7v88orr3D06FGtZboLXLx4kQ8//JBXXnmFI0eOfKZtra2t8cMf/pDjx49TrVaTc9GyLF544QWefPJJvv71rwPQaDT4z//5P/Pyyy9z6tQpFhYW9Gz3HaICtnq9zsLCAseOHSOfz9Ptdj/1tqSUvPPOO6yurnLw4EGOHDnC/Pw89Xqdy5cvc+bMGf7cn/tzzMzM3IMjebzZ3NxMgvvZ2Vl+5md+hlKpRLPZ/NTb6vV6rKyscPnyZTzP4+d+7ucoFAqYppmci1/72teAuNT77Nmz9Ho9/uRP/iSZYNXcHH2lekgJwzARoK2srFCtVqlWq9tmtoHEZ2LSJ0L1a1YajCiKGI/HSV19Pp/fNgMz+Zqe5yWlN+qxMAyxbVsPZO6Q8XjMpUuX6HQ6GIaRdHdRsylSysSnQqEyUyrNqwjDcFt72VqtpmfN7hPNZpO1tTVGoxGZTIYDBw4kJYFAonuYRD22c9DY6/USTVShUGB+fv6GDIUKHuv1etL1Sbdv/myohhTNZpNOp8PnPvc55ubmkuXqXJz8HNVjyqNAEUVRsq1ms8lTTz3F7Oxs8vkYhsHU1NS2rO+VK1dot9s0Gg0ajUbShlbz6RiNRvR6vSTbPj8/T6lUwnVdut0uYRhua0eqrqfqt2zyHPI8j9FoxMrKCr1ej/n5earVKtlslo2NDZrNJvV6ncFgQLfbpdvtJn5AqqNXPp+/YbuaT+b/3969xbZ133cA/57DwzspXkWKEinLlizZiiXVsZxmdtPaWRYnWZMuXYt16Z4KFC3QhxUIigHDHrZiD9vDNmAP6wZsA9YOW9d1W5e4SbvEjd3YudmJk3ixI1nWhbqToni/k+fsgTn/irrYEi278fr9AEES8fDwnPM/PPz//pffXx8qqs9HMZvNcLvdG4I2VVU3/D7q9RKDwSDWFKlWq0ilUpicnATQGKmhzxcFGr+Vaxtt8vk8JEnC22+/jfn5eWbt2gYGFPeoXC6HGzdu4OLFi8jn8/jmN7/ZNP5al0wmEYvFmioaemo7PSd3uVzG2NgY3nvvPYyNjeH3f//30d7evuHhl81msbS0hFAoJCpK+mJ3HR0djN5bFI/H8Z3vfAenTp3C448/vuUcmbUt3ZVKBel0Gr29vU3bl0ol/OM//iN6e3vxjW98o6kyRHfWiy++iOvXr+Ppp58WaT/XWruonU5f2ExfrEn31ltv4aWXXsKv//qvIxKJiO/qWrVaDd/97nchyzJ+7/d+D319fU3d+7RzmUwGp0+fhtFoRHd3N44cOdI0wbderyOdTjd9F9fOV1o7R6ZareJ//ud/UK1WEYlEMDIysmUvk66trU30VsRiMWbsatHk5CRmZ2cRjUYxPDyMEydOiAQmQOO3bP2idvF4HJlMBn6/v6mXf2lpCdevX8fk5CQCgQCeeuopyLKMcrmMhYUFLC4uYmlpCX/1V38l3qOqKjRNw7e//W089NBDOHXqFEKhEH8jd6BarWJxcRHnz5/Hm2++iT/90z/dMOQaaPzmZTKZprLUU6vrC7vqaX0vX76MH/zgB/jWt76FQ4cO3XROhM1mw+joKMbHx7GyssKAYhsYUNxjNE3D8vIyZmdn8eqrr4psI3pvg85isaCzsxOFQgFLS0vo6OjA6uoqlpeX4fF4RE/G6uoq4vE4zp07h0AggMceewxOp7NpX4qioLOzE5qmiVSn5XIZi4uLMJvNIrUsW192RtM0nDlzBouLi/i1X/s17N+/Hz6fr+nau1wulEolzM/PIxwOi1bPeDyOhYUFnDx5UvRAXLx4EWNjYxgeHhZ589e2kNOdEY/HxWJ1vb292LNnT9P4bEVR4Ha7EY/HkcvlmnqeZmZmIMsyDh48CLPZjEKhgHPnziGdTqOvrw89PT1iDtTa75e+cJrX64XP50N3dzdsNhu/gy3SNA1jY2OIxWKo1WqIRCLo7u4Wz1V90q6+IFosFkMymRSpX+fm5mCz2cQY/Wg0ivn5eZRKJXi9XgwMDDSN806lUshms8hkMnC5XAiHwwAaDQXRaBTt7e1MGdsCPR332NgY4vE4HnzwQXR2dopWaKPRCI/HA5fLBYvFgqmpKQSDQfh8PsRiMWQyGQSDQVgsFlSrVUSjUUxOTuL69esYGhoSK1/rk7r37dsHu92Ovr6+puM4f/48VlZW8Ju/+ZvYu3evSNBAt6YnK0gkEvjpT38KRVHEmltrr6GiKAgEAqjX61hcXBRrLa2urqJUKkGWZXi9Xmiahng8jjNnzohhTu3t7bcsDz37nqZpIqMb3RwDinuMnu96YmICly5dwtGjRzE8PCxWywV+kWGkq6sLhUJBfNmWl5cxNTUFn88nIn19DOjbb7+NJ554AqOjowB+kbVJz2ait5AuLCygr68PxWIRExMTGya30fboXe4XLlzA6uoqvvjFLyIYDEJRFJRKJZGRyeVyIZ/PY2pqSqxVEI/HsbKyInKeezweVKtVvPfee3jttdfwzDPPIBKJiAnBtVpNBBZ612+pVEK1WhX/FAoFkfZUkiSW5zboQ13i8Th+9rOfYWhoCD09PXC5XGIdA6PRKH7YpqenUSwWxXCIWq2GWCwGu90uUgJns1n8/Oc/R2dnJ/r7+8UwjWKxCEVRROV2cnIS586dw4MPPohgMIi2tjaoqopisSg+kxlJtkcvx4mJCSwsLABopBoNhUKoVqtiOJPD4RCTdvUUr4qiiAB/YGBAlMPs7KxYSVt/FgONcdkGg0G8JxqNoqOjQzTwZLNZ0ejDAHHn9N+liYkJ5PN5fOELX4DFYkGhUBDDQ/VEFXa7HVNTUyI74vLyMnK5HEKhkEiWMDk5iRs3bmBqagqPP/44gsGgyMgmyzLC4fCmw9ImJydRKBTw2GOPcXXlFmQyGSwsLOD8+fP4zGc+gyNHjkBV1aZsknoKdX3odz6fF0FgvV6HxWIRjQCxWAxvvPEGIpEIPv/5z4t7AmgEJgaDQQwF13s68vk8JiYmoGkaurq6GFBsg6RtcwGB8fFxuFwuTjr6JatWq/jbv/1bMRnb6XQ2daMajUb8wR/8AWw2G2ZnZ/Hcc8/hxo0bsFgsYsz9s88+i1AoBJvNhn/913/F+++/j2g0CovFsmG4zVe/+lUMDAxgcnISFy5cwBtvvCFSHlYqFXzlK1/B0NDQhnSYdHNTU1N46623cP78eSSTSdjtdhFEAEB/fz9OnDiBzs5OJJNJ/P3f/z3K5bIY59vT04OjR4/i8OHDUFUVL7/8Mt59913MzMyIfa3N3/3UU09BkiSUSiX88Ic/RC6Xa6osWa1WnDp1Cvfffz+CwSAfntugqipef/11jI+P42c/+xmMRqNI6Qs0xsg/+uijiEQi6O/vxwsvvICrV68iFouJ9Q4eeOAB7N27Fw888ADef/99TE5O4sc//jEAiH3p36vjx4+LRoIrV66IVZwNBoN4BjgcDjz22GPo6ekRizXRzaVSKUSjUfzHf/wHotEogEZDih6Et7e3Y2BgAA899BCMRiNeeuklTE5OYn5+HoqiwOPxoLu7G4888gjcbjdmZ2dx9uxZvPPOOwAaz2T9nnA4HBgZGcHIyAg6OzvxN3/zN6JFVX99eHgYw8PD6O3tbSp/urUPP/wQf/mXf4lKpSJWPtavn8/nQ19fH7785S9jbGwM09PTeP7558UcJrvdjt7eXvzu7/6umGvxx3/8x8hms6jVanA6neK5qI+//9rXvrbpUOO//uu/xsTEBP78z/+cAcUOaZqG06dP48MPP8S7774Ls9m8Ib39F7/4RfT19aGtrQ3PPfccXn75ZdhsNjEX5qmnnkJ/fz96e3vxxhtv4OLFi7h8+bIIHvWGMwA4ceIE7r//fvz85z/H0tIS5ubmxHGUy2U8+eSTOHnyJOx2+69kI83y8rJIZ30r7KG4x8iyLJaF7+np2fC6oigwmUwwmUzih3BtWjRFUeD1ekXg0NnZiWq1iq6urk0Xp9O7Gf1+P3p7e5tSlAJAR0eHWKKets9qtSIQCODw4cNNC5fpIpEI7Ha7KKfh4WHk83lR8YhEIujp6YHFYkGlUkEgEMChQ4c2nTPhdrvhcDjEGgZ9fX1NPVo6Pe0vKzDb53K5EIlE8MlPfnLD90eWZfj9fjGOd8+ePZAkCR6PB6qqioXT9ACura0NHR0dOHr06KbjdYPBINxuNywWC/r6+jatyFitVrENbY++jsSBAwc2neOgTwS1Wq0wm83o7+8Xa37or0ciEbhcLlitVpFmdjNWqxXBYBBOpxMWiwUDAwNIpVLiGeBwONDb27thHD9tjx6Qrf8uSpIEp9OJjo4OAI2FzVRVxdDQEKrVqni9q6tLNI4ZjUYcOnRo02el3W6Hx+PZ8lk5MDAgeipp5wKBgFi7Z7Oy1J9xdrsdPT09OHz4cNPr3d3dIqOax+PB3r17m1Lgr/8si8WCUCgEs9m8oVE1Eolw+OE2sYeCiIiIiIia7KSH4lev/4aIiIiIiHYNAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImoZAwoiIiIiImqZ8ss+ACK6d2iahkqlAlVVUa/Xm15TFAUGgwGKokCSpF/SEdJWarUaVFVFpVJp+rskSZAkCWazGQaDYcf7VVUVtVpN7Gu75a9pGmq1GjRNA9C4f2R5YxtXvV5HrVYTx8n7a3dpmgZVVVEulyFJEiwWS9P1rdVqqFQqMBgMkGVZXH9N01Cv16GqKlRVhclkAgBUq9VdKSv9WcNyJ7o3MKAgom0rl8t44YUXMD09jYmJiabXHnjgARw8eBD3338/jC1qukUAABgWSURBVEbjL+kIaSvj4+OYnp7Giy++2BQMms1muN1ufOlLX8LAwMCO9xuPx/H2228DABwOB44fP76twKRer+PChQsoFAqQJAmjo6Nob2/fsN38/DwuXLgAu90Oj8eD48ePs2K5i/L5PBKJBP75n/8ZJpMJzz77bNP1fe+99/DjH/8YBw8eRDgcxoMPPgigEWiMj49jbm4Ok5OT+PznPw9ZlnHmzBm43W54PJ7behaUSiW88MILMJlM8Hg8+MQnPgGHw7Er50xEu48BBdE9StM0lKoqKnUN+XKjgihJgMNsgMkgw2zc/RGNmqahWCzCYDCgvb0dfr8fkiQhnU6jUChgenoaIyMjDCi2QdM0oJyHVi1DLWUAAJJsgGR1QTKaIRktu/p5tVoNtVoNVqsVbrcbXq8XAFCpVJBOpzExMYFyuYz77rtvRz0V9Xod5XIZAHZc7uVyWbx3fY+Xzmq1IhwOw2w2/0pVKDVNQ7VaRa1WQ7VaBQDIsgyTySR6A3eDoiiwWq0wGAxQVRWJRAJOpxMWS+P+KxQKWFpags/ng91ubzq+dDqNYrEIWZYhSRJUVUWhUIDFYkGlUhG9T63QnzV6r5qqqrd9rkR05zCgILoH6T/UmWId6WINM6slABoMsoQenxUuqwKT0mhlvBOtuaFQCIcOHcLo6CgMBgPGxsbw5ptv4tq1a/jsZz+76bGupx/X7VQ6bubj3IrdOGcNai4BNbuCWuwGAEBSTFBCByA7/YBibvxtF8/DZDLh4MGDGBkZwf333w8AiEajePnll3Hp0iVcuXIFBw4c2HTo0XpbHZemabcs07XvXbvtZu/z+/341Kc+teEzbtfH/f7QK9SFQgHZbBZAI2Bzu92wWq2ijG73PCwWC0wmEyKRCHK5HGZmZrBnzx6YzY37r1KpIJVKIR6Pw+12i/epqopkMglVVREMBqEoigh81p7DTsvqZudzu+X+cS5zonsdAwqie1AsW8FErIC3prJYzdVQ/aj1TgJgNMgIe8w41GXHoS4H2qx352tut9vhdrs3/GjPzs7in/7pn5oqA0ePHsXjjz8OoDFk5syZM1heXkYm02ipd7vdCAQCePTRR1Gr1XDmzBlYrVYAwAcffIBIJIL77rsPxWIRq6urePfddwE0Kkef/vSn0dXVhUgkchfOujXqyhRqC9dQef9FqPkkUNcrYhLKiglK131Q9hyGcf9xSJY72yofCATwxBNP4L/+678Qj8dx/fp1BINBuN1u/OQnP8Hi4iIWFxcBADabDaOjo9i7dy/27NmzYV/FYhGvvfYagEaPw6VLl1AsFgEAfX196Orqwqc+9amm1vVarYZSqYTvfe97Ytt9+/Zh7969OHLkCLLZLK5duwagcY8dPnwYMzMzmJ2dBQDEYjFcvXpVvD46Oop9+/ahs7MTMzMzuHHjBl5//XUAjd6OgwcPYnBwEPv27bsTl3NXrK6uIpVKYWpqCtVqVbTOS5IEWZYRDAbh8/nQ2dkJRbn977ckSWhvb4eiKIjFYggEAqjX65ienka9XseRI0fENdc0TfRGLC4uwuFwoLu7G0ajUQQUmUwGmUwGr776Kur1OiRJwrFjxxAOh9Hf348rV65gcnISV69eFfNv3G43IpEIfuu3fmvLiv/CwgL++7//G9lsVvRsHTp0CMeOHYPP50OpVML4+DjeffddzM/PAwDC4TD279+Pw4cP/0r1cBHdbQwoiO4iVdOQzNdQrqkoVVvvwl/OVHB9uYipeBHpYh1rG5TrKlCpqTAbJdjMBrRZWv+a20wGWIwSXNbmCZGlUgkrKyuYmZmBwWDA8vIyAKCtra2p52F1dRXxeByZTEZMqiyVSkgkElhZWYHL5RKTcyuViqgkpFIpVCoVZDIZVKtVzM3NwW63Q1EUlEolMRQkGo0imUyK90mShHq9fkd6PdR8Elo5D62UBW5z//XYBGrzV1Gbv9rYn6yXkQatXgOgAQYFss0N1eLc8f4lowUwWSE72yEZbl7+FosFHR0daGtrQyqVQjqdhtlshqZpWF5eRiKRENdXVVVMTEzAZrOhvb1dDIsR51Wvi+3L5TIKhYKYBD43N4dqtYqjR4+KCbxAowV8dXUVhUIB5XIZ1WoVCwsLUFUVw8PDqFQqSCQSYltN01AoFLCysoJ0Oi0ql9VqFZVKBdevX4fH40EoFMLy8jKWl5eRTCbFpHN9cvpu0jQNpVJJ3Me3K5FIIJlMYnV1FfV6XfRG6BOoFUWBpmmwWCwtDX1SFAWKosBms4nvq91uR6lUQjqdFtdZ74EIBAKYm5tDvV5HoVAQ90culxNzW9YGNoVCAdVqFaVSCZVKRXyHFUVBf3+/mGhfLpdFQBGLxWA2m5HJZETjgU7TNKRSKfGPXt7VahWJRAKLi4toa2tDqVTCzMwMEokEstksTCYTqtXqHXsmENEvMKAguouqNQ0/vbqKqXgRY0uF1nekNeq0GgBIwPrh53PJCuaTFZy5lmr5IyQAI90O9AVseHLY1/Ta9PQ0xsbG8PzzzzcOR9Nw/PhxHDp0SFRwNE3DT37yE1QqFXz961+H3++H2WzGtWvXsLy8jNOnT+Ozn/0sAoEAvvzlLzf94F++fBlnz54VLaQ6p9OJP/zDP4TZbIaqqnjuuedgsVjwJ3/yJ6JipGeF2W2Va6+gNnURlWtngXrttval6QXYKEFIav2jvzc0go1rKL/xfTRKYmcMHf1QwodgPfFVSE7/tt6jt0oXCgWMj4+jXC7DYDDgyJEjePjhhwEAS0tL+KM/+iOUy2UYjUYcPHhw033pFflvfvOb8Pka985f/MVf4PLlyzh+/Dj8fr9oLU4mk7h48SKeffZZDA4OYmFhAS+99BLOnTuHxx57bMvjrdVqeO211zA0NIRvf/vbWF5exszMDL7zne8gGAxiYGAAV65cgdlsxjPPPIO+vj4R8N6J+2N6ehorKyuYm5u77X3p3wU98NH/Xx9CtLy8jFgshrGxsZb27/f74fP5MDQ0JOa9eL1elMtljI+PY3BwEKqqIh6PQ1VVdHR0oK+vD4qiYGxsTAyJSiaTiEQiOHDgAACIHsaVlRXU63V861vfQqFQEMPq8vk8Pv3pT+MTn/gERkZG8PTTT4vzOn36NPL5PC5duoTBwUG4XK6m6/Hqq6/CaDTiN37jN7Bnzx643W4sLCxgfHwcr7zyCjo7O5HNZvH666/j4YcfxuDgIDo7O8XziMOdiO4sBhREd1Fd0zAZL2IpXYHaUoOZtuZfN/mBlBqb3G6jXDRRhlmRoa37tGAwCI/Hg0gkIloTp6am8NZbbyEUCsHn88HtdmNpaQmxWAzZbFZM/FxdXRXpQiuVCorFImZnZ3Hjxg3EYjEAjWFQ8/PzGBoaEhUCvdVZTy+qaRoCgQCy2Syef/55HDlyBN3d3bd3wjehJmZQm78K1CstX1htw39AlJW0bkNJDzpaqAep6UXUNBVarbzt96ztWcrn80ilUqIs9TIwm83o6+uD0+lEsVjcstXX4/HAarWKXgFN0xAOhyHLMhKJBGw2mwgo3G43RkZG4Ha7YTQa4ff74fF44HA4kMlkRAv2egaDAYODg+jp6YEsy3C73cjlcmhra0O9XkcqlYLL5UIymcTZs2dhsVgQiUTgcrnuSOUylUohmUzuWku4PrRova3mn+yEPidjbU9NR0cHisUi5ubmkMvloKoqVlZW0NbWhnA4jGQyiVqthtXVVZhMJlgsFvj9/qZeSV0oFILVahUTyLu7u1GpVMTn6r0vb775phgmNTU1BavVimAwuOl5xeNxFItFzMzMwOl0wmw2I5/Pi31Vq1WYTCYEg0GMjY1hcXERzzzzDBNEEN0lDCiI7iJNA1ayVWSKt9fCvb1K5vof5Z1XopKFKlbzG3+QPR4PfD4fRkdHRUviP/zDP2BiYgJLS0swmUxwuVxIpVKYn5/H6upq0/ttNhvcbrcYKnLjxg1cunQJMzMzkGUZ9Xpd/KNXZp1OJ7xeb1NPRDAYRK1Ww6VLlxAKheD1emEymWAwGHYtC45Oza1CTS/efpQGANLmpSFt+I9Ngo1t0IoZqPXamrkZt6avJyBJEsrlMjKZDA4cOIC2tjaxjdFoRDgcht1uR7lc3rJC63Q64Xa7m8rA7/ejVqs1jX8HGqlm9+/fD5vNBoPBgLa2NjgcDthsNhQKhS2zP8myjJ6eHnR0dECSJNhsNjidTtjtdtTrdeRyOXg8HqRSKVy/fh3Dw8Ow2+2wWCxiyM9u0idQ74a113VtZX23AiF9zQn9cyRJgsfjwcrKCpLJJIrFIqrVKtLptBjS5PF4kM/nkU6nYTAYRLawzeYl+Hw++Hw+yLIMi8UCs9ks5sroQyFnZmZw/vx5VCoVyLKMarW6adpg/XpkMhkkEgnkcrkNvUx6hiqTyYRQKIRr165hbm4OmUxGDBHbap0TItodDCiI7iKDLGEk4sB0ooQbseIv+3Bu6WDIjr6AdVsV2t7eXqiqilKphFKpJP7e09OzIbe9XiGw2+24ceMG/vM//xOPPPIIvvCFL6CjowMffPABzp8/D4vFsuV4d0mS8LnPfU6ktXz55Zfx7//+73jiiSfQ09OD3t7e2z39JkrXfdBKOVSvXwDU2wwIt0lb8++dVCUN7T0wdA5CMtlvvfFHFhcXMTc3hwMHDogMP/cyRVFw/PhxHD9+HL/zO7+DH/7wh7h06RL27t2Lw4cPbzlcq1WBQACSJIkJ7B9nHo8HXq93QwXbarXiwIEDKBaL+PDDDxGLxRAKhdDV1YVcLofFxUW8//77KBaLcLlcCAQCTUOTtuvKlSv43//9X/z2b/82QqEQQqEQXnrpJTEpfyvhcBinTp3akMIWaASmkiTh6aefxpNPPolUKoU/+7M/QygUwtDQEI4dO9YUHBPR7mJAQXQXGWTgYMgGv8OIsHvnlTZN01CoqljJVjCTKG/og1hLgoSBDivaLAosJkMrI2fQ7TMj4DTdekMAuVwOq6ur6O3thcFgEKvu6uPyPR4PbDbbhvfpuesdDgc6OjpEy3YmkxEZYjY9P0mC1WoVE1QDgQByuRxSqdSutRSvZQjub0yUdnihtTqpV1OhlfOoJ2ZQj01ibS+ShHUjoSQDjHuPNNalMG28bjc9VlcQsjcMmG69lkWhUEAsFkMul4OmafD7/Uin0zCZTEin03A6fzEpvFarYXFxEXv27IHT6dyyxTeXy6FcLjf1LqyuriKRSKC/v/+uBSxms1ncH+FwGKqqYmlpCblcbtc/S+8dWz+heCf0tSdSqZQYHrR26NPanguDwYBgMAij0bjj3ha9J2d9L57JZEJHRwdKpRLm5+dht9vFUEWv14tsNot4PC7Wnejt7d30O30rlUoFlUpF9Hy43W5Uq9Wmnqv1zGYzjEYjKpUKLBZLUwrbtfTjkSQJ4XAYiqIgHo9vOXSOiHYHAwqiu8hokPHgvp236OnqqoaldAUXpzOYXY2jvkVEIQEwSMCJAQ/2B2wItBnvyLhxPesM0EjpODExgePHj4ssPk6nE9lsFlevXsXg4KDICrT+WCRJgsPhEJWETCaDaDSKSqWyaeVzfcXK6/ViaGgIXq8Xi4uLdySgMO49AuPeI7e1D61ehZqYRemdH0FdmYb20WTsDSUjSYBihOWTX4Khox+yO7Rr5adP7NXLLZVK4Z133hFBRHd3N7LZLObn57G8vCwmwAONoTIffvghAoEA2tvbtxxWlkgkEIvFmhYki0ajmJ+fx5NPPtlSJfR2zlXTNIyMjMDv9+MHP/gB8vn8rn6OJEno7Oy87f3UajXkcjlcvXoV+XxeBGTr501IkgRFUTA4OAin07lr19NsNqO7uxvRaBSJRAJ+v1+kgg6FQshms4hGo1BVFbIs4+jRo00B53bpPZQ2mw0mk0nM18jn85v2LOrPB03TEI1GxTwb/bW19GeDyWTCyZMnMT09jcnJSQYURHcYAwqie4gsAX6nEf1BKz4z4MLlaA7pYh0GvaFYa6SNDblNOBCyocdngce++1/zmZkZvP766zh37pyoVLpcLjz00EM4cOCAGH5w4sQJTE9P48UXX8TZs2dFoBEIBLBnzx4cO3YMLpcLJ06cwMWLF3Hu3DkAjbS0fr9/y5bXQqGAVCqFH/3oR1hZWRF/UxQFn/vc59DV1bXr57wrZANkdwjGvaNAtYjKB2c+Shv7USYaAFq9BiU0ACUyDEOwD7LTd/N97kC5XMbly5dx7do1nD59GkBjXoTT6cTJkydFi+7+/fvR3t6Of/u3f0M0GhVrSxiNRjzyyCO47777EAwGtwwoPB4PDAYD/u7v/k5Uir1eL44dO4ZQKHRXeiiq1Sq+973vidZ+PTgdHR1FKBS645/fCoPBAIfDgVAoBFmWMTMzIyrvwC8C+Pb2dvh8PrS1tTWl4L1dJpMJXV1duHr1Kqanp/Hwww83DRNyOBxibZBMJoP29vaWAop9+/ahVqvhX/7lXwA0hqfl8/kth09JkoRTp04hFovh+9//Pi5duiTuIbfbjWAwiEcffRTpdBrf/e53AUCkF+7u7sbhw4dvq+eIiG6NAQXRPUSSJJgVCV67EX0BGxK5GlbzVdTWpIxSZBkRrxl9ASucVgUmZfcmIsqyDJ/Ph2KxiHQ6LSbyAkB7ezt6enrgcrlgNBqhaRo6OztRrVZht9vFcA6g0RKr54a3Wq3Yv38/PvjgA6TTaQAQlSq9dVQfCmW1WpuGf9RqNbFPo9EIu92O9vb2j+0CVpIkAyYrDJ5OaOEh1Fei0PJJaGvmZEgGIwyhA1DCQ5BsLkjK7lS+rVYr2tra4PV6Ua/XxXUzm81wu90Ih8NiMUCHwwGz2Qy/3496vS7SgepZngKBgOht0ldvBhrD1zKZDMxmMxwOh8i+AzQy/3R3d4u1E+r1Olwul6gQr83G43K5EA6HYbVaoaqq2L/dbhdD6db+TadPGvd4PDCZTOI8q9WqeN+ePXs+tmPp9Z4Hp9OJWq0m1mFZ2yMnyzK8Xi98Ph+MRuOuJh/QJ8X7/X4kk0kEAoGmgMFisaCvrw8rKyuo1WqwWq1N5aYoCvx+P1wul2hU0M+rq6tLrEXj8/kQiUQwMTEh1qkIBAIiSDIajeJZYzQa0dbWhlAoJI4PQNOzRO99WPuMARoBktvtRmdnJ7M9Ed1hkrbNvHPj4+NwuVwIBoN3+piI6BY0TYMGIJapIl2sIbpahIbGpO8erxUumwKvXYGE3c2/rg8f0f97rbWZV9ZmkAGwYWL12u3W7mt9dpv1r282vGH9ceituR/nvPOapgGaCjURhZpLoBa7AQCQFBOU0AHIDj8kpw/A7q2ZsHb4z3r6tV4/tGY713ftNrlcDq+88grq9ToURcGJEydEhX+r+2Nt2a7f583K/2bvW/sZ9+r9oWc2KhaLYj6Foihwu92w2WyihX63v99rP3/9fbH+em51z6w9rvXlcLN9rT+fzcr9Vs+SzV7fbN9EdGvLy8tIp9Po7++/5bbsoSC6B0mSBGga2qwGWIwybCa9kgS0WRq9EvId+PHcyaJg69M6bnfbnbx+r1YQJEmCBhmSww+D2QHJ5v7oBRmy3QPJaG30ZuzyZ+7kem13+80qbPq/ZVnesuxvVslb/9m3Wo9hJ++7F+jHrfcA6MN1ZFkWE83vxLndquJ9q3tiq9c3+/t27631bvUs2e100US0PQwoiO5RkiTBZjLAZgLcNn6V7zWSJEGyOgGrE3Lb5vn37zWSJIlJtnqmL2qNJEkwm83/L1L4EtH/f6yFEBHRrrDZbDh58qT4/92cMExERB9fDCiIiGhX6CsjExHRrxauQ09ERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1jQEFERERERC1TdrJxsVjE8vLynToWIiIiIiL6GCgWi9vedkcBRaVSQaVS2fEBERERERHR/0+SpmnaL/sgiIiIiIjo3sQ5FERERERE1DIGFERERERE1DIGFERERERE1DIGFERERERE1DIGFERERERE1DIGFERERERE1DIGFERERERE1DIGFERERERE1DIGFERERERE1LL/A3+zhryfcmchAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⌛ Analyzing 'line-chart.png'...\n", + "\n", + "✨ Model Prediction (JSON):\n", + "{\"gt_parse\": \"This is a line titled 'Wildlife Population'. The x-axis shows Years and the y-axis shows Population(%).\"}\n", + "================================================================================\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from PIL import Image\n", + "import torch\n", + "import io\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 1. Image upload trigger karein\n", + "print(\"📤 Apni Line Graph image select karein:\")\n", + "uploaded = files.upload()\n", + "\n", + "# 2. Model ko evaluation mode mein set karein\n", + "model.eval()\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model.to(device)\n", + "\n", + "for filename in uploaded.keys():\n", + " # Image load aur display setup\n", + " image_data = uploaded[filename]\n", + " image = Image.open(io.BytesIO(image_data)).convert(\"RGB\")\n", + "\n", + " # Image ko screen par dikhane ke liye\n", + " plt.figure(figsize=(10, 6))\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.title(f\"Uploaded: {filename}\")\n", + " plt.show()\n", + "\n", + " # 3. Processing & Prediction\n", + " print(f\"⌛ Analyzing '{filename}'...\")\n", + "\n", + " # Pixel values prepare karein\n", + " pixel_values = processor(image, return_tensors=\"pt\").pixel_values\n", + " pixel_values = pixel_values.to(device)\n", + "\n", + " with torch.no_grad():\n", + " outputs = model.generate(\n", + " pixel_values,\n", + " max_length=768, # Pure caption ke liye zaroori hai\n", + " early_stopping=True,\n", + " pad_token_id=processor.tokenizer.pad_token_id,\n", + " eos_token_id=processor.tokenizer.eos_token_id,\n", + " use_cache=True,\n", + " )\n", + "\n", + " # 4. Output Display\n", + " prediction = processor.tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " print(\"\\n✨ Model Prediction (JSON):\")\n", + " print(prediction)\n", + " print(\"=\"*80)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 705 + }, + "id": "x1ZXgTN53TU_", + "outputId": "521bdfee-1534-4407-ac33-83e998b08b93" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "📤 Apni Line Graph image select karein:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving line_chart_school.webp to line_chart_school.webp\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "⌛ Analyzing 'line_chart_school.webp'...\n", + "\n", + "✨ Model Prediction (JSON):\n", + "{\"gt_parse\": \"This is a line titled 'School Earrollment by Year'. The x-axis shows Year and the y-axis shows Amount (in current US$).\"}\n", + "================================================================================\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "\n", + "# Path jahan tune training ke baad model save kiya hai\n", + "model_folder = \"/content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model\"\n", + "zip_name = \"STEM_Sight_Line_Expert_Model.zip\"\n", + "\n", + "if os.path.exists(model_folder):\n", + " # Zip the folder\n", + " !zip -r {zip_name} {model_folder}\n", + " print(f\"✅ Zip file ready ho gayi: {zip_name}\")\n", + "else:\n", + " print(\"❌ Error: Model folder nahi mila. Path check karo!\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BlfePbFw3uaV", + "outputId": "48febd09-4bc2-4787-944e-e5f326573087" + }, + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " adding: content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model/ (stored 0%)\n", + " adding: content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model/config.json (deflated 74%)\n", + " adding: content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model/generation_config.json (deflated 57%)\n", + " adding: content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model/model.safetensors (deflated 7%)\n", + " adding: content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model/tokenizer_config.json (deflated 53%)\n", + " adding: content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model/tokenizer.json (deflated 74%)\n", + " adding: content/drive/MyDrive/STEM_Sight_Line_V2_Fixed/final_model/processor_config.json (deflated 55%)\n", + "✅ Zip file ready ho gayi: STEM_Sight_Line_Expert_Model.zip\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "import os\n", + "\n", + "if os.path.exists(\"STEM_Sight_Line_Expert_Model.zip\"):\n", + " files.download(\"STEM_Sight_Line_Expert_Model.zip\")\n", + " print(\"🚀 Download starting...\")\n", + "else:\n", + " print(\"❌ Zip file nahi mili. Pehle Step 1 run karo.\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "C-1viImF4TUS", + "outputId": "60413348-d024-43ef-d215-a3d97d060278" + }, + "execution_count": 25, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " async function download(id, filename, size) {\n", + " if (!google.colab.kernel.accessAllowed) {\n", + " return;\n", + " }\n", + " const div = document.createElement('div');\n", + " const label = document.createElement('label');\n", + " label.textContent = `Downloading \"${filename}\": `;\n", + " div.appendChild(label);\n", + " const progress = document.createElement('progress');\n", + " progress.max = size;\n", + " div.appendChild(progress);\n", + " document.body.appendChild(div);\n", + "\n", + " const buffers = [];\n", + " let downloaded = 0;\n", + "\n", + " const channel = await google.colab.kernel.comms.open(id);\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + "\n", + " for await (const message of channel.messages) {\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + " if (message.buffers) {\n", + " for (const buffer of message.buffers) {\n", + " buffers.push(buffer);\n", + " downloaded += buffer.byteLength;\n", + " progress.value = downloaded;\n", + " }\n", + " }\n", + " }\n", + " const blob = new Blob(buffers, {type: 'application/binary'});\n", + " const a = document.createElement('a');\n", + " a.href = window.URL.createObjectURL(blob);\n", + " a.download = filename;\n", + " div.appendChild(a);\n", + " a.click();\n", + " div.remove();\n", + " }\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "download(\"download_4cf00f93-7186-4740-b202-2a72a2966ac3\", \"STEM_Sight_Line_Expert_Model.zip\", 968480683)" + ] + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🚀 Download starting...\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/notebooks/STEM_Sight_PlotQA_Preprocessing.ipynb b/notebooks/STEM_Sight_PlotQA_Preprocessing.ipynb new file mode 100644 index 0000000..54d7460 --- /dev/null +++ b/notebooks/STEM_Sight_PlotQA_Preprocessing.ipynb @@ -0,0 +1,661 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "165f4b53-33c7-460c-bf3e-7557dea137cb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ M4 GPU (Metal) is AVAILABLE via MPS.\n", + "Test tensor successfully moved to: mps:0\n" + ] + } + ], + "source": [ + "import torch\n", + "\n", + "def check_m4_gpu():\n", + " if torch.backends.mps.is_available():\n", + " print(\"✅ M4 GPU (Metal) is AVAILABLE via MPS.\")\n", + " # Create a small tensor to verify\n", + " device = torch.device(\"mps\")\n", + " x = torch.ones(1, device=device)\n", + " print(f\"Test tensor successfully moved to: {x.device}\")\n", + " else:\n", + " print(\"❌ M4 GPU is NOT available to PyTorch. Check your macOS version (12.3+) or PyTorch installation.\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " check_m4_gpu()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a2e39f4f-17c3-4f12-9914-a0086c50c7b1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting split using 10-core parallel processing...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 157070/157070 [00:28<00:00, 5430.29it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Split Summary:\n", + "- vbar_categorical: 52463 images\n", + "- hbar_categorical: 52700 images\n", + "- dot_line: 26010 images\n", + "- line: 25897 images\n" + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "import shutil\n", + "from concurrent.futures import ThreadPoolExecutor\n", + "from tqdm import tqdm\n", + "\n", + "# --- CONFIGURATION ---\n", + "BASE_PATH = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset\" # Adjust if your local path differs\n", + "TRAIN_PNG_SOURCE = os.path.join(BASE_PATH, \"train/png\")\n", + "ANNOTATIONS_FILE = os.path.join(BASE_PATH, \"train/annotations.json\")\n", + "CHART_TYPES = ['vbar_categorical', 'hbar_categorical', 'dot_line', 'line']\n", + "\n", + "# Initialize directories\n", + "for c_type in CHART_TYPES:\n", + " os.makedirs(os.path.join(BASE_PATH, f\"{c_type}_plots/train/png\"), exist_ok=True)\n", + "\n", + "def copy_file(entry):\n", + " img_idx = entry['image_index']\n", + " chart_type = entry['type']\n", + " img_name = f\"{img_idx}.png\"\n", + " \n", + " src = os.path.join(TRAIN_PNG_SOURCE, img_name)\n", + " dst = os.path.join(BASE_PATH, f\"{chart_type}_plots/train/png\", img_name)\n", + " \n", + " if os.path.exists(src):\n", + " shutil.copy2(src, dst)\n", + " return chart_type\n", + " return None\n", + "\n", + "def split_with_m4_cores():\n", + " with open(ANNOTATIONS_FILE, 'r') as f:\n", + " data = json.load(f)\n", + "\n", + " print(f\"Starting split using 10-core parallel processing...\")\n", + " counts = {c: 0 for c in CHART_TYPES}\n", + " \n", + " # Using ThreadPoolExecutor to handle I/O bound copying across cores\n", + " with ThreadPoolExecutor(max_workers=10) as executor:\n", + " results = list(tqdm(executor.map(copy_file, data), total=len(data)))\n", + "\n", + " for r in results:\n", + " if r: counts[r] += 1\n", + "\n", + " print(\"\\nSplit Summary:\")\n", + " for c_type, count in counts.items():\n", + " print(f\"- {c_type}: {count} images\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " split_with_m4_cores()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "572540c2-826d-43fa-ae79-683ac965a0dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "❌ Validation annotations not found at: /Users/akshatchauhan7/Documents/Projects/Spectra/PlotQA-Dataset/val/annotations.json\n" + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "import shutil\n", + "from concurrent.futures import ThreadPoolExecutor\n", + "from tqdm import tqdm\n", + "\n", + "# --- CONFIGURATION FOR VAL ---\n", + "BASE_PATH = \"/Users/akshatchauhan7/Documents/Projects/Spectra/PlotQA-Dataset\" \n", + "VAL_PNG_SOURCE = os.path.join(BASE_PATH, \"val/png\") \n", + "VAL_ANNOTATIONS = os.path.join(BASE_PATH, \"val/annotations.json\")\n", + "CHART_TYPES = ['vbar_categorical', 'hbar_categorical', 'dot_line', 'line']\n", + "\n", + "# Initialize validation directories\n", + "for c_type in CHART_TYPES:\n", + " os.makedirs(os.path.join(BASE_PATH, f\"{c_type}_plots/val/png\"), exist_ok=True)\n", + "\n", + "def copy_val_file(entry):\n", + " img_idx = entry['image_index']\n", + " chart_type = entry['type']\n", + " img_name = f\"{img_idx}.png\"\n", + " \n", + " src = os.path.join(VAL_PNG_SOURCE, img_name)\n", + " dst = os.path.join(BASE_PATH, f\"{chart_type}_plots/val/png\", img_name)\n", + " \n", + " if os.path.exists(src):\n", + " shutil.copy2(src, dst)\n", + " return chart_type\n", + " return None\n", + "\n", + "def split_val_with_m4():\n", + " if not os.path.exists(VAL_ANNOTATIONS):\n", + " print(f\"❌ Validation annotations not found at: {VAL_ANNOTATIONS}\")\n", + " return\n", + "\n", + " with open(VAL_ANNOTATIONS, 'r') as f:\n", + " data = json.load(f)\n", + "\n", + " print(f\"Starting Validation split using 10-core parallel processing...\")\n", + " counts = {c: 0 for c in CHART_TYPES}\n", + " \n", + " with ThreadPoolExecutor(max_workers=10) as executor:\n", + " results = list(tqdm(executor.map(copy_val_file, data), total=len(data)))\n", + "\n", + " for r in results:\n", + " if r: counts[r] += 1\n", + "\n", + " print(\"\\nValidation Split Summary:\")\n", + " for c_type, count in counts.items():\n", + " print(f\"- {c_type}: {count} images\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " split_val_with_m4()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "efea2226-7481-4b7c-b71c-9ff58c53d688", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Validation directory structure ready.\n", + "❌ ERROR: Cannot find validation annotations at: /Users/akshatchauhan7/Documents/Projects/Spectra/PlotQA-Dataset/val/annotations.json\n", + "Please ensure you have downloaded the Validation Annotations from the official PlotQA links.\n" + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "import shutil\n", + "from concurrent.futures import ThreadPoolExecutor\n", + "from tqdm import tqdm\n", + "\n", + "# --- CONFIGURATION ---\n", + "BASE_PATH = \"/Users/akshatchauhan7/Documents/Projects/Spectra/PlotQA-Dataset\"\n", + "\n", + "# PlotQA validation usually sits in its own 'val' subfolder\n", + "VAL_PNG_SOURCE = os.path.join(BASE_PATH, \"val/png\") \n", + "VAL_ANNOTATIONS = os.path.join(BASE_PATH, \"val/annotations.json\")\n", + "CHART_TYPES = ['vbar_categorical', 'hbar_categorical', 'dot_line', 'line']\n", + "\n", + "# --- INITIALIZATION ---\n", + "def init_val_dirs():\n", + " for c_type in CHART_TYPES:\n", + " path = os.path.join(BASE_PATH, f\"{c_type}_plots/val/png\")\n", + " os.makedirs(path, exist_ok=True)\n", + " print(\"✅ Validation directory structure ready.\")\n", + "\n", + "# --- PROCESSING ---\n", + "def copy_val_file(entry):\n", + " img_idx = entry['image_index']\n", + " chart_type = entry['type'] # vbar_categorical, hbar_categorical, dot_line, line\n", + " img_name = f\"{img_idx}.png\"\n", + " \n", + " src = os.path.join(VAL_PNG_SOURCE, img_name)\n", + " dst = os.path.join(BASE_PATH, f\"{chart_type}_plots/val/png\", img_name)\n", + " \n", + " if os.path.exists(src):\n", + " shutil.copy2(src, dst)\n", + " return chart_type\n", + " return None\n", + "\n", + "def split_val_with_m4():\n", + " # Final check for file existence\n", + " if not os.path.exists(VAL_ANNOTATIONS):\n", + " print(f\"❌ ERROR: Cannot find validation annotations at: {VAL_ANNOTATIONS}\")\n", + " print(\"Please ensure you have downloaded the Validation Annotations from the official PlotQA links.\")\n", + " return\n", + "\n", + " with open(VAL_ANNOTATIONS, 'r') as f:\n", + " data = json.load(f)\n", + "\n", + " print(f\"🚀 Starting Validation Split (Parallel I/O on 10 Cores)...\")\n", + " counts = {c: 0 for c in CHART_TYPES}\n", + " \n", + " with ThreadPoolExecutor(max_workers=10) as executor:\n", + " results = list(tqdm(executor.map(copy_val_file, data), total=len(data)))\n", + "\n", + " for r in results:\n", + " if r: counts[r] += 1\n", + "\n", + " print(\"\\n--- Validation Split Summary ---\")\n", + " for c_type, count in counts.items():\n", + " print(f\"- {c_type}: {count} images\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " init_val_dirs()\n", + " split_val_with_m4()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "49957439-ba21-4044-869b-900c800a2bac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Validation specialized directories initialized.\n", + "🚀 Processing 33650 validation entries using 10 M4 Cores...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 33650/33650 [00:04<00:00, 6757.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Validation Split Summary ---\n", + "- vbar_categorical: 11240 images\n", + "- hbar_categorical: 11292 images\n", + "- dot_line: 5571 images\n", + "- line: 5547 images\n" + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "import shutil\n", + "from concurrent.futures import ThreadPoolExecutor\n", + "from tqdm import tqdm\n", + "\n", + "# --- CONFIGURATION (Updated from your screenshot) ---\n", + "# Your screenshot shows: Documents > Documents > Projects...\n", + "BASE_PATH = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset\"\n", + "VAL_PNG_SOURCE = os.path.join(BASE_PATH, \"val/png\") \n", + "VAL_ANNOTATIONS = os.path.join(BASE_PATH, \"val/annotations.json\")\n", + "CHART_TYPES = ['vbar_categorical', 'hbar_categorical', 'dot_line', 'line']\n", + "\n", + "def init_val_dirs():\n", + " for c_type in CHART_TYPES:\n", + " path = os.path.join(BASE_PATH, f\"{c_type}_plots/val/png\")\n", + " os.makedirs(path, exist_ok=True)\n", + " print(\"✅ Validation specialized directories initialized.\")\n", + "\n", + "def copy_val_file(entry):\n", + " img_idx = entry['image_index']\n", + " chart_type = entry['type']\n", + " img_name = f\"{img_idx}.png\"\n", + " \n", + " src = os.path.join(VAL_PNG_SOURCE, img_name)\n", + " dst = os.path.join(BASE_PATH, f\"{chart_type}_plots/val/png\", img_name)\n", + " \n", + " if os.path.exists(src):\n", + " shutil.copy2(src, dst)\n", + " return chart_type\n", + " return None\n", + "\n", + "def split_val_dataset():\n", + " if not os.path.exists(VAL_ANNOTATIONS):\n", + " print(f\"❌ STILL NOT FOUND: {VAL_ANNOTATIONS}\")\n", + " return\n", + "\n", + " with open(VAL_ANNOTATIONS, 'r') as f:\n", + " data = json.load(f)\n", + "\n", + " print(f\"🚀 Processing {len(data)} validation entries using 10 M4 Cores...\")\n", + " counts = {c: 0 for c in CHART_TYPES}\n", + " \n", + " with ThreadPoolExecutor(max_workers=10) as executor:\n", + " results = list(tqdm(executor.map(copy_val_file, data), total=len(data)))\n", + "\n", + " for r in results:\n", + " if r: counts[r] += 1\n", + "\n", + " print(\"\\n--- Validation Split Summary ---\")\n", + " for c_type, count in counts.items():\n", + " print(f\"- {c_type}: {count} images\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " init_val_dirs()\n", + " split_val_dataset()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8578cb60-1cdf-46ce-8c73-deb17b2fe87e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Specialized directories initialized at: /Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset\n", + "🚀 Processing 33650 entries from PlotQA Validation set...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████| 33650/33650 [00:04<00:00, 7998.51it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Validation Split Summary ---\n", + "- vbar_categorical: 11240 images\n", + "- hbar_categorical: 11292 images\n", + "- dot_line: 5571 images\n", + "- line: 5547 images\n" + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "import shutil\n", + "from concurrent.futures import ThreadPoolExecutor\n", + "from tqdm import tqdm\n", + "\n", + "# --- CONFIGURATION (Directly from your screenshot) ---\n", + "# This absolute path prevents folders from being created in your 'notebooks' section\n", + "BASE_PATH = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset\"\n", + "VAL_PNG_SOURCE = os.path.join(BASE_PATH, \"val/png\") \n", + "VAL_ANNOTATIONS = os.path.join(BASE_PATH, \"val/annotations.json\")\n", + "CHART_TYPES = ['vbar_categorical', 'hbar_categorical', 'dot_line', 'line']\n", + "\n", + "def init_val_dirs():\n", + " # This ensures the new folders are created inside the PlotQA-Dataset directory, not the notebooks folder\n", + " for c_type in CHART_TYPES:\n", + " path = os.path.join(BASE_PATH, f\"{c_type}_plots/val/png\")\n", + " os.makedirs(path, exist_ok=True)\n", + " print(f\"✅ Specialized directories initialized at: {BASE_PATH}\")\n", + "\n", + "def copy_val_file(entry):\n", + " img_idx = entry['image_index']\n", + " chart_type = entry['type']\n", + " img_name = f\"{img_idx}.png\"\n", + " \n", + " src = os.path.join(VAL_PNG_SOURCE, img_name)\n", + " dst = os.path.join(BASE_PATH, f\"{chart_type}_plots/val/png\", img_name)\n", + " \n", + " if os.path.exists(src):\n", + " shutil.copy2(src, dst)\n", + " return chart_type\n", + " return None\n", + "\n", + "def split_val_dataset():\n", + " if not os.path.exists(VAL_ANNOTATIONS):\n", + " print(f\"❌ ERROR: Cannot find annotations at {VAL_ANNOTATIONS}\")\n", + " return\n", + "\n", + " with open(VAL_ANNOTATIONS, 'r') as f:\n", + " data = json.load(f)\n", + "\n", + " print(f\"🚀 Processing {len(data)} entries from PlotQA Validation set...\")\n", + " counts = {c: 0 for c in CHART_TYPES}\n", + " \n", + " # Using your 10-core CPU for maximum I/O speed\n", + " with ThreadPoolExecutor(max_workers=10) as executor:\n", + " results = list(tqdm(executor.map(copy_val_file, data), total=len(data)))\n", + "\n", + " for r in results:\n", + " if r: counts[r] += 1\n", + "\n", + " print(\"\\n--- Validation Split Summary ---\")\n", + " for c_type, count in counts.items():\n", + " print(f\"- {c_type}: {count} images\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " init_val_dirs()\n", + " split_val_dataset()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "79c14ce4-c2fc-4ff3-b2e1-7e4b6d6110dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "📂 Loading original train annotations...\n", + "📝 Processing 157070 entries...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Categorizing train: 100%|████████████████████████████████████████████| 157070/157070 [00:11<00:00, 13368.50it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Created train metadata for vbar_categorical: 52463 entries\n", + "✅ Created train metadata for hbar_categorical: 52700 entries\n", + "✅ Created train metadata for dot_line: 26010 entries\n", + "✅ Created train metadata for line: 25897 entries\n", + "\n", + "📂 Loading original val annotations...\n", + "📝 Processing 33650 entries...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Categorizing val: 100%|███████████████████████████████████████████████| 33650/33650 [00:00<00:00, 192386.68it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Created val metadata for vbar_categorical: 11240 entries\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Created val metadata for hbar_categorical: 11292 entries\n", + "✅ Created val metadata for dot_line: 5571 entries\n", + "✅ Created val metadata for line: 5547 entries\n" + ] + } + ], + "source": [ + "import json\n", + "import os\n", + "from tqdm import tqdm\n", + "\n", + "# --- CONFIGURATION (Exact M4 Path) ---\n", + "BASE_PATH = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset\"\n", + "CHART_TYPES = ['vbar_categorical', 'hbar_categorical', 'dot_line', 'line']\n", + "\n", + "# Original Source Annotations\n", + "SOURCE_ANN = {\n", + " \"train\": os.path.join(BASE_PATH, \"train/annotations.json\"),\n", + " \"val\": os.path.join(BASE_PATH, \"val/annotations.json\")\n", + "}\n", + "\n", + "def generate_specialized_metadata():\n", + " for split in ['train', 'val']:\n", + " ann_path = SOURCE_ANN[split]\n", + " \n", + " if not os.path.exists(ann_path):\n", + " print(f\"❌ Skipping {split}: Source annotations not found at {ann_path}\")\n", + " continue\n", + "\n", + " print(f\"\\n📂 Loading original {split} annotations...\")\n", + " with open(ann_path, 'r') as f:\n", + " all_data = json.load(f)\n", + "\n", + " # Create a dictionary to hold the JSONL entries for each type\n", + " type_buckets = {c_type: [] for c_type in CHART_TYPES}\n", + "\n", + " print(f\"📝 Processing {len(all_data)} entries...\")\n", + " for entry in tqdm(all_data, desc=f\"Categorizing {split}\"):\n", + " chart_type = entry.get('type')\n", + " if chart_type not in type_buckets:\n", + " continue\n", + "\n", + " # 1. Extract raw data for the summary\n", + " title = entry.get('general_figure_info', {}).get('title', {}).get('text', 'Untitled')\n", + " x_label = entry.get('general_figure_info', {}).get('x_axis', {}).get('label', {}).get('text', 'X-axis')\n", + " y_label = entry.get('general_figure_info', {}).get('y_axis', {}).get('label', {}).get('text', 'Y-axis')\n", + " \n", + " # 2. Build the semantic summary for STEM Sight\n", + " chart_phrase = chart_type.replace('_', ' ')\n", + " summary = f\"This is a {chart_phrase} titled '{title}'. The x-axis shows {x_label} and the y-axis shows {y_label}.\"\n", + "\n", + " # 3. Format for Donut Training\n", + " type_buckets[chart_type].append({\n", + " \"file_name\": f\"{entry['image_index']}.png\",\n", + " \"ground_truth\": json.dumps({\"gt_parse\": summary})\n", + " })\n", + "\n", + " # Save individual JSONL files into the specialized directories\n", + " for c_type in CHART_TYPES:\n", + " output_dir = os.path.join(BASE_PATH, f\"{c_type}_plots/{split}\")\n", + " output_jsonl = os.path.join(output_dir, \"metadata.jsonl\")\n", + " \n", + " # Ensure the directory exists (it should from the previous notebook)\n", + " os.makedirs(output_dir, exist_ok=True)\n", + "\n", + " if type_buckets[c_type]:\n", + " with open(output_jsonl, 'w') as f:\n", + " for item in type_buckets[c_type]:\n", + " f.write(json.dumps(item) + \"\\n\")\n", + " print(f\"✅ Created {split} metadata for {c_type}: {len(type_buckets[c_type])} entries\")\n", + "\n", + "if __name__ == \"__main__\":\n", + " generate_specialized_metadata()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8643a0ae-c2f2-46e6-9822-a5120de2f1b4", + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: 'plotqa_master.jsonl'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mFileNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 16\u001b[39m\n\u001b[32m 13\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33m✅ Extracted \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mhorizontal_count\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m horizontal bar samples.\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 15\u001b[39m \u001b[38;5;66;03m# Run this on your master PlotQA metadata\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m16\u001b[39m \u001b[43mextract_horizontal_bars\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mplotqa_master.jsonl\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mplotqa_hbar_expert.jsonl\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 5\u001b[39m, in \u001b[36mextract_horizontal_bars\u001b[39m\u001b[34m(input_jsonl, output_jsonl)\u001b[39m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mextract_horizontal_bars\u001b[39m(input_jsonl, output_jsonl):\n\u001b[32m 4\u001b[39m horizontal_count = \u001b[32m0\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43minput_jsonl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mr\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m f_in, \u001b[38;5;28mopen\u001b[39m(output_jsonl, \u001b[33m'\u001b[39m\u001b[33mw\u001b[39m\u001b[33m'\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f_out:\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m line \u001b[38;5;129;01min\u001b[39;00m f_in:\n\u001b[32m 7\u001b[39m data = json.loads(line)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/IPython/core/interactiveshell.py:344\u001b[39m, in \u001b[36m_modified_open\u001b[39m\u001b[34m(file, *args, **kwargs)\u001b[39m\n\u001b[32m 337\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m file \u001b[38;5;129;01min\u001b[39;00m {\u001b[32m0\u001b[39m, \u001b[32m1\u001b[39m, \u001b[32m2\u001b[39m}:\n\u001b[32m 338\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 339\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mIPython won\u001b[39m\u001b[33m'\u001b[39m\u001b[33mt let you open fd=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfile\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m by default \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 340\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mas it is likely to crash IPython. If you know what you are doing, \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 341\u001b[39m \u001b[33m\"\u001b[39m\u001b[33myou can use builtins\u001b[39m\u001b[33m'\u001b[39m\u001b[33m open.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 342\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m344\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mio_open\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[31mFileNotFoundError\u001b[39m: [Errno 2] No such file or directory: 'plotqa_master.jsonl'" + ] + } + ], + "source": [ + "import json\n", + "\n", + "def extract_horizontal_bars(input_jsonl, output_jsonl):\n", + " horizontal_count = 0\n", + " with open(input_jsonl, 'r') as f_in, open(output_jsonl, 'w') as f_out:\n", + " for line in f_in:\n", + " data = json.loads(line)\n", + " # Check for horizontal bar chart types in PlotQA metadata\n", + " if \"horizontal_bar\" in data.get(\"type\", \"\").lower():\n", + " f_out.write(json.dumps(data) + \"\\n\")\n", + " horizontal_count += 1\n", + " \n", + " print(f\"✅ Extracted {horizontal_count} horizontal bar samples.\")\n", + "\n", + "# Run this on your master PlotQA metadata\n", + "extract_horizontal_bars(\"plotqa_master.jsonl\", \"plotqa_hbar_expert.jsonl\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f29ef544-9942-4dea-83e6-aca9792bbec3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/STEM_Sight_VBar_Training.ipynb b/notebooks/STEM_Sight_VBar_Training.ipynb new file mode 100644 index 0000000..22590a0 --- /dev/null +++ b/notebooks/STEM_Sight_VBar_Training.ipynb @@ -0,0 +1,761 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "b83246bc-83b6-4492-81b5-a628f1f84fdc", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q transformers datasets sentencepiece accelerate" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bcdee684-8d39-4f52-8a5b-dfa7b119548f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ VisionEncoderDecoderModel successfully imported from Transformers!\n", + "🚀 M4 GPU (MPS) is ready for training.\n" + ] + } + ], + "source": [ + "from transformers import VisionEncoderDecoderModel, DonutProcessor\n", + "import torch\n", + "\n", + "# This is the class the previous error was referring to\n", + "print(\"✅ VisionEncoderDecoderModel successfully imported from Transformers!\")\n", + "\n", + "# Quick check on your 10-core GPU\n", + "if torch.backends.mps.is_available():\n", + " print(\"🚀 M4 GPU (MPS) is ready for training.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7d2747a8-559d-4faf-b850-e9bdba51b1dd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The image processor of type `DonutImageProcessor` is now loaded as a fast processor by default, even if the model checkpoint was saved with a slow processor. This is a breaking change and may produce slightly different outputs. To continue using the slow processor, instantiate this class with `use_fast=False`. \n", + "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Collator initialized successfully with the processor!\n" + ] + } + ], + "source": [ + "import json\n", + "from transformers import DonutProcessor\n", + "\n", + "# 1. Re-define the processor (Ensure this matches your model choice)\n", + "model_checkpoint = \"naver-clova-ix/donut-base\"\n", + "processor = DonutProcessor.from_pretrained(model_checkpoint)\n", + "\n", + "# 2. The Collator Class\n", + "class DonutDataCollator:\n", + " def __init__(self, processor, max_length=128):\n", + " self.processor = processor\n", + " self.max_length = max_length\n", + "\n", + " def __call__(self, batch):\n", + " pixel_values = [item[\"image\"].convert(\"RGB\") for item in batch]\n", + " inputs = self.processor(pixel_values, return_tensors=\"pt\")\n", + " \n", + " # Extract ground truth from the JSONL metadata\n", + " labels = [json.loads(item[\"ground_truth\"])[\"gt_parse\"] for item in batch]\n", + " \n", + " labels_batch = self.processor.tokenizer(\n", + " labels, \n", + " add_special_tokens=True, \n", + " max_length=self.max_length, \n", + " padding=\"max_length\", \n", + " truncation=True, \n", + " return_tensors=\"pt\"\n", + " )\n", + "\n", + " labels = labels_batch.input_ids.clone()\n", + " labels[labels == self.processor.tokenizer.pad_token_id] = -100\n", + " \n", + " return {\n", + " \"pixel_values\": inputs.pixel_values,\n", + " \"labels\": labels\n", + " }\n", + "\n", + "# 3. Now initialize - This should work perfectly now!\n", + "collator = DonutDataCollator(processor)\n", + "print(\"✅ Collator initialized successfully with the processor!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f98ec32e-add9-4dff-9c02-84678aa56c7d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Created sample dataset with 500 images at /Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset/vbar_sample\n" + ] + } + ], + "source": [ + "import os\n", + "import shutil\n", + "import json\n", + "\n", + "# Paths\n", + "ORIGINAL_DIR = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset/vbar_categorical_plots/train\"\n", + "SAMPLE_DIR = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset/vbar_sample\"\n", + "\n", + "os.makedirs(os.path.join(SAMPLE_DIR, \"png\"), exist_ok=True)\n", + "\n", + "# Copy 500 images\n", + "images = os.listdir(os.path.join(ORIGINAL_DIR, \"png\"))[:500]\n", + "for img in images:\n", + " shutil.copy(os.path.join(ORIGINAL_DIR, \"png\", img), os.path.join(SAMPLE_DIR, \"png\", img))\n", + "\n", + "# Filter metadata.jsonl for only these 500 images\n", + "sample_metadata = []\n", + "with open(os.path.join(ORIGINAL_DIR, \"metadata.jsonl\"), 'r') as f:\n", + " for line in f:\n", + " data = json.loads(line)\n", + " if data['file_name'] in images:\n", + " sample_metadata.append(data)\n", + "\n", + "with open(os.path.join(SAMPLE_DIR, \"metadata.jsonl\"), 'w') as f:\n", + " for entry in sample_metadata:\n", + " f.write(json.dumps(entry) + '\\n')\n", + "\n", + "print(f\"✅ Created sample dataset with {len(images)} images at {SAMPLE_DIR}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "09f78ebf-0434-42c6-b9cf-d80f81fef982", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'dataset' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 20\u001b[39m\n\u001b[32m 3\u001b[39m training_args = TrainingArguments(\n\u001b[32m 4\u001b[39m output_dir=\u001b[33m\"\u001b[39m\u001b[33m./stem_sight_sample_run\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 5\u001b[39m per_device_train_batch_size=\u001b[32m2\u001b[39m,\n\u001b[32m (...)\u001b[39m\u001b[32m 13\u001b[39m report_to=\u001b[33m\"\u001b[39m\u001b[33mnone\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;66;03m# Keep it clean\u001b[39;00m\n\u001b[32m 14\u001b[39m )\n\u001b[32m 16\u001b[39m \u001b[38;5;66;03m# Initialize Trainer with the sample data\u001b[39;00m\n\u001b[32m 17\u001b[39m trainer = Trainer(\n\u001b[32m 18\u001b[39m model=model,\n\u001b[32m 19\u001b[39m args=training_args,\n\u001b[32m---> \u001b[39m\u001b[32m20\u001b[39m train_dataset=\u001b[43mdataset\u001b[49m[\u001b[33m\"\u001b[39m\u001b[33mtrain\u001b[39m\u001b[33m\"\u001b[39m].select(\u001b[38;5;28mrange\u001b[39m(\u001b[32m500\u001b[39m)), \u001b[38;5;66;03m# Only use the 500 sample images\u001b[39;00m\n\u001b[32m 21\u001b[39m data_collator=collator,\n\u001b[32m 22\u001b[39m )\n\u001b[32m 24\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mRunning sample training on M4...\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 25\u001b[39m trainer.train()\n", + "\u001b[31mNameError\u001b[39m: name 'dataset' is not defined" + ] + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0b3c7746-1142-4f17-a961-759716953fa2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights: 100%|█| 484/484 [00:00<00:00, 1864.73it/s, Materializing param=encoder.encoder.layers.3.blocks.\n", + "The tied weights mapping and config for this model specifies to tie decoder.model.decoder.embed_tokens.weight to decoder.lm_head.weight, but both are present in the checkpoints, so we will NOT tie them. You should update the config with `tie_word_embeddings=False` to silence this warning\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Model 'model' is now defined and running on: mps\n" + ] + } + ], + "source": [ + "from transformers import VisionEncoderDecoderModel, DonutProcessor\n", + "import torch\n", + "\n", + "# 1. Setup Device\n", + "device = \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n", + "\n", + "# 2. Load Model and Processor\n", + "model_checkpoint = \"naver-clova-ix/donut-base\"\n", + "processor = DonutProcessor.from_pretrained(model_checkpoint)\n", + "model = VisionEncoderDecoderModel.from_pretrained(model_checkpoint)\n", + "\n", + "# 3. Move model to your M4 GPU\n", + "model.to(device)\n", + "\n", + "print(f\"✅ Model 'model' is now defined and running on: {device}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "71c12e3b-c58d-43fe-8fc5-d87ec8fd0a7c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "📂 Loading dataset from local SSD...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading data: 100%|███████████████████████████████████████████| 52463/52463 [00:00<00:00, 1489664.36files/s]\n", + "Downloading data: 100%|███████████████████████████████████████████| 11240/11240 [00:00<00:00, 1448622.69files/s]\n", + "Generating train split: 52463 examples [00:00, 125679.18 examples/s]\n", + "Generating validation split: 11240 examples [00:00, 127820.00 examples/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🤖 Loading Donut model to M4 GPU...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights: 100%|█| 484/484 [00:00<00:00, 1908.25it/s, Materializing param=encoder.encoder.layers.3.blocks.\n", + "The tied weights mapping and config for this model specifies to tie decoder.model.decoder.embed_tokens.weight to decoder.lm_head.weight, but both are present in the checkpoints, so we will NOT tie them. You should update the config with `tie_word_embeddings=False` to silence this warning\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ 'dataset' and 'model' are now live on: mps\n" + ] + } + ], + "source": [ + "import os\n", + "import torch\n", + "from datasets import load_dataset\n", + "from transformers import VisionEncoderDecoderModel, DonutProcessor\n", + "\n", + "# 1. Paths & Device\n", + "BASE_PATH = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset\"\n", + "DATA_DIR = os.path.join(BASE_PATH, \"vbar_categorical_plots\")\n", + "device = \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n", + "\n", + "# 2. Load Dataset\n", + "print(\"📂 Loading dataset from local SSD...\")\n", + "dataset = load_dataset(\"imagefolder\", data_dir=DATA_DIR)\n", + "\n", + "# 3. Load Model and Processor\n", + "print(\"🤖 Loading Donut model to M4 GPU...\")\n", + "model_checkpoint = \"naver-clova-ix/donut-base\"\n", + "processor = DonutProcessor.from_pretrained(model_checkpoint)\n", + "model = VisionEncoderDecoderModel.from_pretrained(model_checkpoint).to(device)\n", + "\n", + "print(f\"✅ 'dataset' and 'model' are now live on: {device}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "e1f25ece-2593-4957-98cc-39a2850ea26c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running sample training on M4...\n" + ] + }, + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset/vbar_categorical_plots/train/104649.png'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mFileNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[15]\u001b[39m\u001b[32m, line 25\u001b[39m\n\u001b[32m 17\u001b[39m trainer = Trainer(\n\u001b[32m 18\u001b[39m model=model,\n\u001b[32m 19\u001b[39m args=training_args,\n\u001b[32m 20\u001b[39m train_dataset=dataset[\u001b[33m\"\u001b[39m\u001b[33mtrain\u001b[39m\u001b[33m\"\u001b[39m].select(\u001b[38;5;28mrange\u001b[39m(\u001b[32m500\u001b[39m)), \u001b[38;5;66;03m# Only use the 500 sample images\u001b[39;00m\n\u001b[32m 21\u001b[39m data_collator=collator,\n\u001b[32m 22\u001b[39m )\n\u001b[32m 24\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mRunning sample training on M4...\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m25\u001b[39m \u001b[43mtrainer\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:1412\u001b[39m, in \u001b[36mTrainer.train\u001b[39m\u001b[34m(self, resume_from_checkpoint, trial, ignore_keys_for_eval)\u001b[39m\n\u001b[32m 1410\u001b[39m hf_hub_utils.enable_progress_bars()\n\u001b[32m 1411\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1412\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43minner_training_loop\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1413\u001b[39m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m=\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1414\u001b[39m \u001b[43m \u001b[49m\u001b[43mresume_from_checkpoint\u001b[49m\u001b[43m=\u001b[49m\u001b[43mresume_from_checkpoint\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1415\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrial\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtrial\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1416\u001b[39m \u001b[43m \u001b[49m\u001b[43mignore_keys_for_eval\u001b[49m\u001b[43m=\u001b[49m\u001b[43mignore_keys_for_eval\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1417\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:1684\u001b[39m, in \u001b[36mTrainer._inner_training_loop\u001b[39m\u001b[34m(self, batch_size, args, resume_from_checkpoint, trial, ignore_keys_for_eval)\u001b[39m\n\u001b[32m 1682\u001b[39m update_step += \u001b[32m1\u001b[39m\n\u001b[32m 1683\u001b[39m num_batches = args.gradient_accumulation_steps \u001b[38;5;28;01mif\u001b[39;00m update_step != (total_updates - \u001b[32m1\u001b[39m) \u001b[38;5;28;01melse\u001b[39;00m remainder\n\u001b[32m-> \u001b[39m\u001b[32m1684\u001b[39m batch_samples, num_items_in_batch = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mget_batch_samples\u001b[49m\u001b[43m(\u001b[49m\u001b[43mepoch_iterator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_batches\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1685\u001b[39m \u001b[38;5;66;03m# Store the number of batches for current gradient accumulation\u001b[39;00m\n\u001b[32m 1686\u001b[39m \u001b[38;5;66;03m# This is used to correctly scale the loss when the last accumulation step has fewer batches\u001b[39;00m\n\u001b[32m 1687\u001b[39m \u001b[38;5;28mself\u001b[39m.current_gradient_accumulation_steps = \u001b[38;5;28mlen\u001b[39m(batch_samples)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:2146\u001b[39m, in \u001b[36mTrainer.get_batch_samples\u001b[39m\u001b[34m(self, epoch_iterator, num_batches, device)\u001b[39m\n\u001b[32m 2144\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(num_batches):\n\u001b[32m 2145\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m2146\u001b[39m batch_samples.append(\u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mepoch_iterator\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[32m 2147\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[32m 2148\u001b[39m \u001b[38;5;28;01mbreak\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/accelerate/data_loader.py:567\u001b[39m, in \u001b[36mDataLoaderShard.__iter__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 565\u001b[39m \u001b[38;5;66;03m# We iterate one batch ahead to check when we are at the end\u001b[39;00m\n\u001b[32m 566\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m567\u001b[39m current_batch = \u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mdataloader_iter\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 568\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[32m 569\u001b[39m \u001b[38;5;28mself\u001b[39m.end()\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/torch/utils/data/dataloader.py:741\u001b[39m, in \u001b[36m_BaseDataLoaderIter.__next__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 738\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._sampler_iter \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 739\u001b[39m \u001b[38;5;66;03m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[39;00m\n\u001b[32m 740\u001b[39m \u001b[38;5;28mself\u001b[39m._reset() \u001b[38;5;66;03m# type: ignore[call-arg]\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m741\u001b[39m data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_next_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 742\u001b[39m \u001b[38;5;28mself\u001b[39m._num_yielded += \u001b[32m1\u001b[39m\n\u001b[32m 743\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[32m 744\u001b[39m \u001b[38;5;28mself\u001b[39m._dataset_kind == _DatasetKind.Iterable\n\u001b[32m 745\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._IterableDataset_len_called \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 746\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._num_yielded > \u001b[38;5;28mself\u001b[39m._IterableDataset_len_called\n\u001b[32m 747\u001b[39m ):\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/torch/utils/data/dataloader.py:801\u001b[39m, in \u001b[36m_SingleProcessDataLoaderIter._next_data\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 799\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_next_data\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 800\u001b[39m index = \u001b[38;5;28mself\u001b[39m._next_index() \u001b[38;5;66;03m# may raise StopIteration\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m801\u001b[39m data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_dataset_fetcher\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfetch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindex\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# may raise StopIteration\u001b[39;00m\n\u001b[32m 802\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._pin_memory:\n\u001b[32m 803\u001b[39m data = _utils.pin_memory.pin_memory(data, \u001b[38;5;28mself\u001b[39m._pin_memory_device)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/torch/utils/data/_utils/fetch.py:52\u001b[39m, in \u001b[36m_MapDatasetFetcher.fetch\u001b[39m\u001b[34m(self, possibly_batched_index)\u001b[39m\n\u001b[32m 50\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.auto_collation:\n\u001b[32m 51\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m.dataset, \u001b[33m\"\u001b[39m\u001b[33m__getitems__\u001b[39m\u001b[33m\"\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m.dataset.__getitems__:\n\u001b[32m---> \u001b[39m\u001b[32m52\u001b[39m data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mdataset\u001b[49m\u001b[43m.\u001b[49m\u001b[43m__getitems__\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpossibly_batched_index\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 53\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 54\u001b[39m data = [\u001b[38;5;28mself\u001b[39m.dataset[idx] \u001b[38;5;28;01mfor\u001b[39;00m idx \u001b[38;5;129;01min\u001b[39;00m possibly_batched_index]\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/arrow_dataset.py:2945\u001b[39m, in \u001b[36mDataset.__getitems__\u001b[39m\u001b[34m(self, keys)\u001b[39m\n\u001b[32m 2943\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__getitems__\u001b[39m(\u001b[38;5;28mself\u001b[39m, keys: \u001b[38;5;28mlist\u001b[39m) -> \u001b[38;5;28mlist\u001b[39m:\n\u001b[32m 2944\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Can be used to get a batch using a list of integers indices.\"\"\"\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m2945\u001b[39m batch = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[34;43m__getitem__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2946\u001b[39m n_examples = \u001b[38;5;28mlen\u001b[39m(batch[\u001b[38;5;28mnext\u001b[39m(\u001b[38;5;28miter\u001b[39m(batch))])\n\u001b[32m 2947\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m [{col: array[i] \u001b[38;5;28;01mfor\u001b[39;00m col, array \u001b[38;5;129;01min\u001b[39;00m batch.items()} \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n_examples)]\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/arrow_dataset.py:2941\u001b[39m, in \u001b[36mDataset.__getitem__\u001b[39m\u001b[34m(self, key)\u001b[39m\n\u001b[32m 2939\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._format_type \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._format_type \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m (\u001b[33m\"\u001b[39m\u001b[33marrow\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mpandas\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mpolars\u001b[39m\u001b[33m\"\u001b[39m):\n\u001b[32m 2940\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m Column(\u001b[38;5;28mself\u001b[39m, key)\n\u001b[32m-> \u001b[39m\u001b[32m2941\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_getitem\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/arrow_dataset.py:2923\u001b[39m, in \u001b[36mDataset._getitem\u001b[39m\u001b[34m(self, key, **kwargs)\u001b[39m\n\u001b[32m 2921\u001b[39m formatter = get_formatter(format_type, features=\u001b[38;5;28mself\u001b[39m._info.features, **format_kwargs)\n\u001b[32m 2922\u001b[39m pa_subtable = query_table(\u001b[38;5;28mself\u001b[39m._data, key, indices=\u001b[38;5;28mself\u001b[39m._indices)\n\u001b[32m-> \u001b[39m\u001b[32m2923\u001b[39m formatted_output = \u001b[43mformat_table\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2924\u001b[39m \u001b[43m \u001b[49m\u001b[43mpa_subtable\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mformatter\u001b[49m\u001b[43m=\u001b[49m\u001b[43mformatter\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mformat_columns\u001b[49m\u001b[43m=\u001b[49m\u001b[43mformat_columns\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput_all_columns\u001b[49m\u001b[43m=\u001b[49m\u001b[43moutput_all_columns\u001b[49m\n\u001b[32m 2925\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2926\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m formatted_output\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/formatting/formatting.py:658\u001b[39m, in \u001b[36mformat_table\u001b[39m\u001b[34m(table, key, formatter, format_columns, output_all_columns)\u001b[39m\n\u001b[32m 656\u001b[39m python_formatter = PythonFormatter(features=formatter.features)\n\u001b[32m 657\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m format_columns \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m658\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mformatter\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpa_table\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mquery_type\u001b[49m\u001b[43m=\u001b[49m\u001b[43mquery_type\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 659\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m query_type == \u001b[33m\"\u001b[39m\u001b[33mcolumn\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m 660\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m key \u001b[38;5;129;01min\u001b[39;00m format_columns:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/formatting/formatting.py:415\u001b[39m, in \u001b[36mFormatter.__call__\u001b[39m\u001b[34m(self, pa_table, query_type)\u001b[39m\n\u001b[32m 413\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m.format_column(pa_table)\n\u001b[32m 414\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m query_type == \u001b[33m\"\u001b[39m\u001b[33mbatch\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m415\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mformat_batch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpa_table\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/formatting/formatting.py:472\u001b[39m, in \u001b[36mPythonFormatter.format_batch\u001b[39m\u001b[34m(self, pa_table)\u001b[39m\n\u001b[32m 470\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m LazyBatch(pa_table, \u001b[38;5;28mself\u001b[39m)\n\u001b[32m 471\u001b[39m batch = \u001b[38;5;28mself\u001b[39m.python_arrow_extractor().extract_batch(pa_table)\n\u001b[32m--> \u001b[39m\u001b[32m472\u001b[39m batch = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mpython_features_decoder\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdecode_batch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 473\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m batch\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/formatting/formatting.py:234\u001b[39m, in \u001b[36mPythonFeaturesDecoder.decode_batch\u001b[39m\u001b[34m(self, batch)\u001b[39m\n\u001b[32m 233\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mdecode_batch\u001b[39m(\u001b[38;5;28mself\u001b[39m, batch: \u001b[38;5;28mdict\u001b[39m) -> \u001b[38;5;28mdict\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m234\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfeatures\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdecode_batch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.features \u001b[38;5;28;01melse\u001b[39;00m batch\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/features/features.py:2161\u001b[39m, in \u001b[36mFeatures.decode_batch\u001b[39m\u001b[34m(self, batch, token_per_repo_id)\u001b[39m\n\u001b[32m 2157\u001b[39m decoded_batch = {}\n\u001b[32m 2158\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m column_name, column \u001b[38;5;129;01min\u001b[39;00m batch.items():\n\u001b[32m 2159\u001b[39m decoded_batch[column_name] = (\n\u001b[32m 2160\u001b[39m [\n\u001b[32m-> \u001b[39m\u001b[32m2161\u001b[39m \u001b[43mdecode_nested_example\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mcolumn_name\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2162\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m value \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 2163\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 2164\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m value \u001b[38;5;129;01min\u001b[39;00m column\n\u001b[32m 2165\u001b[39m ]\n\u001b[32m 2166\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._column_requires_decoding[column_name]\n\u001b[32m 2167\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m column\n\u001b[32m 2168\u001b[39m )\n\u001b[32m 2169\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m decoded_batch\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/features/features.py:1419\u001b[39m, in \u001b[36mdecode_nested_example\u001b[39m\u001b[34m(schema, obj, token_per_repo_id)\u001b[39m\n\u001b[32m 1416\u001b[39m \u001b[38;5;66;03m# Object with special decoding:\u001b[39;00m\n\u001b[32m 1417\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(schema, \u001b[33m\"\u001b[39m\u001b[33mdecode_example\u001b[39m\u001b[33m\"\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(schema, \u001b[33m\"\u001b[39m\u001b[33mdecode\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[32m 1418\u001b[39m \u001b[38;5;66;03m# we pass the token to read and decode files from private repositories in streaming mode\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1419\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mschema\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdecode_example\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtoken_per_repo_id\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mif\u001b[39;00m obj \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 1420\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m obj\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/datasets/features/image.py:175\u001b[39m, in \u001b[36mImage.decode_example\u001b[39m\u001b[34m(self, value, token_per_repo_id)\u001b[39m\n\u001b[32m 173\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 174\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m is_local_path(path):\n\u001b[32m--> \u001b[39m\u001b[32m175\u001b[39m image = \u001b[43mPIL\u001b[49m\u001b[43m.\u001b[49m\u001b[43mImage\u001b[49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 176\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 177\u001b[39m source_url = path.split(\u001b[33m\"\u001b[39m\u001b[33m::\u001b[39m\u001b[33m\"\u001b[39m)[-\u001b[32m1\u001b[39m]\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/PIL/Image.py:3512\u001b[39m, in \u001b[36mopen\u001b[39m\u001b[34m(fp, mode, formats)\u001b[39m\n\u001b[32m 3510\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m is_path(fp):\n\u001b[32m 3511\u001b[39m filename = os.fspath(fp)\n\u001b[32m-> \u001b[39m\u001b[32m3512\u001b[39m fp = \u001b[43mbuiltins\u001b[49m\u001b[43m.\u001b[49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mrb\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 3513\u001b[39m exclusive_fp = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m 3514\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[31mFileNotFoundError\u001b[39m: [Errno 2] No such file or directory: '/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset/vbar_categorical_plots/train/104649.png'" + ] + } + ], + "source": [ + "from transformers import TrainingArguments, Trainer\n", + "\n", + "training_args = TrainingArguments(\n", + " output_dir=\"./stem_sight_sample_run\",\n", + " per_device_train_batch_size=2,\n", + " gradient_accumulation_steps=4,\n", + " max_steps=100, # Just run 100 steps to test the logic\n", + " learning_rate=5e-5,\n", + " logging_steps=10, # Log every 10 steps to see progress\n", + " save_total_limit=1,\n", + " #use_mps_device=True, # Use your 10-core M4 GPU\n", + " remove_unused_columns=False,\n", + " report_to=\"none\" # Keep it clean\n", + ")\n", + "\n", + "# Initialize Trainer with the sample data\n", + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=dataset[\"train\"].select(range(500)), # Only use the 500 sample images\n", + " data_collator=collator,\n", + ")\n", + "\n", + "print(\"Running sample training on M4...\")\n", + "trainer.train()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9a5423a6-4d03-4638-a57e-d4240cee5e54", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🔄 Re-syncing dataset paths...\n", + "✅ Paths synced. Found 52463 training images.\n" + ] + } + ], + "source": [ + "import os\n", + "from datasets import load_dataset\n", + "\n", + "# Point this EXACTLY to the folder containing your 'train' and 'validation' sub-folders\n", + "DATA_DIR = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset/vbar_categorical_plots\"\n", + "\n", + "print(\"🔄 Re-syncing dataset paths...\")\n", + "# This will look into vbar_categorical_plots/train/png/ automatically\n", + "dataset = load_dataset(\"imagefolder\", data_dir=DATA_DIR)\n", + "\n", + "print(f\"✅ Paths synced. Found {len(dataset['train'])} training images.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8b1479fe-8d1c-45e3-aa94-5146fd58b734", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "❄️ Encoder frozen. GPU focus is now on the Decoder.\n", + "🚀 Launching Ultra-Light training on M4...\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'VisionEncoderDecoderConfig' object has no attribute 'pad_token_id'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[23]\u001b[39m\u001b[32m, line 42\u001b[39m\n\u001b[32m 34\u001b[39m trainer = Trainer(\n\u001b[32m 35\u001b[39m model=model,\n\u001b[32m 36\u001b[39m args=training_args,\n\u001b[32m 37\u001b[39m train_dataset=dataset[\u001b[33m\"\u001b[39m\u001b[33mtrain\u001b[39m\u001b[33m\"\u001b[39m].select(\u001b[38;5;28mrange\u001b[39m(\u001b[32m100\u001b[39m)), \n\u001b[32m 38\u001b[39m data_collator=collator,\n\u001b[32m 39\u001b[39m )\n\u001b[32m 41\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33m🚀 Launching Ultra-Light training on M4...\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m42\u001b[39m \u001b[43mtrainer\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:1412\u001b[39m, in \u001b[36mTrainer.train\u001b[39m\u001b[34m(self, resume_from_checkpoint, trial, ignore_keys_for_eval)\u001b[39m\n\u001b[32m 1410\u001b[39m hf_hub_utils.enable_progress_bars()\n\u001b[32m 1411\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1412\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43minner_training_loop\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1413\u001b[39m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m=\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1414\u001b[39m \u001b[43m \u001b[49m\u001b[43mresume_from_checkpoint\u001b[49m\u001b[43m=\u001b[49m\u001b[43mresume_from_checkpoint\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1415\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrial\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtrial\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1416\u001b[39m \u001b[43m \u001b[49m\u001b[43mignore_keys_for_eval\u001b[49m\u001b[43m=\u001b[49m\u001b[43mignore_keys_for_eval\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1417\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:1742\u001b[39m, in \u001b[36mTrainer._inner_training_loop\u001b[39m\u001b[34m(self, batch_size, args, resume_from_checkpoint, trial, ignore_keys_for_eval)\u001b[39m\n\u001b[32m 1740\u001b[39m sync_context = functools.partial(\u001b[38;5;28mself\u001b[39m.accelerator.no_sync, model=model)\n\u001b[32m 1741\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m sync_context():\n\u001b[32m-> \u001b[39m\u001b[32m1742\u001b[39m tr_loss_step = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtraining_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_items_in_batch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1744\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[32m 1745\u001b[39m args.logging_nan_inf_filter\n\u001b[32m 1746\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_torch_xla_available()\n\u001b[32m 1747\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m (torch.isnan(tr_loss_step) \u001b[38;5;129;01mor\u001b[39;00m torch.isinf(tr_loss_step))\n\u001b[32m 1748\u001b[39m ):\n\u001b[32m 1749\u001b[39m \u001b[38;5;66;03m# if loss is nan or inf simply add the average of previous logged losses\u001b[39;00m\n\u001b[32m 1750\u001b[39m tr_loss = tr_loss + tr_loss / (\u001b[32m1\u001b[39m + \u001b[38;5;28mself\u001b[39m.state.global_step - \u001b[38;5;28mself\u001b[39m._globalstep_last_logged)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:1951\u001b[39m, in \u001b[36mTrainer.training_step\u001b[39m\u001b[34m(self, model, inputs, num_items_in_batch)\u001b[39m\n\u001b[32m 1948\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m loss_mb.reduce_mean().detach().to(\u001b[38;5;28mself\u001b[39m.args.device)\n\u001b[32m 1950\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m.compute_loss_context_manager():\n\u001b[32m-> \u001b[39m\u001b[32m1951\u001b[39m loss = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mcompute_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_items_in_batch\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnum_items_in_batch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1953\u001b[39m \u001b[38;5;28;01mdel\u001b[39;00m inputs\n\u001b[32m 1954\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[32m 1955\u001b[39m \u001b[38;5;28mself\u001b[39m.args.torch_empty_cache_steps \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 1956\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m.state.global_step % \u001b[38;5;28mself\u001b[39m.args.torch_empty_cache_steps == \u001b[32m0\u001b[39m\n\u001b[32m 1957\u001b[39m ):\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:2022\u001b[39m, in \u001b[36mTrainer.compute_loss\u001b[39m\u001b[34m(self, model, inputs, return_outputs, num_items_in_batch)\u001b[39m\n\u001b[32m 2020\u001b[39m kwargs[\u001b[33m\"\u001b[39m\u001b[33mnum_items_in_batch\u001b[39m\u001b[33m\"\u001b[39m] = num_items_in_batch\n\u001b[32m 2021\u001b[39m inputs = {**inputs, **kwargs}\n\u001b[32m-> \u001b[39m\u001b[32m2022\u001b[39m outputs = \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2024\u001b[39m \u001b[38;5;66;03m# User-defined compute_loss function\u001b[39;00m\n\u001b[32m 2025\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.compute_loss_func \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/torch/nn/modules/module.py:1776\u001b[39m, in \u001b[36mModule._wrapped_call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 1774\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._compiled_call_impl(*args, **kwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[32m 1775\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1776\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/torch/nn/modules/module.py:1787\u001b[39m, in \u001b[36mModule._call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 1782\u001b[39m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[32m 1783\u001b[39m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[32m 1784\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m._backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_pre_hooks\n\u001b[32m 1785\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[32m 1786\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[32m-> \u001b[39m\u001b[32m1787\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1789\u001b[39m result = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 1790\u001b[39m called_always_called_hooks = \u001b[38;5;28mset\u001b[39m()\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py:412\u001b[39m, in \u001b[36mVisionEncoderDecoderModel.forward\u001b[39m\u001b[34m(self, pixel_values, decoder_input_ids, decoder_attention_mask, encoder_outputs, past_key_values, decoder_inputs_embeds, labels, use_cache, output_attentions, output_hidden_states, return_dict, cache_position, **kwargs)\u001b[39m\n\u001b[32m 408\u001b[39m encoder_attention_mask = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 410\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (labels \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m) \u001b[38;5;129;01mand\u001b[39;00m (decoder_input_ids \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m decoder_inputs_embeds \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[32m 411\u001b[39m decoder_input_ids = shift_tokens_right(\n\u001b[32m--> \u001b[39m\u001b[32m412\u001b[39m labels, \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mconfig\u001b[49m\u001b[43m.\u001b[49m\u001b[43mpad_token_id\u001b[49m, \u001b[38;5;28mself\u001b[39m.config.decoder_start_token_id\n\u001b[32m 413\u001b[39m )\n\u001b[32m 415\u001b[39m \u001b[38;5;66;03m# Decode\u001b[39;00m\n\u001b[32m 416\u001b[39m decoder_outputs = \u001b[38;5;28mself\u001b[39m.decoder(\n\u001b[32m 417\u001b[39m input_ids=decoder_input_ids,\n\u001b[32m 418\u001b[39m attention_mask=decoder_attention_mask,\n\u001b[32m (...)\u001b[39m\u001b[32m 428\u001b[39m **kwargs_decoder,\n\u001b[32m 429\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/configuration_utils.py:164\u001b[39m, in \u001b[36mPreTrainedConfig.__getattribute__\u001b[39m\u001b[34m(self, key)\u001b[39m\n\u001b[32m 162\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m key != \u001b[33m\"\u001b[39m\u001b[33mattribute_map\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m key \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28msuper\u001b[39m().\u001b[34m__getattribute__\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mattribute_map\u001b[39m\u001b[33m\"\u001b[39m):\n\u001b[32m 163\u001b[39m key = \u001b[38;5;28msuper\u001b[39m().\u001b[34m__getattribute__\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mattribute_map\u001b[39m\u001b[33m\"\u001b[39m)[key]\n\u001b[32m--> \u001b[39m\u001b[32m164\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[34;43m__getattribute__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[31mAttributeError\u001b[39m: 'VisionEncoderDecoderConfig' object has no attribute 'pad_token_id'" + ] + } + ], + "source": [ + "import torch\n", + "import gc\n", + "import os\n", + "from transformers import TrainingArguments, Trainer\n", + "\n", + "# 1. Clear memory & setup device\n", + "gc.collect()\n", + "torch.mps.empty_cache()\n", + "device = \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n", + "\n", + "# 2. Hard-limit the image size\n", + "processor.image_processor.size = {\"height\": 480, \"width\": 640}\n", + "\n", + "# 3. Freeze the Encoder (Swin Transformer)\n", + "model.encoder.requires_grad_(False)\n", + "print(\"❄️ Encoder frozen. GPU focus is now on the Decoder.\")\n", + "\n", + "# 4. Ultra-conservative Training Args (Cleaned)\n", + "training_args = TrainingArguments(\n", + " output_dir=\"./stem_sight_ultra_light\",\n", + " per_device_train_batch_size=1,\n", + " gradient_accumulation_steps=16, \n", + " max_steps=50, \n", + " learning_rate=1e-4, \n", + " logging_steps=5,\n", + " gradient_checkpointing=True, \n", + " remove_unused_columns=False,\n", + " report_to=\"none\"\n", + ")\n", + "\n", + "# 5. Environment variable check\n", + "os.environ[\"PYTORCH_MPS_HIGH_WATERMARK_RATIO\"] = \"0.0\"\n", + "\n", + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=dataset[\"train\"].select(range(100)), \n", + " data_collator=collator,\n", + ")\n", + "\n", + "print(\"🚀 Launching Ultra-Light training on M4...\")\n", + "trainer.train()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "925296b1-82ff-4871-aff7-dd12ca39073d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🔄 Force-refreshing dataset and clearing path cache...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading data: 100%|███████████████████████████████████████████| 52463/52463 [00:00<00:00, 1464784.39files/s]\n", + "Downloading data: 100%|███████████████████████████████████████████| 11240/11240 [00:00<00:00, 1421497.87files/s]\n", + "Generating train split: 52463 examples [00:00, 124120.49 examples/s]\n", + "Generating validation split: 11240 examples [00:00, 125642.89 examples/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Success! Found 52463 images. First image loaded correctly.\n" + ] + } + ], + "source": [ + "import os\n", + "from datasets import load_dataset\n", + "\n", + "# Path to the specialized folder\n", + "DATA_DIR = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset/vbar_categorical_plots\"\n", + "\n", + "print(\"🔄 Force-refreshing dataset and clearing path cache...\")\n", + "\n", + "# We use split=\"train\" to verify immediately if it can see the images\n", + "dataset = load_dataset(\n", + " \"imagefolder\", \n", + " data_dir=DATA_DIR,\n", + " drop_labels=True, # We use the JSONL for labels, not folder names\n", + " download_mode=\"force_redownload\" \n", + ")\n", + "\n", + "# Test a single image access immediately\n", + "try:\n", + " test_img = dataset[\"train\"][0][\"image\"]\n", + " print(f\"✅ Success! Found {len(dataset['train'])} images. First image loaded correctly.\")\n", + "except Exception as e:\n", + " print(f\"❌ Still failing. Error: {e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "6c1d756a-843e-4cf4-9414-bba010f5ff3a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pad Token ID: 1\n", + "Decoder Start Token ID: 3\n" + ] + } + ], + "source": [ + "# 1. Manually sync the token IDs from the decoder to the main config\n", + "model.config.pad_token_id = processor.tokenizer.pad_token_id\n", + "model.config.decoder_start_token_id = processor.tokenizer.convert_tokens_to_ids([''])[0]\n", + "\n", + "# 2. Double check they are set\n", + "print(f\"Pad Token ID: {model.config.pad_token_id}\")\n", + "print(f\"Decoder Start Token ID: {model.config.decoder_start_token_id}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "712a0774-144f-4cfa-8271-49d146424b55", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pad Token ID: 1\n", + "Decoder Start Token ID: 3\n" + ] + } + ], + "source": [ + "# 1. Manually sync the token IDs from the decoder to the main config\n", + "model.config.pad_token_id = processor.tokenizer.pad_token_id\n", + "model.config.decoder_start_token_id = processor.tokenizer.convert_tokens_to_ids([''])[0]\n", + "\n", + "# 2. Double check they are set\n", + "print(f\"Pad Token ID: {model.config.pad_token_id}\")\n", + "print(f\"Decoder Start Token ID: {model.config.decoder_start_token_id}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "c17f5001-7c31-4299-bb58-5217b52405c1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights: 100%|█| 484/484 [00:00<00:00, 1606.59it/s, Materializing param=encoder.encoder.layers.3.blocks.\n", + "The tied weights mapping and config for this model specifies to tie decoder.model.decoder.embed_tokens.weight to decoder.lm_head.weight, but both are present in the checkpoints, so we will NOT tie them. You should update the config with `tie_word_embeddings=False` to silence this warning\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Encoder unfrozen to fix CheckpointError. Adjusting resolution for 16GB RAM safety.\n", + "🚀 Starting VBar Specialist Training on M4...\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [ 14/9837 01:36 < 21:59:55, 0.12 it/s, Epoch 0.00/3]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining LossValidation Loss

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[32]\u001b[39m\u001b[32m, line 86\u001b[39m\n\u001b[32m 77\u001b[39m trainer = Trainer(\n\u001b[32m 78\u001b[39m model=model,\n\u001b[32m 79\u001b[39m args=training_args,\n\u001b[32m (...)\u001b[39m\u001b[32m 82\u001b[39m data_collator=collator,\n\u001b[32m 83\u001b[39m )\n\u001b[32m 85\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33m🚀 Starting VBar Specialist Training on M4...\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m86\u001b[39m \u001b[43mtrainer\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:1412\u001b[39m, in \u001b[36mTrainer.train\u001b[39m\u001b[34m(self, resume_from_checkpoint, trial, ignore_keys_for_eval)\u001b[39m\n\u001b[32m 1410\u001b[39m hf_hub_utils.enable_progress_bars()\n\u001b[32m 1411\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1412\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43minner_training_loop\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1413\u001b[39m \u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m=\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1414\u001b[39m \u001b[43m \u001b[49m\u001b[43mresume_from_checkpoint\u001b[49m\u001b[43m=\u001b[49m\u001b[43mresume_from_checkpoint\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1415\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrial\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtrial\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1416\u001b[39m \u001b[43m \u001b[49m\u001b[43mignore_keys_for_eval\u001b[49m\u001b[43m=\u001b[49m\u001b[43mignore_keys_for_eval\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1417\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:1742\u001b[39m, in \u001b[36mTrainer._inner_training_loop\u001b[39m\u001b[34m(self, batch_size, args, resume_from_checkpoint, trial, ignore_keys_for_eval)\u001b[39m\n\u001b[32m 1740\u001b[39m sync_context = functools.partial(\u001b[38;5;28mself\u001b[39m.accelerator.no_sync, model=model)\n\u001b[32m 1741\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m sync_context():\n\u001b[32m-> \u001b[39m\u001b[32m1742\u001b[39m tr_loss_step = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtraining_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_items_in_batch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1744\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[32m 1745\u001b[39m args.logging_nan_inf_filter\n\u001b[32m 1746\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m is_torch_xla_available()\n\u001b[32m 1747\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m (torch.isnan(tr_loss_step) \u001b[38;5;129;01mor\u001b[39;00m torch.isinf(tr_loss_step))\n\u001b[32m 1748\u001b[39m ):\n\u001b[32m 1749\u001b[39m \u001b[38;5;66;03m# if loss is nan or inf simply add the average of previous logged losses\u001b[39;00m\n\u001b[32m 1750\u001b[39m tr_loss = tr_loss + tr_loss / (\u001b[32m1\u001b[39m + \u001b[38;5;28mself\u001b[39m.state.global_step - \u001b[38;5;28mself\u001b[39m._globalstep_last_logged)\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/transformers/trainer.py:1979\u001b[39m, in \u001b[36mTrainer.training_step\u001b[39m\u001b[34m(***failed resolving arguments***)\u001b[39m\n\u001b[32m 1976\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.accelerator.distributed_type == DistributedType.DEEPSPEED:\n\u001b[32m 1977\u001b[39m kwargs[\u001b[33m\"\u001b[39m\u001b[33mscale_wrt_gas\u001b[39m\u001b[33m\"\u001b[39m] = \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1979\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43maccelerator\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43mloss\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1981\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m loss.detach()\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/accelerate/accelerator.py:2852\u001b[39m, in \u001b[36mAccelerator.backward\u001b[39m\u001b[34m(self, loss, **kwargs)\u001b[39m\n\u001b[32m 2850\u001b[39m \u001b[38;5;28mself\u001b[39m.lomo_backward(loss, learning_rate)\n\u001b[32m 2851\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m2852\u001b[39m \u001b[43mloss\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/torch/_tensor.py:630\u001b[39m, in \u001b[36mTensor.backward\u001b[39m\u001b[34m(self, gradient, retain_graph, create_graph, inputs)\u001b[39m\n\u001b[32m 620\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 621\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[32m 622\u001b[39m Tensor.backward,\n\u001b[32m 623\u001b[39m (\u001b[38;5;28mself\u001b[39m,),\n\u001b[32m (...)\u001b[39m\u001b[32m 628\u001b[39m inputs=inputs,\n\u001b[32m 629\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m630\u001b[39m \u001b[43mtorch\u001b[49m\u001b[43m.\u001b[49m\u001b[43mautograd\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 631\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m=\u001b[49m\u001b[43minputs\u001b[49m\n\u001b[32m 632\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/torch/autograd/__init__.py:364\u001b[39m, in \u001b[36mbackward\u001b[39m\u001b[34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[39m\n\u001b[32m 359\u001b[39m retain_graph = create_graph\n\u001b[32m 361\u001b[39m \u001b[38;5;66;03m# The reason we repeat the same comment below is that\u001b[39;00m\n\u001b[32m 362\u001b[39m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[32m 363\u001b[39m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m364\u001b[39m \u001b[43m_engine_run_backward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 365\u001b[39m \u001b[43m \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 366\u001b[39m \u001b[43m \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 367\u001b[39m \u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 368\u001b[39m \u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 369\u001b[39m \u001b[43m \u001b[49m\u001b[43minputs_tuple\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 370\u001b[39m \u001b[43m \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 371\u001b[39m \u001b[43m \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 372\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m/Library/Frameworks/Python.framework/Versions/3.14/lib/python3.14/site-packages/torch/autograd/graph.py:865\u001b[39m, in \u001b[36m_engine_run_backward\u001b[39m\u001b[34m(t_outputs, *args, **kwargs)\u001b[39m\n\u001b[32m 863\u001b[39m unregister_hooks = _register_logging_hooks_on_whole_graph(t_outputs)\n\u001b[32m 864\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m865\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mVariable\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_execution_engine\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[32m 866\u001b[39m \u001b[43m \u001b[49m\u001b[43mt_outputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\n\u001b[32m 867\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# Calls into the C++ engine to run the backward pass\u001b[39;00m\n\u001b[32m 868\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[32m 869\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m attach_logging_hooks:\n", + "\u001b[31mKeyboardInterrupt\u001b[39m: " + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "import torch\n", + "import gc\n", + "from datasets import load_dataset\n", + "from transformers import (\n", + " DonutProcessor, \n", + " VisionEncoderDecoderModel, \n", + " TrainingArguments, \n", + " Trainer\n", + ")\n", + "\n", + "# 1. HARDWARE & MEMORY SETUP\n", + "os.environ[\"PYTORCH_MPS_HIGH_WATERMARK_RATIO\"] = \"0.0\" \n", + "device = \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n", + "gc.collect()\n", + "torch.mps.empty_cache()\n", + "\n", + "# 2. PATHS\n", + "BASE_PATH = \"/Users/akshatchauhan7/Documents/Documents/Projects/Spectra/PlotQA-Dataset\"\n", + "DATA_DIR = os.path.join(BASE_PATH, \"vbar_categorical_plots\")\n", + "\n", + "# 3. LOAD MODEL & PROCESSOR\n", + "model_id = \"naver-clova-ix/donut-base\"\n", + "processor = DonutProcessor.from_pretrained(model_id)\n", + "model = VisionEncoderDecoderModel.from_pretrained(model_id)\n", + "\n", + "# ARCHITECTURE SYNC\n", + "model.config.pad_token_id = processor.tokenizer.pad_token_id\n", + "model.config.decoder_start_token_id = processor.tokenizer.convert_tokens_to_ids([''])[0]\n", + "model.config.tie_word_embeddings = False \n", + "model.to(device)\n", + "\n", + "# 4. FIX CHECKPOINTERROR: UNFREEZE ENCODER\n", + "# Checkpoint logic fails on MPS when layers are frozen\n", + "model.encoder.requires_grad_(True)\n", + "print(\"✅ Encoder unfrozen to fix CheckpointError. Adjusting resolution for 16GB RAM safety.\")\n", + "\n", + "# 5. DATA LOADING\n", + "dataset = load_dataset(\"imagefolder\", data_dir=DATA_DIR)\n", + "\n", + "# 6. DATA COLLATOR (Ultra-Conservative for 16GB)\n", + "def collator(batch):\n", + " # Reduced resolution to 384x512 to offset memory of un-frozen encoder\n", + " pixel_values = [processor(item[\"image\"].convert(\"RGB\"), size={\"height\": 384, \"width\": 512}, return_tensors=\"pt\").pixel_values for item in batch]\n", + " pixel_values = torch.cat(pixel_values).to(device)\n", + " \n", + " # Process text labels (max_length reduced to 96 for speed/memory)\n", + " labels = [json.loads(item[\"ground_truth\"])[\"gt_parse\"] for item in batch]\n", + " labels_batch = processor.tokenizer(\n", + " labels, padding=\"max_length\", truncation=True, max_length=96, return_tensors=\"pt\"\n", + " ).input_ids.to(device)\n", + " \n", + " labels_batch[labels_batch == processor.tokenizer.pad_token_id] = -100\n", + " \n", + " return {\"pixel_values\": pixel_values, \"labels\": labels_batch}\n", + "\n", + "# 7. TRAINING ARGUMENTS (Stable M4 Setup)\n", + "training_args = TrainingArguments(\n", + " output_dir=\"./stem_sight_vbar_final\",\n", + " per_device_train_batch_size=1, \n", + " gradient_accumulation_steps=16, \n", + " num_train_epochs=3, \n", + " learning_rate=2e-5, # Lowered for full-model fine-tuning\n", + " logging_steps=10,\n", + " save_steps=500,\n", + " eval_strategy=\"steps\",\n", + " eval_steps=500,\n", + " save_total_limit=2,\n", + " remove_unused_columns=False, \n", + " gradient_checkpointing=True, \n", + " dataloader_num_workers=0, # Zero workers prevents Segfaults on M4\n", + " report_to=\"none\"\n", + ")\n", + "\n", + "# 8. INITIALIZE & TRAIN\n", + "trainer = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=dataset[\"train\"],\n", + " eval_dataset=dataset[\"validation\"],\n", + " data_collator=collator,\n", + ")\n", + "\n", + "print(f\"🚀 Starting VBar Specialist Training on M4...\")\n", + "trainer.train()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59de4971-ab0b-4969-bcf8-c4925daf44a4", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/Test.ipynb b/notebooks/Test.ipynb new file mode 100644 index 0000000..ae8928e --- /dev/null +++ b/notebooks/Test.ipynb @@ -0,0 +1,5277 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "ac22f21d-bd06-4843-99fc-a16bf7dabda5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting graphvision-ai==0.2.4\n", + " Downloading graphvision_ai-0.2.4-py3-none-any.whl (11 kB)\n", + "Requirement already satisfied: Pillow in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from graphvision-ai==0.2.4) (12.0.0)\n", + "Requirement already satisfied: easyocr in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from graphvision-ai==0.2.4) (1.7.2)\n", + "Requirement already satisfied: opencv-python-headless in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from graphvision-ai==0.2.4) (4.8.1.78)\n", + "Requirement already satisfied: torchvision in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from graphvision-ai==0.2.4) (0.25.0)\n", + "Requirement already satisfied: huggingface_hub in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from graphvision-ai==0.2.4) (1.3.7)\n", + "Requirement already satisfied: torch in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from graphvision-ai==0.2.4) (2.10.0)\n", + "Requirement already satisfied: numpy in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from graphvision-ai==0.2.4) (2.2.6)\n", + "Requirement already satisfied: ultralytics in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from graphvision-ai==0.2.4) (8.4.19)\n", + "Requirement already satisfied: Shapely in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from easyocr->graphvision-ai==0.2.4) (2.1.2)\n", + "Requirement already satisfied: pyclipper in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from easyocr->graphvision-ai==0.2.4) (1.4.0)\n", + "Requirement already satisfied: PyYAML in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from easyocr->graphvision-ai==0.2.4) (6.0.3)\n", + "Requirement already satisfied: python-bidi in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from easyocr->graphvision-ai==0.2.4) (0.6.7)\n", + "Requirement already satisfied: ninja in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from easyocr->graphvision-ai==0.2.4) (1.13.0)\n", + "Requirement already satisfied: scipy in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from easyocr->graphvision-ai==0.2.4) (1.15.3)\n", + "Requirement already satisfied: scikit-image in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from easyocr->graphvision-ai==0.2.4) (0.25.2)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from torch->graphvision-ai==0.2.4) (4.15.0)\n", + "Requirement already satisfied: sympy>=1.13.3 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from torch->graphvision-ai==0.2.4) (1.14.0)\n", + "Requirement already satisfied: networkx>=2.5.1 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from torch->graphvision-ai==0.2.4) (3.4.2)\n", + "Requirement already satisfied: filelock in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from torch->graphvision-ai==0.2.4) (3.20.1)\n", + "Requirement already satisfied: fsspec>=0.8.5 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from torch->graphvision-ai==0.2.4) (2025.10.0)\n", + "Requirement already satisfied: jinja2 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from torch->graphvision-ai==0.2.4) (3.1.6)\n", + "Requirement already satisfied: httpx<1,>=0.23.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from huggingface_hub->graphvision-ai==0.2.4) (0.28.1)\n", + "Requirement already satisfied: shellingham in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from huggingface_hub->graphvision-ai==0.2.4) (1.5.4)\n", + "Requirement already satisfied: hf-xet<2.0.0,>=1.2.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from huggingface_hub->graphvision-ai==0.2.4) (1.2.0)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from huggingface_hub->graphvision-ai==0.2.4) (4.67.1)\n", + "Requirement already satisfied: typer-slim in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from huggingface_hub->graphvision-ai==0.2.4) (0.21.1)\n", + "Requirement already satisfied: packaging>=20.9 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from huggingface_hub->graphvision-ai==0.2.4) (25.0)\n", + "Requirement already satisfied: opencv-python>=4.6.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from ultralytics->graphvision-ai==0.2.4) (4.13.0.92)\n", + "Requirement already satisfied: requests>=2.23.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from ultralytics->graphvision-ai==0.2.4) (2.32.5)\n", + "Requirement already satisfied: polars>=0.20.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from ultralytics->graphvision-ai==0.2.4) (1.38.1)\n", + "Requirement already satisfied: matplotlib>=3.3.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from ultralytics->graphvision-ai==0.2.4) (3.10.7)\n", + "Requirement already satisfied: ultralytics-thop>=2.0.18 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from ultralytics->graphvision-ai==0.2.4) (2.0.18)\n", + "Requirement already satisfied: psutil>=5.8.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from ultralytics->graphvision-ai==0.2.4) (7.1.3)\n", + "Requirement already satisfied: anyio in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from httpx<1,>=0.23.0->huggingface_hub->graphvision-ai==0.2.4) (4.12.1)\n", + "Requirement already satisfied: idna in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from httpx<1,>=0.23.0->huggingface_hub->graphvision-ai==0.2.4) (3.11)\n", + "Requirement already satisfied: httpcore==1.* in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from httpx<1,>=0.23.0->huggingface_hub->graphvision-ai==0.2.4) (1.0.9)\n", + "Requirement already satisfied: certifi in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from httpx<1,>=0.23.0->huggingface_hub->graphvision-ai==0.2.4) (2025.11.12)\n", + "Requirement already satisfied: h11>=0.16 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from httpcore==1.*->httpx<1,>=0.23.0->huggingface_hub->graphvision-ai==0.2.4) (0.16.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from matplotlib>=3.3.0->ultralytics->graphvision-ai==0.2.4) (2.9.0.post0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from matplotlib>=3.3.0->ultralytics->graphvision-ai==0.2.4) (1.3.2)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from matplotlib>=3.3.0->ultralytics->graphvision-ai==0.2.4) (1.4.9)\n", + "Requirement already satisfied: cycler>=0.10 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from matplotlib>=3.3.0->ultralytics->graphvision-ai==0.2.4) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from matplotlib>=3.3.0->ultralytics->graphvision-ai==0.2.4) (4.60.1)\n", + "Requirement already satisfied: pyparsing>=3 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from matplotlib>=3.3.0->ultralytics->graphvision-ai==0.2.4) (3.2.5)\n", + "Requirement already satisfied: polars-runtime-32==1.38.1 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from polars>=0.20.0->ultralytics->graphvision-ai==0.2.4) (1.38.1)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from requests>=2.23.0->ultralytics->graphvision-ai==0.2.4) (3.4.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from requests>=2.23.0->ultralytics->graphvision-ai==0.2.4) (2.5.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from sympy>=1.13.3->torch->graphvision-ai==0.2.4) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from jinja2->torch->graphvision-ai==0.2.4) (3.0.3)\n", + "Requirement already satisfied: imageio!=2.35.0,>=2.33 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from scikit-image->easyocr->graphvision-ai==0.2.4) (2.37.2)\n", + "Requirement already satisfied: lazy-loader>=0.4 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from scikit-image->easyocr->graphvision-ai==0.2.4) (0.4)\n", + "Requirement already satisfied: tifffile>=2022.8.12 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from scikit-image->easyocr->graphvision-ai==0.2.4) (2025.5.10)\n", + "Requirement already satisfied: click>=8.0.0 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from typer-slim->huggingface_hub->graphvision-ai==0.2.4) (8.3.1)\n", + "Requirement already satisfied: six>=1.5 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib>=3.3.0->ultralytics->graphvision-ai==0.2.4) (1.17.0)\n", + "Requirement already satisfied: exceptiongroup>=1.0.2 in /Users/aryangahlot/.pyenv/versions/3.10.12/envs/tfenv/lib/python3.10/site-packages (from anyio->httpx<1,>=0.23.0->huggingface_hub->graphvision-ai==0.2.4) (1.3.1)\n", + "Installing collected packages: graphvision-ai\n", + " Attempting uninstall: graphvision-ai\n", + " Found existing installation: graphvision-ai 0.2.3\n", + " Uninstalling graphvision-ai-0.2.3:\n", + " Successfully uninstalled graphvision-ai-0.2.3\n", + "Successfully installed graphvision-ai-0.2.4\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m26.0.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49m/Users/aryangahlot/.pyenv/versions/tfenv/bin/python -m pip install --upgrade pip\u001b[0m\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install --upgrade graphvision-ai==0.2.4" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fa403a85-ff61-4d59-9004-f3743d7f73b5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/aryangahlot/.pyenv/versions/tfenv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up GraphVision AI Models from Hugging Face...\n", + "\n", + "🚀 Analyzing: ./../Test/PieChart.png\n", + "----------------------------------------\n", + "📊 Detected Chart Type: PIE\n", + "{\n", + " \"chart_type\": \"pie\",\n", + " \"title\": \"Tha Learning App\",\n", + " \"data\": {\n", + " \"Mathematics\": 30.34,\n", + " \"Science\": 23.11,\n", + " \"Social science\": 16.99,\n", + " \"English\": 22.5,\n", + " \"Hindi\": 7.07\n", + " }\n", + "}\n" + ] + } + ], + "source": [ + "from graphvision import GraphExtractor\n", + "\n", + "# Initializes the class and downloads weights from Hugging Face once\n", + "extractor = GraphExtractor() \n", + "\n", + "# Fast extractions since the models are already loaded in memory\n", + "json_data1 = extractor.extract(\"./../Test/PieChart.png\")\n", + "# json_data2 = extractor.extract(\"./../FigureQA_Dataset/no_annot_test2/png/1.png\")\n", + "\n", + "print(json_data1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5e6be9af-c5b8-4566-9281-b28a001fc5e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting transformers\n", + " Downloading transformers-5.3.0-py3-none-any.whl.metadata (32 kB)\n", + "Requirement already satisfied: torch in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (2.10.0)\n", + "Requirement already satisfied: pillow in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (12.0.0)\n", + "Collecting huggingface-hub<2.0,>=1.3.0 (from transformers)\n", + " Downloading huggingface_hub-1.7.1-py3-none-any.whl.metadata (13 kB)\n", + "Requirement already satisfied: numpy>=1.17 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from transformers) (2.2.6)\n", + "Requirement already satisfied: packaging>=20.0 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from transformers) (25.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from transformers) (6.0.3)\n", + "Requirement already satisfied: regex!=2019.12.17 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from transformers) (2025.11.3)\n", + "Collecting tokenizers<=0.23.0,>=0.22.0 (from transformers)\n", + " Downloading tokenizers-0.22.2-cp39-abi3-macosx_11_0_arm64.whl.metadata (7.3 kB)\n", + "Collecting typer (from transformers)\n", + " Downloading typer-0.24.1-py3-none-any.whl.metadata (16 kB)\n", + "Requirement already satisfied: safetensors>=0.4.3 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from transformers) (0.7.0)\n", + "Requirement already satisfied: tqdm>=4.27 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from transformers) (4.67.1)\n", + "Requirement already satisfied: filelock in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from torch) (3.20.0)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from torch) (4.15.0)\n", + "Requirement already satisfied: setuptools in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from torch) (80.9.0)\n", + "Requirement already satisfied: sympy>=1.13.3 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from torch) (1.14.0)\n", + "Requirement already satisfied: networkx>=2.5.1 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from torch) (3.6.1)\n", + "Requirement already satisfied: jinja2 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from torch) (3.1.6)\n", + "Requirement already satisfied: fsspec>=0.8.5 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from torch) (2025.10.0)\n", + "Collecting hf-xet<2.0.0,>=1.4.2 (from huggingface-hub<2.0,>=1.3.0->transformers)\n", + " Downloading hf_xet-1.4.2-cp37-abi3-macosx_11_0_arm64.whl.metadata (4.9 kB)\n", + "Requirement already satisfied: httpx<1,>=0.23.0 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (0.28.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from sympy>=1.13.3->torch) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from jinja2->torch) (3.0.3)\n", + "Requirement already satisfied: click>=8.2.1 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from typer->transformers) (8.3.1)\n", + "Requirement already satisfied: shellingham>=1.3.0 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from typer->transformers) (1.5.4)\n", + "Requirement already satisfied: rich>=12.3.0 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from typer->transformers) (14.2.0)\n", + "Requirement already satisfied: annotated-doc>=0.0.2 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from typer->transformers) (0.0.4)\n", + "Requirement already satisfied: anyio in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (4.12.0)\n", + "Requirement already satisfied: certifi in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (2025.11.12)\n", + "Requirement already satisfied: httpcore==1.* in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (1.0.9)\n", + "Requirement already satisfied: idna in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (3.11)\n", + "Requirement already satisfied: h11>=0.16 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from httpcore==1.*->httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (0.16.0)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from rich>=12.3.0->typer->transformers) (4.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from rich>=12.3.0->typer->transformers) (2.19.2)\n", + "Requirement already satisfied: mdurl~=0.1 in /Users/aryangahlot/.pyenv/versions/3.12.12/lib/python3.12/site-packages (from markdown-it-py>=2.2.0->rich>=12.3.0->typer->transformers) (0.1.2)\n", + "Downloading transformers-5.3.0-py3-none-any.whl (10.7 MB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.7/10.7 MB\u001b[0m \u001b[31m25.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m1m20.3 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\n", + "\u001b[?25hDownloading huggingface_hub-1.7.1-py3-none-any.whl (616 kB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m616.3/616.3 kB\u001b[0m \u001b[31m20.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading tokenizers-0.22.2-cp39-abi3-macosx_11_0_arm64.whl (3.0 MB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.0/3.0 MB\u001b[0m \u001b[31m42.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading typer-0.24.1-py3-none-any.whl (56 kB)\n", + "Downloading hf_xet-1.4.2-cp37-abi3-macosx_11_0_arm64.whl (3.6 MB)\n", + "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.6/3.6 MB\u001b[0m \u001b[31m20.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: hf-xet, typer, huggingface-hub, tokenizers, transformers\n", + " Attempting uninstall: hf-xet\n", + " Found existing installation: hf-xet 1.2.0\n", + " Uninstalling hf-xet-1.2.0:\n", + " Successfully uninstalled hf-xet-1.2.0\n", + " Attempting uninstall: huggingface-hub\n", + " Found existing installation: huggingface_hub 1.1.7\n", + " Uninstalling huggingface_hub-1.1.7:\n", + " Successfully uninstalled huggingface_hub-1.1.7\n", + "Successfully installed hf-xet-1.4.2 huggingface-hub-1.7.1 tokenizers-0.22.2 transformers-5.3.0 typer-0.24.1\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m26.0.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n" + ] + } + ], + "source": [ + "!pip install transformers torch pillow" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e4ecc8e2-8b2f-4ef4-ad42-3e512ca067fc", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import torch\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "from transformers import Pix2StructProcessor, Pix2StructForConditionalGeneration\n", + "\n", + "from graphvision import GraphExtractor" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0b64bb58-63d9-41ba-ad38-27533d28980c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n", + "The image processor of type `Pix2StructImageProcessor` is now loaded as a fast processor by default, even if the model checkpoint was saved with a slow processor. This is a breaking change and may produce slightly different outputs. To continue using the slow processor, instantiate this class with `use_fast=False`. \n", + "Loading weights: 100%|███████████████████████████████████████████████████| 285/285 [00:00<00:00, 1831.83it/s, Materializing param=encoder.layernorm.weight]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up GraphVision AI Models from Hugging Face...\n" + ] + } + ], + "source": [ + "# DePlot\n", + "processor = Pix2StructProcessor.from_pretrained(\"google/deplot\")\n", + "model = Pix2StructForConditionalGeneration.from_pretrained(\"google/deplot\")\n", + "\n", + "device = \"mps\" if torch.cuda.is_available() else \"cpu\"\n", + "model.to(device)\n", + "\n", + "# GraphVision\n", + "extractor = GraphExtractor()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6be48014-9dbb-4ece-8e6f-83acee3f2e17", + "metadata": {}, + "outputs": [], + "source": [ + "def run_deplot(image_path):\n", + "\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + "\n", + " inputs = processor(\n", + " images=image,\n", + " text=\"Generate underlying data table of the figure below:\",\n", + " return_tensors=\"pt\"\n", + " ).to(device)\n", + "\n", + " start = time.time()\n", + "\n", + " predictions = model.generate(**inputs, max_new_tokens=512)\n", + "\n", + " end = time.time()\n", + "\n", + " output = processor.decode(predictions[0], skip_special_tokens=True)\n", + "\n", + " print(\"\\nDePlot Output:\\n\")\n", + " print(output)\n", + "\n", + " print(\"\\nTime:\", end - start, \"seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3ee4f2f1-a4ba-4ac6-9926-1c8e053cd012", + "metadata": {}, + "outputs": [], + "source": [ + "def run_graphvision(image_path):\n", + "\n", + " start = time.time()\n", + "\n", + " result = extractor.extract(image_path)\n", + "\n", + " end = time.time()\n", + "\n", + " print(\"\\nGraphVision Output:\\n\")\n", + " print(result)\n", + "\n", + " print(\"\\nTime:\", end - start, \"seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "32d0620b-352e-429d-9c73-9ff8cb4dc0e7", + "metadata": {}, + "outputs": [], + "source": [ + "def run_graphvision(image_path):\n", + "\n", + " start = time.time()\n", + "\n", + " result = extractor.extract(image_path)\n", + "\n", + " end = time.time()\n", + "\n", + " return result, end - start" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b0948d8e-e67a-4363-8d25-fc65702c1bfb", + "metadata": {}, + "outputs": [], + "source": [ + "def run_deplot(image_path):\n", + "\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + "\n", + " inputs = processor(\n", + " images=image,\n", + " text=\"Generate underlying data table of the figure below:\",\n", + " return_tensors=\"pt\"\n", + " ).to(device)\n", + "\n", + " start = time.time()\n", + "\n", + " predictions = model.generate(**inputs, max_new_tokens=512)\n", + "\n", + " end = time.time()\n", + "\n", + " output = processor.decode(predictions[0], skip_special_tokens=True)\n", + "\n", + " return output, end - start" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ddc4c774-4ac2-419f-a94d-fa99664ecb8b", + "metadata": {}, + "outputs": [], + "source": [ + "from graphvision import GraphExtractor\n", + "\n", + "# Initializes the class and downloads weights from Hugging Face once\n", + "def run_graphvision(image_path):\n", + " extractor = GraphExtractor() \n", + "\n", + " start = time.time()\n", + " # Fast extractions since the models are already loaded in memory\n", + " json_data1 = extractor.extract(image_path)\n", + " # json_data2 = extractor.extract(\"./../FigureQA_Dataset/no_annot_test2/png/1.png\")\n", + " \n", + " end = time.time()\n", + "\n", + " return json_data1, end - start" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "fc9301b0-bc7c-4cff-844a-891999478bcc", + "metadata": {}, + "outputs": [], + "source": [ + "def compare_models(image_path):\n", + "\n", + " # Show Image\n", + " img = Image.open(image_path)\n", + "\n", + " plt.figure(figsize=(6,6))\n", + " plt.imshow(img)\n", + " plt.axis(\"off\")\n", + " plt.title(\"Input Graph\")\n", + " plt.show()\n", + "\n", + " # Run GraphVision\n", + " gv_output, gv_time = run_graphvision(image_path)\n", + "\n", + " # Run DePlot\n", + " deplot_output, deplot_time = run_deplot(image_path)\n", + "\n", + " print(\"\\n=========== GraphVision-AI ===========\\n\")\n", + " print(gv_output)\n", + " print(\"\\nTime:\", gv_time, \"seconds\")\n", + "\n", + " print(\"\\n=========== DePlot ===========\\n\")\n", + " print(deplot_output)\n", + " print(\"\\nTime:\", deplot_time, \"seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "232c9eff-faf9-4290-bbdb-d761e7827cbc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAEICAYAAACOKIcAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAaXxJREFUeJztnQd4FPeZ/7/bu7TqvaMGiCZ6N8U2Lrg7tlOc2E4ucXIlPfe/knLJ3aVfyp3TixPHduy4YWMbG0yvAgQIUAP13rfXmf/z/hYJSTSBJLSS3s/z7KPd2dmZ2dHufuftClmWZTAMwzAMM6EoJ3b3DMMwDMMQLMgMwzAMEwawIDMMwzBMGMCCzDAMwzBhAAsywzAMw4QBLMgMwzAMEwawIDMMwzBMGMCCzDAMwzBhAAsywzAMw4QBLMgMw9wUFAoFPve5z/HZZpgrwILMMAD+8Ic/CMEoKSkJi/PhcrnwjW98Azt37ryu17W3t+NrX/saioqKYDabodfrMWPGDHziE5/A3r17x+14GYYZPeox2AbDMOMgyN/85jfF/bVr147oNYcPH8add94Ju92ORx55BJ/+9Keh0+lQU1OD1157TVx07Nq1C6tXr+b/F8OEISzIDDMF6Onpwb333gu1Wo3S0lIUFBQMef7b3/42XnjhBRgMhqtux+l0wmQyjfPRMgxzOdhlzTBX4OMf/7hw+zY1NQmxo/txcXH40pe+hGAwOLBebW2tcHf/4Ac/wI9//GNkZGQI4VuzZg3KysqGbJOs3ctZvLSvzMzMge3RfgiykmnbdCMX9pX4xS9+gZaWFvzP//zPJWJM0OsfffRRLFq0aGAZbY+WnzlzBo899hiioqKwcuVK8dzJkyfFMWVnZwu3d2JiIp544gl0dXUN2W7/NsrLy/Hwww8jIiICMTEx+Md//Ed4PJ7LHitZ67NnzxbW+6xZs/DOO+/wZ5Bh2EJmmKtDwnvbbbdhyZIlQnDff/99/PCHP0ROTg4+85nPDFn32WefFe7iz372s0KMfvKTn2DdunU4deoUEhISRnyqSYyfeeYZsf377rsP999/v1g+Z86cK75my5Yt4iKgf93r4aGHHkJubi7+8z//E/3TWN977z2cP39exJ5JjE+fPo1f/epX4u/BgweFCA+GxJguKP7rv/5LPP/Tn/5UWO10TgZDcexXXnkFTz/9NCwWi1jvgQceQH19vRByhpnW0Dxkhpnu/P73vyclko8cOTKw7PHHHxfLvvWtbw1Zd/78+XJxcfHA45qaGrGewWCQGxsbB5YfOnRILP/85z8/sGzNmjXiNhzaV0ZGxsDjjo4O8dqvf/3rIzr+qKgoed68eZcst9lsYlv9N4fDMfAcbZv28eijj17yOpfLdcmy559/Xqy/e/fuS7axefPmIes+/fTTYvmJEycGltFjrVYrV1dXDyyj52n5z372sxG9T4aZyrDLmmGuASVHDWbVqlXCehwOubVTUlIGHi9evFhY1lu3bh33c2yz2YRLfTgf/ehHhcXdf/vqV796zfdHDI41k7Xf2dmJpUuXisfHjh27ZH3yCgzm7//+78Xf4e99w4YNwrvQD1n95Oa+3PlkmOkGCzLDXAWKn/bHc/uhWCu5Y4dDbt/h5OXliZjweEPuX4fDccnyb33rW8L9TLcrkZWVdcmy7u5uEQcmVzuJM52D/vX6+vqu+d5JdJVK5SXvPT09/ZLXXul8Msx0g7OsGeYqqFSqMT0/FHvtj9MOZnCS2I1AiVwnTpyA3++HRqMZWH61uHM/l8u8ppjw/v378eUvfxnz5s0T1rckSbj99tvF32sxPMZ8rfN5uXPCMNMNtpAZZoyoqqq6ZFllZeVA9nS/Ndjb23vJenV1dSMStCtx1113we1249VXX8VoIWt1+/btosEIZXlTYtnGjRtFxvVI33t1dbUQ7sHvnWGYq8OCzDBjBJXzUInU4EYdhw4dwqZNm4a4cqlEqKOjY2AZWbb79u0bsi2j0Sj+Xk68LwdlZJN7+fOf/7y4CBiNBdpvxQ5/DZVUXYn//d//HfL4Zz/7mfg7+L0zDHN12GXNMGMEtaikOl4SR6/XKwSMSnm+8pWvDKxDtbw/+tGPRCnVk08+KVpdUg0x1eNSYtZgN/LMmTPx4osvijh0dHS0qN2l2+Wg58k6vvvuuzF37lzRqYtqjsl93dDQgJdeeumKMdzhUJIVdfP63ve+J1zglKi2bds20fHrStBzmzdvFi7tAwcO4M9//rOobaZjYRhmZLCFzDBjxMc+9jGRXfzzn/8c3/nOd4TI7tixA0lJSQPrFBYWitpcSoz6whe+gDfeeAN/+tOfsGDBgku295vf/EaIIVm91NTj5Zdfvur+ly1bJhqR0DGQdU4NTOj+c889JzK+d+/ePeTi4Gr85S9/ERcNZPn+8z//sxD2t99++4rr04UDNfogN/dbb70lhkj89re/HdG+GIYJoaDapwv3GYa5ASiTmDKQv//97wsRnE5Qpy6KM5MLPjY2dqIPh2EmNWwhMwzDMEwYwILMMAzDMGEACzLDMAzDhAEcQ2YYhmGYMIAtZIZhGIYJA1iQGYZhGCYMYEFmGIZhmDCABZlhGIZhwgAWZIZhGIYJA1iQGYZhGCYMYEFmGIZhmDCApz0xDMMwYwaNR/A6fJD8wRt6vcakgUanmZb/ERZkhmEYZkyQJAn1JQ0oeek4PN3u69+AAkielYQljy+CMcoIR4cDpW+WwWf3hp5XKmCKMiKpMAEps5Oh0qrQWdOFjuoOZC3JhD5CD4VCIS4KnN0u1B6pQ8qsZFhTI8VyorWyHe3V7chbNQM6sw6dtV1oq+pAztIsGCL0A++j9nAd5KCMrKWZ6KrrRtPJZuSsyIY5xiReU3ukHvZOh3icOjcFCbnxUKlH53RmQWYYhmHGhIA3iCN/O46zuypveBu1pxuROCcRhevy0XCqGR/8Yo8QaqUyJHYktjqjFus+sxrzNhfh6GsncPy1E7jl71Zh8aPFIUGWZJS8fBz7/3QIKz66BCufXAaVWiVev++PB3F2RwUe/t59yF6ahSN/PYYTb5Xh7n/ZhNm3FQIy4O714O3vvy8s/af/9hQOPHcEJ94sw13/chtSZyfj5a+9js66LuCC+EfEWbDxH9aicH0+lKobF2UWZIZhGGZskGX4vYHLPqXRqxGdGoWoVKsQra6GHrRXdwjxHIwUlOFz+0Obu/Bc1sIMrH5qORRKBWpL6nHgz0dw8IUSZC/NRMa8VJS+cQqH/3oMmQvTkZAXj+YzrSj523FoDFpkLc4YIpJ+j19sN0DHScfrCSAYkBDwXTxuuh8IBOH1+C6s4xf7Nlj0KPlbKTrqupCzJAuzNhag9mg9KnZVYf+fDyNtfqoQ5xuFBZlhGIYZN6LTo5C/Zgb0UXo0N7egsakNHrcHBUtyEJ1mxdkdlcIqHcKwx0arAWlzUoQomqNNOPN+uXBJk3DmrshB3uoZOPNeuRBLEu6DfzkCt82DRQ/OF67tfnf1iFBcehwR8RYkzIhD/Iw4lG07K5bnrshG0e0zMXN9vjgGKSgJwR4NLMgMwzDMuEAx1eWPL8YHL+9FU3kLNEENlLISvT4bSvefxme/+gk0lbXA1ma/5rZI8FrKWlH2zln0NvchbW4qTNEmEUde/pFFaDrVjNPvnhWlQxV7qoWALnl0IZSjjOsSyz+2BPPvmQNrciQyFqShfGcl9v7+AJxdTszaWIjCW/KgUF2H6F8BLntiGIZhxgVyP3tsXgRaAoiULTApDTCodIjXR8MQJIu5FcZIw4i25bF58P5Pd6LklVLxeM6mmdBbdML6jcuKxeKHFwg387Etp6CAAkseLYY16WIy12igRLLYzBjh+i7aNBNLHiGhV2H/c0fw4ldexfaf74Kjyznq/bAgMwzDMOMCJTw1HG9ESn6iEMkB4VEoYdYbEJMYjcDlyqMUly7SGrWYubEA6QtShet63x8OiQxr2odKoxIJWalFycKSzlmWiYJb8sR26PHwOPVlj5XWkYfdv8xx6M163PKZVbj/O3ej+P55wm1+6K9HsfvX++Bz+TAaWJAZhmGYcYNKisi9PDixKigFobKoYOuzYdamAljizENeczmrVq1TY+GDC/DID+7H4oeLRWLV6XfODjyvt+hF6RGRMT8NWoMW9g4Htv9sF2qO1InlJN6UwCX2oVSI/VCyGYm21+mFfEGRvQ4vgoEg1NqhUV0S6p6mXrj7PCKmveHv1+C+b94FS6wZp98rR1/rtV3vV4MFmWEYhhk3PA6viOPqTNqLwqNQQmvXYMuvtmH3zn2Yd89saAwXm4EolUMFWQpIwvqkzGi6BS9kcrtsg2qdFSSyF+5eeD3VCx98sURkQPe12kRWN/1VKJUi/kwXCVGpUUKYq/efR3dDD+ztdpE05u51IyE3Tljf/Th7XNj24x149d+2oPFkM4J+CYZIvXhvPjcdXyg7/EbhpC6GYRhm3CDL0+f0ITIxQmQ+9wuyRWOGRqlGeUkN5i2dI+K0ve6+AUt2ME1lzXj9G1vFfRLM9pouUVc8Y0X2Vfcdlx2L6FSrsJCf/czzok6amnmQazsuK0aIeMGaXJS+cRLnD9fhD5/6C7Q6Dfra7SJZbP7mOcIy70etU0Fr0qJyTzVe/PIrYju2FptwncflxMIcO9TSv15YkBmGYZhxg9y8rRXtIvGKumT1QzasVqmBGmoE/IEhLm3pQsyXumBFpVhFnLa5vFUso/ViMqMx767ZyF6SeXF7SoWoc45Jj0JEfIRYRiK/6csbsed3B9DXZoNar8aM5dlY9/Sqga5e1pRI3Pm1W7Hn9weFO5qOl8qbFt43FwVrc4e4z3UmnWhIQk1K6kobRIY4Wf9UWrXu6dUwx5pGda5YkBmGYZhxhSzchQ/Ph1qrQsB3MYlLkmVYos2wRllR4wrFeQUXDGSyQB/54f2hZh4XlpELmYTaFG0cIpYkknPvmo2sRRnCGqfnqBSJHicVJoo2nAqVEhHxZmj0moHX0t/0eWl46L8ThPUsUz2x1Siyv/td3/3QurTtO//51lAsudctLOjIpEhRKz3ajG4WZIZhGGbc48gksiRc1BeaUKiB2LQYLN+wBK3HWkV8dji+gA8Bgx8KA2A0GKBSq2E2mS4rfF6vFxIkUZ40GFqXGnZcrmmH6HntdEKn04ks7pj06MseP63n8XjgDwQQYbGIZC+y+McaFmSGYRhm3Olt6hNDIUhLKbabPCtRxHQpvtt4sumypUl2uwOHj5TAbrNjzpw56OzswOzZsxEZGSGsa4/LDbPFDLVajbq6erhcLsybNxd+fwB2uw0GEnGVCg6HE3q9TljRXq8PGo0aPp9PPNfQ0Ii4+DhoNVpIUhBms1mIbzAYFK/XarXi/uHDR9Dd3YM77tgk1qN16DnaBt2nbdNr+3tu3wgsyAzDMMy4U3e8QbSZpClL5O499Jej12ymERcXi6LZs1FTU4uMjDScOXMGBw4cRExMDOwOB4KBABITE7BgwXwhtCSMNKnp6LGj6O7qEYFqen1p6QmoNWohmN4Lli5lcpNQx8fHw+vzobqqWoh2Wloa6urrodPqEBsbi+Li+XC73ejs6oZep0VtbS2aW5rhcrnh9/lgtVrhdLnE4w3rb0FUVNQNnyMue2IYhmHGBjGV6fJxVKoJPvLSMTEYgvpXX02MVRfaXYo48MDmFIiMjERR0WxhCVdWVsJut8Pvp/gyWdeyeNzR0SkEvLe3F06HE6fPnBGJYJ0dnWLdvLxcSMEAZs2cCa1GA7/PL4SdRL6goAA9Pb3ChZ2UlAifP9Too7GxCZ2dnejt68PZs2fhdnuQlZkprGw6loSEBCHWHs+FMZE3CFvIDMMwzJhACVcp85NRfrz6ilOfcLGs97LEpEYjPi9u4HFERKSwjrVaDTIy0oW7OisrE0lJCUI809PThJuYrNmmpmbU1NRg3ty5aG9vR3x8nBB1m82OuNhYkTxmtliQlZUFy4W/5HbW6XWIiIiA1RoJvV6P+vp61NbWITY2FI+mhiG3334rDHoDampr0dnRgbq6OvF6ughoaWkRljG9fjQo5OEFXwzDMAxzA4hOWP4gWmvbhzbtGCFKhRLRyVGISogcyHAeLFF0f3BCF7mnSYzFDGRZFo/FdpRKcT9kYSsG7hP96/b/Hb4sEAjg+PFSIfZz5xYJ63fwfimeXF19TljQJOp0AWCxRAjx7t/fjcKCzDAMwzAXIPGlIRWyLEGjuVgeNfj5/guB/sejFeJ+WJAZhmEYJgzgGDJz06CyBq/LJxq5Bzz+K8eYBkFuK51RKwr69WbdkG4+DMMwUwkWZGZMY0fUBJ7Gqbn73KKJu63ZBkerHY52Ozy9HvgcXrEOnH6o7UMF2aULQmvpgE55MfYUVOgQ0MYJQdZajNCZDDDHR8ISHwlzvFU0hjdGGUVfW+o9S9mZY+E6YhiGudmwy5q5YcjSpXpCulH3na7zXfDU9sFb2QO5zQWdDzB7AKMX4r7ODxj8CqhDeReXUJbhRErxn5Furry4UFaILnpBWQ1XwAJv0AhXMAKuYCQcASucQStkSzLU8VkwpmUiJjMBUalWRKdFib8szgzDTBbYQmZGbAH73H64ul3oqu9G05EGtB1rQqDJAUO7D5Y2P+KdgC6ggCYIaCQFVNLgkeTX2D5ksa4SElSKQYp9YQNqBKFTDa3xowRJEmqfpIOvSw9vhwFdB1JRocqGQ5MFTVwqovNzkLogR7TEI0taa7g0SYNhGCYcYEFmrhrzJSu4s64b5w/UoOVkM7zHO6CptCHOoUCeR4EIjwJKUTlAIjdyAR4LSFfVigDUygCM6lCTgXh9I4CDkGQVejti0dWYiLNvpcBtXQBtZhFS5mYhbX666ENL8ejhzeMZhmEmCnZZM5dAyVYd5zvReKIJDe9WwXeqE9Y2P5I7AaNPAbVMH5yxlV+ykE9lOpFa/CwyLJVjt12Ztq2EX9LA4bei2ZuPNmkWFMmzkbq8GBnFGaKvrmbQzFOGYZiJgAWZEVCildvuQc2hWlS/Vwl3SSusVS4k9ioQ4aW47/hakuMlyJfsRwb8kha9vli0eTLRpl0BdcYc5K2fh8yFmTBYaaLMNVoJMQzDjAMsyNMY0aVGBtrPd6Lig0rUvlEOyykbUruAGGe/K/rmOKJvliAP7O/CeyPXdocnFbXOmeiLXIb4ZatQuC4fiXkJYpYqx5sZhrlZsCBPU2jgd2tlO06/egrdH9QivsKNpG4FjD5KrLr5cdWbLcjDkWQlnAELmly5aFCugXHmYhRtXoLE/ATozDoWZoZhxh0OnE0jRMu3gIS2qnYce6kUfVvPI6XKi4U2JXTB6d1wQ6mQYNH0oSCyBNnBk2g8nYsjxxZBVbgRc+9fivT5aVDr1CzMDMOMG2whTxOEEJ/rwNHnjqLv7fPIOOdHYl+oJvjm5kaHp4V8yfFcKKnq8KTgrHM1lPkbMPu+FchelCGEmWEYZqxhQZ7iUBN0W5sdJ149icZXziL5hBMpPQpog+EhxOEqyIOhDO02dxoq/RtgmLcRCx5eifgZcWLUHMMwzFjBl/pT2D1NceKz2ytx4reHEXuwF4s7lNAEFWElxJMBjdKPFON5JMq/Q+3JA9hZuh4JG+/FgvvmITIxQqzDyV8Mw4wWFuQp6p5uKW/Fkd8egv/desw/L8PsVU5IstZUob8JSY7lFJKDNajadhzvHNqEmR+6A/lr8qAz6Sb6EBmGmeSwIE8xq9jr9OHkllM4+9sSZB53I61HAZXMQjyWwmxUOzDHugtdnkqcfuYE6g4/hCUfXYnYrJiBGakMwzDXC8eQp1Cby7bqDux/Zi/kN+tRWAcY/eEVJ56sMeRrJX6dd8xGlWIzCh+5F0V3zBLjIhmGYa4XtpCnABQrrvigCqXPHEDGXhuSRPb0ZJHiye/GzrWUItbXjFPPVqH97INY/LE1YpgFx5UZhrkeWJAnuYvaY/diz2/3o/O3pzCnWhZtLlmKb74wR2nbsTL6RVQcrcY71XVY/vR9yFyYLoZXsDAzDDMSWJAnsRi3VbZj38/2QrelHgubFNAF2SaeSFFWQUKBtQRx3iYc+q9atN77MObfXwxDhH7CjothmMkDZ6BMQmgkYs2Remz/562Ifr4Os+pZjMMFpUJGrK4ZK8x/QNfffoT3f/yuqAMXfcMZhmGuAgvyJCPoD+LEllPY9YU3UbCtF1ndXM4UjtayWWPD4ugtiCz9Lt751vOibziLMsMwV4Nd1pMIr8uHI8+XoPH/jmHhaT8sHC8O+4YiMyMPwdhmwwf/0YUln3sEWYsyoFTxdTDDMJfCvwyTALKs3DYP9v56P5q/ewjzTgZYjCfR0Ios82nM9f8Ch3/4K5zedlaUqDEMwwyHLeRJAGVS7/rpLrh+dwYL6hTQSJy8Ndlc2ImGeuh8v8Wx37jgcz2OuXfPgVrLXz+GYS7Cvwhhjq3djp0/2Qn1n85hThOL8eQujerAYsWfcORZEuUnsfChYh7pyDDMACzIYeymtnc4sO2/34P+hVoUtCq5BeYUEGWLpgfLIl7A3hdlkaC37GNLRUyZa5UZhuEYcpji6HLi7R+9h3NlNZAV1FiSmSqibFA5sMz6Mlpf/z0O/vkQAt7ARB8WwzBhAFvIYdp9a+ev96LBVg/9ag3KdX5ojkjIa1dCKXMfrslOyFLuw2LLS9j3VwX0Fj3m3zcfSiXnBjDMdIYt5DDD6/Dig1/uRmV9BXT5KigjFdCt1KBskYyzCUFICraVpwomtU2026x9/rc48eYp0fCFYZjpCwtyGOFz+3Hg+SM4U34WmlwlFKpQH2SFUQHNcg3OLgIq4yUEWZSn0ChHO+ZqXsbZP/wJNYdrWZQZZhrDghwmbmqyjo6/fgIlu49CO0sJpfai+5JEWWlWQLtCg1OLZFTES5DEwEJmSmRf69qxWP8s9v34eTSfbeWOXgwzTeEYcjggA2XbzuLgO4ehm6OEQnPpKiIL1wghymfgh1wioaCNM6+n0rSoOb4/Yt9PzNj49Y8hKsU6ZTOvqTGK1+UVn/sxR6GARqeGSqMah40zzPjCghwG1nHT6RbsfWk/5OwAlIYrj+uj5SqzAliuwWnZD1WJhFxO9JoS0L881VwNV9dz2PnzJGz6f5un3JQo+qxT9cCJVw7Bce4slIrgOOxFCdmShDkPrkRiXsI1L2q6G3tRsbsKUcmRyF2RM0TIyWtV+uYp+F1+zLljFgyRhmteaAR8AVFbTvdrjtQh4Asif/UMTLT3jY6H3pvX6UPFziokz0pCXFbMhB0Xc3lYkCcQ+rJ01fdg2zPb4U1xQx01stm55L7WrdLglMKPYImEwlYlz0CeIpOiZliOw3b6dzj8lzis+MQq8eM+VSBROPm3fdC//2XkGitCrqExR4G+uhgcd3wLG/79cWgNl3E3DaK7oQd7f3cApmgj0uamwhRlvPhcYw92/N9u8Z2csSL7moLc29yHV/5tCx750QPQm3Wo2ndOVExMpCDTKT7x1mm0VrRh05c2wO/xo+ZoHcxxZhbkMGTqfNsnIXS1uueP+9Gt6oIuTjViF2W/+1qzTIOz8EN5oSRKJU9NF+d0Qq0MYG7ULux5OwMV2QmYubFwyriu6QI02N2EaG0zNErfuO0nWtcKlbNZiM+1BBmyDKVaKQa3tJS3Ysay7IFjPbe/BkqlEiqtauDagZbT99bv9kGhVEJv0YkWqGSFOnucaClvg6vXDY1eIy5A6Ob3BuCxuaFUq2CI1Itt9kPH6HF4Qf9hfYReWLH0/6badNomHRv1saeSOLogEH3t+zx03QFjhEE8T9C6HrtHWOR0EUcXBNRwhvbd29SLzpoueJ1e4XVZ+fhSmKJNA++HXkOvJej5/pauwUAQHptHbFtj0EJn0k6Zz2K4woI8QdCH/egrpahpPA/tTJX4gl0PItHLAmgo0Uv2AyUS8ttCljJ/ZSY3WqUH842v49BvUxGX82nEZcdOqR9CRZilI5IIJeTGo3LPOeQszRLn2ufyoa60QUznokS7fvFqPtOCPb8/iK7aLqi0auStmoFljy2Es9eN3b87AEmS8N7/7MDaT68SryFx3v7zXTh34DwMVgOWProQBWvzoFAq0Ndiw/4/HULtsQYhuLkrc7Dy40uhM4Ws6/oTTUIEz+6oFCK76MH56Gu1ofyDSihUSix+eIFwpdPpPL7lFE6+VQZHtxMR8RYsuG8uZq7PF9s5s71CHMfOX+3Doofm49ALRzFzQz4yi9Nhb3dg7x8PoO5oA7lokLs8G8s/tgQqtRJHXz2B0++VCyEn9/byjy5BalHylPoshhucZT1B1JbU48h7JVDlYKC86XoRJVEmBbQrNThNdcqJEtcpTwHooxCta0Nh8EXs+b9tcPa4JvqQpjQkblmLM8TM6p6mXrGMhK/jXCeyF2cOrEeituvX+xGfEyvc0nd+7VaUf1CB6gM1MMcYMWtDgfhOzru7CBEJFvEa2mZ0mhWP/vhB5K2cgZ2/3Adnt0u0Tf3gF3vgtntw7zfuxB1fvVXkkhx79YSwSG0dDpx6+7SwlB/673tRsGYG3v3Rdti7HLjvP+4SQnz4r8fQVd+NhpNNOPrKcSz98CI89pOHMPu2mdj1q32wtdmRXJiItDkpsCZHYvatIW8Lua/pvdBFx/b/2yXc6vd/+27c8ZWNOH+4TkwkO3eoFqVvnMSmL63Hoz96QFywHHnpmFiXGT9YkG8ydJXd09yLPX85AGQHoDJRH+Mb356wlE0KqJdpcKZYRlVcqE45vGwQ5nqhz0S6qRy6yhdxckupsLyY8SO1KAVBX0C4nOk72nCiCbFZsTDFhFy7hEavxuIPLcDih4thjjUjOjVKWLMkilqDFkkFieL7SLFogyWUkBc/IxYL7p2L6LQozNxQgJ6mHvg8fvS29KGlog1LHlmIuOwYJBUmYPbGQlQfrBEuasISa8b8e+YgNjNaWOrBgIQVH1uK+Jw4YU3T8To6nUJs1392DWYsy4I52oiE3DixfXLDRyZFICrVCqPVgORZiQMubsLR5ULN4TqsemKZENyM+WlY95lVwsKm7YrPoVIJU5QJCx+cL6z7qZTTEI7w2b3JSAEJ+587jM5AO3SxY1Oa0e++1lKiF/yQLpREsfN6ckNZyPOsH2DP63lImpWGzOI0dheOEyS2JHrV+88jb2UOKvdUI39NriihGvh/qJQi3kqWKlmKZMn2W9RXwhxtGojJKlUKSDQLW5ZFTNdNFvev9ol9E64+txBCnzMUXycXtyHCMOR7brDoQttShhz/dPFAItl+rgOHXzwqRJus75F0faNj1xg0MA5KViOXPdHb2idi6q/86xaotSqRlV1020zxHpjxgwX5JkIJHlX7z6PqbBW0s0eexHVdiV7LQ3XKihJO9JoanbwcKFS9gUO/K0TCjEdhtF7MAmbG8lyHMqnf+cF21B5tEIlWGcXpcHQ6BtZpr+7Ath/vEElRKUXJ0Bo12PIf79zQ/lRqlbBaKdZLljDRL6SDrfJrJYRIQRnHXz+Jyr3nsPrJZYhMjBSW828+8adrH4NGCTkohy4SLkAxaBJ5svjXfmolfG6fqAShUqm3v/8+HvruPcJCZ8YHdlnfRCgutedP+6HICV62+cfYWMoKqFdqcOqC+5o7ek1+UoznYal/BafeOsmtNceR+Ow4mGNM2P2bfcJtG51qHfI8CRNZyZQQRW5mypZ2dF0UbIEidOEtXyNmFD8jTlizlAWePDMRSQUJosyKapevpxyMBLytsl28nuLdMelR6G2xhTYxeDN0f5jRTC53Cm41n2kV26Hkra3f3YaSl47j8AtHceDPh8U6eatysPqp5eIihTLMmfGDLeSbBF39HvxrCWyGHmgtY2sdXxpTDrmvyxQh93U+l0RNalTKIOZY92Dfm28jvTgTifnXbnjBXD9UkpQ6Oxn7/ngQiz9UfMnzJHrk4n31628J4Xb3uWFNtqLxZJNw/6p1KpGxTZPalj226Kr7ssSZsfCBedj2kw+QlJ8gqi56Gnqx9jOrRMnUSKFs6JzlWdj7+wN4w+mF5A+VSllTIlG+s1J0fKMSp47aThx8oURkUfdDcfDlH1mMnb/cg9PvnRWJXvQ7VXT7TPS12fHeT3bgpa+9BnOMGZ11XchdmY3YjOjrPKvM9aCQyT/BjCt0imuP1mPL/20FZgWg1CluToceuwz/fj/mHFFgRkd4j26kK/VTmU6kFj+LDEvlRB9O2EHf0irbXHTN/Tfc9v/uhXoStoYkK+zAr9+BcccXkaAnS3B8cAdMOJvyHWz85sehM2qvui51DqP4a+qcFGj1Gtja7SJ2SglONBbT1etCS0W7KPeheDK5reuONwjRTJ+fBlmSUHOkHgVrc4ULmixcSqjKX50rBE4KBJE8M2mg5vjcwRphyWqNWvG48VSzyHqmEqq0Ocmh7mJKhbCWKZ5MsVv6X5P4159oFHXSVKtMruTGk80igYtqhOmY2qraEZMWjbS5KeI+ZecXrssX2dQUEyc3dPaSTPEcJZmRF4AEuL60Ea1V7cJap1Ioek5Y3lUdosyLrGLqZJa5MEO8R2b8YEG+CZCr5+V/ew0dplaoEyir+ubIIomy7JLh3e1H0VGFqFOmVK9whAX52viCWuzrexRFX/wX5K3OxWSDPo8kVsde2Au5t3nc9hNQR2DuQ2uRWDD2ngRhv5AJM3izFx7TvgY/P5J9X+/6I91Ov53Vv83Bdtfw/VzpGAZeMwbHx4wMdlmPMxRPqthVhVZbK3QZN0+Mhw+kOK0INQ8Zj45eCoMa6jwrKQb85/oAnwRFpBaq+KEJSMFGB2R3YEz3PZ3QqnyYadiO0hdXIHl2ssjgnUzQ5zEq2Yo1n7tdxE/HC8oEpszm8fiuiW0O36ziGs9f7/bG4LiGv/ernYsrHcPAa1iHbxosyOMIXWGSC6zkrePQ5CigUN/8T3Z/SZT6Qkcv5YWBFGPZ0cv04XxE/+8t8Jf3oOOeLQjU2mB+rAAR/7wQCIausimbs/Mj7yBwvg+mx/KBgAzX6+cQbBiWFMNclVhdC/S1b6Hm0DLMvn3WpLRaSCzVV/ckM8y0hAV5nDmx9RR6FV0ikWuiCM1TvlinHDw6dnXKqswImP+uaKjlqwA0s6Mh9Xhh//kJIBCaNhNsciDya4sQ7HALazry/y1C9z/tBrzjMfVn6tYmz4zcj5K/vouM4gwRB2QYZmrAZU/jXOZ0en851Kk311V91Y5ey4d29BoVWiUsny4SQustaR/ylCrdAn9ZFyS7D8EeL9xv1UC2+6HOtMDzTi3c2+qgSo+AQssfweufndyBqO7tom0jd/BimKkDW8jjBMXITm49DbfBCQ3NMA4DhChHAOpVGpyQfZCPQsSUb9R9rZ0fD+M92ej+7AewfH7BkOfUGRFQz7BCd0sqlJFa+A61ofOxt+HZ3YyIrxRD9gTh298M2c3W8Y2QazqCA1u2Y9atM4eMDGQYZvLCgjxO2NpsOL3vDNT54ZWdeLFOWSvqlGVK9Oq4/kQvhVmDiC/Mh/dQK4LdXij0Kig0SijjDECTA47fnxHrud+sgfG+HFi/sxyGu7Lh+OUpePc1i9iyv7JHuLOZ6/0fAhHaLsR070Llrlsx7555YfUZYxjmxmB/4Tglc1XurYZT54DCEH4/lKGYskIkepUtlHEu9voHUqhTzdAURkO3NAkxv1oPbXG8cFNH/vtiIc6e9+rhfL4CgapeuLfWitFuqkyLiDX7jrTBd6wdssM/ju9yaqNUyMg1l6Dq/RKeBsUwUwS2kMcBajZQtvsMNOlKUeQfjgzMUxbuaz+Cxy7OUx4JgWYnev9lP5QWrSh7snx2DpQxBrhfOw91qgVxr98N38FW2H5wFIbN2YBfgu9QaK4sMzaQlayrexcNJ9aIxhRsJTPM5IYFeTy6cpXUoy/QFzax42u5rzVUp4xQSdSMzpG5r2WbD+4tNaHtWDTQb0iHKjUA93v1CLY44XqpCubHC6GdHweFRQvnXyvh3Tt+zSCmI0pIyNKXovLtA2JCEXVwYhhm8sKCPMZQK7qyHWegTJQmRURgSKIXfEAJkNtxfYlesiuAvv86IlzVUrtLWMO9/3YArlerhVs72OSEd0+TSORixvJ/ByQa61BefRgt5RuQMjs57K3km9mp93rOxeWOa8Sdtm5gfwxzOViQx5jWyna0tLRAs2DiS52uv05ZK+qU5aOSEOURJ3pRgtbJzqHLhIu6TdyY8UOtDCBDsR/lH5QjqTBRjPULV0i8RDhn6z64Oqhf+TiIs6yAxpSA/PVrkJCXMKKXeF0+NJxoRMOJJvg9AUSlRCJtbioSZsRdM+Rk73Dg/KFaFG2aBdUENP5hphYsyGMINWQ/s6MCiJegmGTuw35RFh29LrivczrDeyAFEyLRUINzR0rg6l0yMFs3HKHmMGVvH4Sm9+uYP/f0OO1EAVuPFcde/jrW/eNHoDPprunR2veHg6jaew4ZC9PFgIXq/TU4+kopNv7TOmQvyriqKNMQiF2/3odZGwvE5CWGGQ0syGMIXS3Xn62HOmdyfjH73dea1eS+9kM6Gup9zZIc3pjUdkR07EHjyXtQuK4A4WwhB131yM6phjli/FqmGs0OVJ1vQsAXhO4a7b5p0lPV/vPY8A9rxTQjcmrR63Y8sxsHnzuMtKJkMZmpv7eA2+YWk576p0ilz03FZ154AmqdeojIu+0eMV2JBH44NGrRY/NAa9KJCVKDCXgD8Di94kJi+HN+es7ugSHCALV2cl3wMyODBXkMf2xorFmvrwe6SfxlGZ7opbiORC9mYlAqJKQZK1Gzpwz5a/KgVIX7BeH4x5FH+mn12GmGcBB6iw5KpUJYw1qDEosfWiC+z0q1Slj2NJ7w4HNHYOuwi/M7a0MB5t5VJNb54Bd78KHv3QelRiXGFR7402G4+twiya74vrnIX5MrXvP+z3bCEmdBx/kOdDf0ClFd8fGlSJ+XCilIyaB1OPLSMTHukER/ySPFyFqcIY6zet95HH31hBilSMe65JGFSJ+fCqUy3P/XzPXA/80xpHJ/NZSxYzO9ZeItZQVUKzU4USyJOmVJDEhkwpUkYw1slafRVd890YcyqYjLjoUp2oSt33tfuJ7P7qgQbujIxAgU3JIHlUYJZ7cLb/3nuzDFmLDmqRXIXZGDg385gtaKViHoTWXNkCQZ9g47tn53G6LTo7DqyWVivV2/2S/ySsQFe3UHDr1QgrjsOKx+ajn0EQZs/9kuSAFJzETe9j87hJVOz8XPiMPOX+6Frc2Otsp2cT9tTop4LqkgEe/88H3Y23kwy1SDLeQxwtntRENVE9T5kyeZayR1ytrVWpwk9/Uxdl+HMypFANGOA2gpfxCxmTFT4jN4MzBFG3HHVzei5OXjqDvegPJdVfA6vIhKtWLlJ5YhszgNdcfrhfW77LGFwsKlbHaypsmqHQxZsUarEcs/ugSGCD0yF6Sj4WQjzh04j8S8eGFpZy5MR/H9c4X1TNbu9v/dLRLdKndXIyE3HgsfmCemYSXlJwh3d9AXxJntFeK5ZR9ZJJL2EmbEo6akDvXHG1G0aeaEnTtm7GFBHgPo6re+tAkelRuaMOzMNepEr5UalMEPVYmE7C52X4crSboqNBytvJBgNHnDJjfze0vWqTU5Erd9cb0QYrJIO+u6cfz1k3jnB+/j4798DG3VnYhIsAwkiFFsd/GHisX984frBrZHbm0aKPPuD7cPJIL1NPWJWDLthzDHmITgEiK0oAglg5L1nFSQAOWFxDC9RY/VTy4Xot1Z04W+djve/M674jkaKOLqdqGzrusmnzFmvGFBHgPoy9ZwsgmIpTrbqfVDOFCnvFqDUvggHQ3VKVOqFxM+kEEcqe3EqRNH4HNtgiFian0OxwUZqNhdhbaqDqz9u5VCBOkWlxMrvAx//tyL6GnqFeIqByUMLlUmMdSb9UM2R+tFJliQt3rGQMY1dVAzx5oGhPZK0GtJmAcOTZJFwhlZ3PRcbHq02FY/M9fnw5oUOXbnggkLOIY8BvjcfjRVN0NpmZoi1d/7WrNSi7KxGt04wajzVkO35lNQGKNCC7RGaObeCf3d/wLt8o9CYY65sKYCythM6FY9IZ5TF67HQOquQgmFKRrQDP1hniiMajvMvnNoOcMd0UYEpXsolcIl3HiqGQF/cCCburelD2qdCpY4M1KLktFxvkssI6HsrO3Cuz/agdbKoTX2yYWJ4rcgeWaiEOWM4nTUlNSjp7H36iEEBUR8mFzQlH1Nwlx/ohHv/ngHXL0u4a72efzIWJAmtpuYn4DyD6rgtnlG9Xlhwg+2kMcASubo6umEfsbUtUr6LWVc6OilLIGoU77R0Y0TAr0HawpUaXNg2PzvQlj9Z7ZDdvXCsOnL0N/+JUi9TVBGJMI/7244f/eUWMf8mRehSp4JydYGw6avwP32D+B58zvQrvw4NPlrIDs64X7nh5B7myd84ESiphL1x+uQtSQrjOPI4XFcdH6yFqYLwX3t62+KhCqdSSuynClRa+GDC8RoS8qCpiQrcmGTOFICFsWIU2cno6W8TYg6Qe1LT28rF67luOwY9LbYRJnU4ocXXBB/xdD/CX0eLywrXJeHqn3n8Ma33xFWdt3xRsxYloXo9GjMuWOWaD7y2tffQnRaFDpqusS2KCGNmVqwII8BDaeaoIye+mdzcKKXqFM+JiF3MtUpa/TQ3/Pv0MzaCGVkIoLt1WKxMiZdiKvv2KtwvfglaJd+GMaH/huqrF9CYbJClT4Pzt89Cf/pbTA9+Qfoln8Y/mOvQlt8H1zPfwG6JY9At/QxeN75wUS/Q8Tr6lBSWS+yf0k0wu3zo9Inoa0xBTqDe9z247Kb4fPHQz2C5jzkor79i+vRdLpFhJ2oU1dcViwWPbwAcZkxIvmK3M13fu1WVO8/L2K9c+6chbyVM6Az6xCbGY3bPn+L2JdGr8a937xTJGh1NfSIpiL5a3OFlU3vfcmHimEcNLs6PjtGxIkNkQaRwHX/f9yFsx9UwtHpxKonlmHG8mwRr6YY9/3fvhsVu6pga7dj9m2FyF2ZE3b/X2b0THEJGX/IhdV4hgR5amRX30hHr0mT6OX3wvvuj+E//FfoN/8bFGa6igJUSQVQGK0IVO2HbGtH4OwOyriBOrMY/qq9kH1uKGMyoDBGQ2mOQbCjFlCFvjqyxwHZ6wK04fHjaFA7gNYyOHvuDrsfbLLqCjYsQ+lr/4r2knPjtyNlNIo2bxKCORIoWSt7caa4XekzT+ey6PaZKBr2HGVdz7lj9sBjsqjn3zPnstshgR1MREKEuA3e1uKHiy+7fyrD6k8kY6YuLMijhGI83c09UGVNAkEaS1GODA2kOA4f5KPAjOscSDEhyBKCLWch9TRCdnYPCLLCEguFWgvZH7LaQn/JvZ0MqfkMgnVHYbjvmzDc8+8iE8j3t39BsOkMAlX7YHz4e9SaCe6t30U4oFIEoes9K5KRYtKjwuoikY6FrL01n35gfHuDXHAPM8xkgwV5lPS12eHyOqG4tEPe9HBfDx5IQTHlyWApDycYoBqYyyz3Cfe1OnMh3K9/C4Ez22F85AfQrXsavpJX4Hn3R1Ba4iF7HSIOHQ4oICFW34y2M/UiBhmOnxuFahJ+RhjmJsBZ1qOdXtPhgFftCZc8lQkQ5VBHr5MLJJyPmZwdvYKdNZB9LhFXpsxpsozJhAs0n4V6xlLIHjt8R/6KwLkD8J95HwpTDJSxGdT0OGRth4kYE2QQR2i70VkemlXNMMzkgS3k0SADbdXtkI2TTYLGYSDFGi1K4UeQEr0uuK8nC8Hmswi2VUG77COQepuhXfQQZHunEGByZWsXPQzDbV+Av2q/uC911iDYcALhilXbCU9rk8gW1o8wjsowzMTDgjxKC7mv0walaVg5wwSSmZmJ9PT0gcfBYBClpaVwOp3isclkwuLFi2GxWLBz507YbDbRoF6r1cLv94v1R9vRS3n06oledPlCdrRfBbg1MrqNMrxqoMWohKOvGF3eJFFTG6NrhVnTC63KCyWCwvobC2RZgmzvgEz1xJKfJgzA/dLXYHz4+yImLLv74HrpK5DaquGzd4gsa03R7dDMu1sIt/u1b0B29iBc0aucUDs70NvUK2pWGYaZHLAgjwLRTaehA8rE8BBjEtasrGxkZ2ejuzvUVi8QCEB1ISOYKCgoQGFhoRBRjUYDlUqFBQuKYbVGwu324OjRErjd7htO9MLqUKIXjl5apxzyI8jo08uojZbQa5ChlIFIjwImrwKmgCxE2Ki2wemPRKNzBoKSGiZNH3IjTyBO3wQF5NELs9cJ5x8/feGgQt2RApV7YPvuWuGulh1dQpTF044uuJ59GgpTlMjElrobRBJXOEPnxyw3ikYWLMgMM3lgQR4FNDfVYXNAkRkegkyiaLGYce5cNU6ePCl63no8Hni9XvG81WpFTk4O2tvbkZAQspzi4+MRExOD/fv3Yd68ecK6rqioGJOBFPIxaSD7mixipxaojg2ixyAjpU+J7C4VDH5AfaFjoMsiC9HNsFSKHKuArIEnaESbKx2lnauFUBdGHRWirRhtp7ALQjwEvwdSx/nLrSyysuk2WTAHG0UfZfLihIv3hmGYq8OCPMoOXUFFEOqwybBWwGw2Q6fTY+3atcI6Pnv2LKqrq6FWqzF37ly0traKH+l+QQ4hi3Vp+aiP4IIogxK94IOqBMjsVqLTJONsQhCxTgWW1qlhCAwVieGpYKQhGoUfGmUfLJGnkGauwjnbbBxoux2F1hJkWc5AqRg7N/ZUI0rbhqZ2u2jDyIMmGGZywFnWo6CnuRfQyWFT80ht+Hw+HwLBAJqam6HX67Fy5SpER8cgJSUFqampwnIm8e2nra0NnZ2dWLFihRDkurqL02tulJD7WgH1ai2OLZRwOCOAk8kBzGpVYWarCvphYjwSdCoPCq1HsTLxTSHMp7qXQeKP7xUxqJxwd7Qj6L+MJ4BhmLCELeRRIAaE68iyCw9BDgYlbN++XSRnORwOdHZ04NZbb0VychIyMjLEcoov91vH5L4uKyvDsWPHhHiTa/tGkrquluglZ6pwzunHrBoVol2KUU2JIje1VduBFYlv4WjnWpzuXoJZUYehUo7NMU8lVEo/gj0tkAJ0bsLGhTMwHS0ojmt8oLGG1O6SXfXMZIMFeRS47R4gjKpKoqKiMHfuHOGiJkGmJC+yet0ej8impgSutLQ0REREDMSPKbva5XKJ21hC+w32ygi0SDAs0aHK5IfFKyF7lAMpyEVtUtuwIHYXdrfcA4u2D5nmM+y6HoZKEUCwr2NgDm/Y1O13OnH8lVL4amwDaX5jjTJGj9n3zxHDF0YiyjTlqfFEExrLmhDwBmGJNyNjQfqoO53R+6X+0zEZMYjL6p8ednloDnPdsXrMurUwNCd5lPjcPpw/VIfE/Hge0ziJYEEeBc5uZ1gJssfrQVJSknBP19bWCqu4t7cXLc3NqKutHfhxWbx4iRDukpIS9PWFsonHGtkHeM4GoJuphiZJCVW0FidkP6TjFxO9RpVFrO7DwrgPcLRjLWJ0LYjQhm8Z0kSgVvhFTTV5TcKpKqHs1ZPwfeMIUrrGz6vk1gKH6vtw23fvgtaoveq6AV8A+/54COW7qpCUHw+1VoPms6049uoJbPzHW5AxP21UIamTW09j5oaCawpyR00n3v/5LhSuyx8bQXb5cPLt02J6Fc9NnjywIN8glCwT8AaosVPY4HQ4sH37DsyePUu4pVtaWlBWdnqgBrmftrZWVFTohBU9Folcw6Ft+puCUKghxJh+0IYkeh0FsrqUo3RfA/H6BiQa63C2dyEWxW2HUhE+4jPR0LlQyl54HV5YYs0IB+hz4TnXi4QeBYz+8RNkvV9Ga5sHfm/gmoLcVd8jrNi1n1opxifSZ5XmDG//+U4cfL5EzDbWGrTi2IWr3R8U66i0qlAb0AsXueL3wEeJkRCTn2hKFLH271aKgRP97z+0XlB88mkbJL60DXqOll/u29j/uqAv5OZX69RDRjlebt+GCAPWfmqFGFgx/DeLUGnVUKlDHjS6UKIbbVM8r6B9aEROSj80IzroCwzsf/BFA4UfrnRszPXBgnyD0AfX2euCMiq8PnitrS1ob28b+JJT6dNwyKV97ty5yz43JgQAf2MQ+pmagfC6iClbAfUaLY7BB+kY1SmrRp2WlRdZil3N98Hptwj3NXPRZW1QOeDociI28+rW2c2EPg7h9I1x9riEyNI0pX5LmCY7LXl0kZiJTMJD3yMS7iMvHRPLaGRj4S15KNo0S4xN9Hv8OPb6SZTvqBSu4syF6Vjy6EJxIXT8jVPIWZIpJj2Ru55Evu5ovbiizFqUIWYlm2NNA8ejuIIn7tCLx1BbUi/c/LkrcrDwgXkwWo1X3DcJc+mWU5i1sRAps5LEhVnJK6ViNCSJ64zlWWIcpD5Cj+oDNWg/1yG+o+UfVEKtVWPB/XMxk6x1tVKco5KXjuPcwRpxPvJW5YjxlHShQpUmR/5WivMHa4XAF67PR/F9c6HRh1fewmSBBXkKci2hFVfF42AZ9+Nvl6DQKaCKHnql3F8SpVkVqlNWHAuKmPKNWsqheLId8cYG1DvzMUt7eAzfxeSGzo0S0oWkLuZKxKZHCWHb+t/bULAuT4hXJI1FjDcj7u7QsEUSpK3f3SZcvxv+fi3snQ4c/EuJEPLi++fh6CulOP1+BZZ9ZBH0Jh12/WYfFIqjWPfZ1ag9UofotCjxfdv37CF013dj/d+vEdbw3t8fgM6owYqPL73i8dE+Dv/1OFrOtmL9Z1eLxwf+fBh6i+6q+1744HzUHKkXLneyfg//9Riq9p7D0o8sglavEdsg1nxyBXoae3D4xaNCgOmYm8pasOe3BxCfHStmQ+/8xV4xh/mWz6wS3oOdv9wrZjyTK37Xb/bD3m7Hmk8uh8/tx6HnS4SbfN5dRWFTfTKZYEG+QfrdSMyw8yLJCLQHoUlWXfYLOdDR68LoRsUF9/WNJ3nJyDSX40T3CuRHHoNaebGka7pjUNlhb2evwdWwxFtw2xfXC2Ere/cMdv16n3AxJxUmYtlji5AyOwn1xxvg6nVj879uQmRSKCEy4AkIizOzOB2Ve85h0YPzhdVMqPVqNJQ2DslZo+9FxvxULLh3jvBYkLBW7alG4+mWIccz/DKZ1uus6UREvEUkqZH1TpY3ueOd3a4r73sQtg47qg/WYOUTy4RlTDshF/ee3x8YmLFMVvHqp1bAEKlHUkEiDr1QAnuHAwqVEi3lrbj9ixuQOidZvA96fdAfEJPu6Nzc9627kZAXJ7bj6nEJK7tgbV7YzeOeDLAg3yB+TwAen4cruYchBwDJJkOVe2WJ7RdlGkhBoiwdB3I6btx5bdV1ICBp4AxEIFI7ebppjTcqZQDyGJWxTVXos5iQG4fbvrAu9J22edBwsgmlb57Clm+/jcd/+aiwGElEjVbDgMcnfX4qtn7vPTF32tHlQFzOxYzutKIUpMxMGnJBSq5ea4oVZe+eRXdjD3wuPzpruxCfExKyK6HWazDnztk48KfD+P2Tf0ZMZgyyF2cgf00u3H3uK+7bQQmnF+hrscHWasPJrWXCZd0/x91j86KvJXTBZo42QWvSiu2otSohuiS+3XXdQpTpQqR/dGbhujxhkNDFgMfuxYHnDgv3NWHvtIsOcT6XlwX5BmBBHgWTb9DgTYAMVBWgUF/d5u13X6tWanFS9kF5DJAUN57ApFe54A0abmwDzLREkmSceb8c3Q09WPXEMmElklUXlWoVIveXf3oZfa12aIwa4fofHOahHBKNXi3ESnDhOZGc5Q8i4PGL+Gw/tjYb3vvJB8J9PffOIiHuJ94qE+VOgxn+FaDHZIWT+5jEnzLAj79+Ek2nW4RlfKV9D4cSvdLnpQ4kecmShNm3FQrLu39HV/z6DQpxiYRNSvwSlrIMnUknSsTo/YhzGpTExYc+gr+LN0IY5QgzUwHh0hJX0tdel0RZZVVARYlexRJaI0LW3PWGtxWQoFO54ZPCqAaNCXvIqCShImFsq+wYyK0Qtft9bpGkRAJNcdjWynYh3P2hqjPvVyB5ZhJiM6KFyNUerR9w5+7/0yG8/q2tkIMXP8hkNVJS16KHFgi3MZVBOTodlxzT8I++1+nF69/cis66LmQvycTKx5di6YcXof1cJ3QW/RX3PTicRglrJJjkii9YmytulJhGnoBrZaHThQldfLRVtofE2O3Hm//5joiHx8+IE/uhiwXaJlntdBydNV2cZX2DsIXMjC2kx/T3Cpfb4ko7CMh+cm/LkL0yJIcMnxXosKtxzl4EjdKHSG0nDGonlCMcIkF9rZnJQbj4leiCMGNBGpILE/HaN98SFiQJF4kxWaIL7p0rkpdoWc6yLLz9/ffFOhRPbqtqFyVN1uRIzLu7SAiUGOYhyULo1n5yhXDv9hOVYhXb+uCZ3YjLiROJUJTtTBZyx/nOKx4jlRFFp1nxwTN7UXu0ASqVEnWlDZi5Ph/RKdYr7puaAg2Ok1NGOMWMG042i3Kr2pI6zLljttj+1aDjLrglDzt/tQ91xxtFVnVXbTdWPr5MJLnN3JCPd3+8XVjxZDk3nWoWSWqaa2yXuTx81phxQQxTunDVToIbdMqQbBKCLkk8pjadXr9XNDPxajwIqPxIiTDBusiOqu5FcDfoECl1IMNUgVhdM9RK/zVGL3JGZ7gjPCIJRvQZZZh847cfjxrwmS/WAl8NY6QBd/7zbaKkh6xgUbcdZ8a6W1YjfW6q2AbdNnxuLar3n0NLRZtwO1OGM9Uo03uatbEApmgjao7UiccUjybhJlY8vkQIcESCRTQaOftBpbAqizbNRHRqlGgcQnFYilFTFjVZ5YMhN/qqTyxDQm482qtDVvzSRxdixvIcIaZX2jdlcdO+yYqleuL5m4sQmWARokrrUd115sIMsQ9yOZOl3R/zJpfzLU+vFklkdH/5R5cgYUacEHs6TnocT3FrpQIrP74UCTPi0VzeCr1ZJ7LQ6SKHM6xvDIU8nvUvUxi6in7lP7agK7ENSv30FQPx8aGQkidk7VK7TE+5H4oYajLgFy43f8APn8oHn9IDr9oDn9qLAGVDK2TIdLtgMy0OxuCjT74AU4QdXrceTeczUF+ejb4mKyyuLiTrzyNW3yK6dA0WZklWYn/bJuREnEKSkWo1GaKsdxkiHv8Z5t0byqSdaPrreQ//+gBQMzR2OpZI0VoUPb4Q6cVpI3adCld1MOSuJst2sIU5eB0pGLoovFw3LbJ4RZ216vKNMQaacMgYEF4S55E00ujfN13h9jcTuZ59X9wGXSkroLzKeld7rUjsGna8g58biy5j0xm2kG8QumqmPtBh438bT8Gl9ygBMnmFJUByyZBcEvxdAQQcQQQ9khhc4aXOUEEv9C4DutTt8JPwGgMIUrYvuZ6v8v1XBzQw6X0wR9qg1gSh0TqQP/80cuecha3HivamJNSdzkNF3SJESJ1I01WJlplaZWjWsydoEhOhmPCFfrAp5nrrv90G32USj8YKyhKmxhTXIzhCaEaQiKi6yjrDrdvL7mOQG5sYqYCNdt8XtzGC5I7rfO1otssMhQWZubRJSHCQm1ncJATsErxeDzweD3xBH/xk8Qpr1we/2oeANvQDSz2qEwOpYplH5x7x2dUEtIiMdAgxHoxSJcEa243ImG7MKDoDr9uA5po01FXk4UztUmhtTsTrGuGXNDCq7cL64K594Q25Wq8Vu2SY6Qh/K24QailHV+HkpoVhcrmshduMkqr8shgCIVzNDgm+bj8C7iB8Tj+CcgBeeOFWuYSr2afxQlJLkCwSZKUUcjNf5m2LDFWdC2ZXBDxa14hDu9qAFvGJtVd8nkSWmoAYTC7kzK5AZmEV3A4TOlvjcXjbKtg8USixrUey6jxi9K1CnGnAwnQWZ2/QCBV5cRiGmRSwIN/oidOoYbDoIXfL4WvxSoOadZDF2ych6JSE+AbdQXgCHpFc5ZHdwuIVlq7KD7/JL9zMN5QnpQCcBjsSulOgCWrgV/mvvR05ZCHHxnWNeDcqlQRzpB0arQ96iwfF67ZCpQqioToL56vmAO0S0gyVSDHWwKB2QIngtBNnn6SHJYHaojEMMxlgQR4FVMMnd0z8r7xIFvEAkleGTPFdz4VSIrtfNJz3OD0IKALwK33wqN3wqbwisUrSSYAulFglGKO3QuLu1XgR4YxGV0TbNdcnN7c2oEPUdQgyQdcdDeeyoNYEkJ57buCvf70WHS0JqCnLx76aIui77UhQ1SPe0IhITRdUyqlfIiXLCkjy5duXMgwTnrAg3yg0kzfGBFTg5li8ZO1S/a6o4Q3FdgM2iu0GELAHxWB134WkKo/CJbKZgypKqAoiYA1Aojrdm/jb3GfqRnxvsrB8/Zqr17goZCWiTF4YzUPHRF4LclmfKZmHeSsPCTEWbm2VDJ3Bi9TseqRk1cNpN8PWFYX6ymyUVq6F1A0kq2uQbKiBUW0TNc9T0XIOymq4g6aLnZgYhgl7WJBHgSnKBHhG/2t+ucozYfE6ZQRtUiir2SHB7w4IF7PL44Jf4RcuZkqs8qv98Bu8kIbPA54ooVEAPo0HNmMP4nqT0BbdiKDqylapUlIg1uSBWjPyzNuAX42D769BbFIbUrNrLyuqtMwc4YDJ4kBSZgOk9Uq01KehoSobhyo3QdnhQ4K2HummKkRou0Sdc//rJjtBWYWgOoIbNDDMJIIFeRRQQT5ucNC66FJFiVU+ecDVHOiThJuZ2tNR1xufwgsfvPAo3fBq3ELUJL0EySBBJvENZ+FQAHZjL/R+A6LsceiKaBfJYJdDKasQF22DRucbsRifOlgMj8uIpRt3Qqm8ehy/X2BVagmp2XVIzqyHd6UeTpsF9RXZOF6+DoFuJeLlBiQZahGp7YJW6ZnUwkwWsjoqAUouR2GYSQML8igQ3W18CshUFD+svnBw/a7oVkWZzDa6BYXFK9zMvgC8AS/cfjd8ilAJESVVBdR+BCz+kMU7iUVBVsrojGxFbG8i4noT0RnZBonit8PeE7m1LRFdUKmvPjpR9CAJqHF89zI01WTglnu3wmh2XfdxkYAbTG5xi01qx5wVJaLOuaUuDSfL1kDqkhCvbkK6sQIWTQ9UisCIW3iGCzT9ShVNgsyNGhhmssCCPAoi4sxQKzWQfF5AG0qsotaQspvczZKI8VKnKp/HB5/PB7/SD69IqvKJMiK/1hd6nRCoqzfOmKxISgmd1lZE2+KR1JWO7oh2uHXOIe/VJGkRFdd5TUu3pz0Wh3esEvHiDQ++IZqIjAW0veTMBiRlNGDu8sOiEUlDZRZOVa6Gt1WLqEArko01iNM3Q6sKNSIJdwKyBurYUOtHhmEmByzIo4AyWM0mMxoO9CAYCCAYDMIrUVKVmxzNokczJVVJhiCCpmD4u5nHUZS7IttgcVoR25cAl94p3NmUjU0Z3gYoERnTc8nrRC5bUAWHzYLqskLUVeQgM78asxYdF4lbYw25qEmco+M7xQVC4aITsHVb0VybhqqyYpR1LEecohGpumpYNL1iwhSNfgxHbL5oRCRGQ6UJHwuZvEY0mOHoW6XoaOgYt/0YzUYs2lwsuoJdC6pCOP1euTiuy32/Fz4wH1qDZlQtds9sr0DuqhwxM/jYq6WYf88cGK4yntDZ7cSJradHvW9m8sGCPAroCxuVZMWh6gOwmXoQ0F8mKWkaCvDloEYidI5cegcinFGI704WMXGyls1BA/QGD6RgSDz8fg1s3VGi6UfjuUxhsSakNmPtPW9fd2nUaMRZq/MhJrFd3GYvOYbezhg01aSjsmoxnHVGWPzdSDNVItHYALUiFP8Ol7izU44VAw2up33kzRDkI68dw4svvwC7vm/c9kMldN1NPXjo6/cKEbwaXqcPh188JuYDm2PNQ54jdz+JJ3DjoujsdYdGFebGiTGIpVtOYeb6gqsKsr3TiQ+e2YM5d8xiQZ5msCCPAvqxS8iOQ3BfQMR+WXyvdrJCfyg+Tm7rXrNK/HBGOK1QBfU4+N5a0YmrH2r4QS0zZ8wuR1xKs+jQRc1Abjb9ekbH1m85F8w/CbfThKZzGag9PQdnWpchyt+KJF0NonSdopxqomPOPchBSlJkeAmyJKO9pR0OnU1UCIwX5HnptnfB7wlcU5AJGke44J75mLmhYMhyRX+vAUkWoSeNQSssXr/HL0oeqf1n//kN+oOwdzrERbol1izWoUlNA8hUlWHEw9+7T0yTEoskGa4+t5gwRXOXDZHDRFqWxTaDviDMsaah22OmJPwfHgX05YtJj4YZEehD99j9V6Y6CkBSBeFRuYQbvyiiB5seexmypBwQP53BI/pYhxv0+6vRBqDR9iFi4Unkzy9DT2cMOlvi0VBeiDM1kTD6+5BpKEesiDl7oARNwrl5xxiUVPCoE2FNCb8uXTdruNxAs5sRQP8aElcaH3g5nD0uvPOD98U4xqr95+Bx+IQ7fN3Tq4UwO7qc2PO7/WJ8I8Xsc5Zmwd7hwOxbC6GP0A9sx93nwdbvvYd7v34nTDFGnHizDOU7K8X4RYPVgAX3zEXeypzQ8csyyradxbmDtfA5fUgqTMTqp5aLcZHM1IUFeZTQFzLaHIUmXLkPM3OVD2BQg4T4duiN7rBx914PdNEQk9CB6PgO5BadhdejR31VFurOzkJZw/LQ2EhDjegSZlLbbsp7tPutUFoTxXB55tpIkoSWs62XuIfp/MXnxAnrt2rfebjtHqx8fKkQy3d/tAPH3zgpZhPv/u1+dNV145ZPrxJ13weeOyLmE+cszRwiyFRVUXe8AX6vX8w2pvVWP7kcCblxOH+4Dh/8Yg9SZieFjikooamsBaufWCZKIN/5/vtiJvG8zUVh5fVgxhYW5FFCnZBiIuOg6lFdtfkFcxnkkCDHxd+cuPB4EuoSJgnXev6808LVTsloPR0xqD01A9V186DrcyFNV4lYXYtwa6vHqYVnry8OkTlZ47LtqYgUkFC+swq1xxqGLCcLNzYrRtwPeANCfDOL08Xj5MJE9Db3obfFhuYzrVj58SXiORLrxQ8vQEv51VvGkquaXNZkUetMOhEvJgHXmbRwdDrFWMZlH1ks9kPbjE6PRk9Tr3jN8BJLZurAgjxKDFYjYpNioGs3wKVyjM1/ZRqh9+sRFTv5BXk4KnUQkdG9iIjqRUbeOXhcBpGgRsMvyqsWw+TuEZZzqrFaZGtTl7CxMHyoh3WPNx5xhSzII/5faVRY+uFFKFibO2Q5xY8HzyuOTIgY8hqyeD02D9w294A3gqxXU7RpiGV8OVJmJWPGsiy8++PtMEYaET8jFrnLs0UIrH87lJTXj1KlEFbzTfL4MxMEC/IoUSoVSC1IhqHEKDKImetBAas+AKPFMSnd1SOh/31RE5IZRWeRPbMCPq8O3e2xqCnLw56aImi6PEhS1yBe34hIXRdU1Hd8FC0zuxW5mDkjfuzexBSHxI+SqgYL7kjRGjUi9kzZ2oNd4NQs6GpIgSCWPLoQKx5firbqdlTvO48dz+wRQm6OGZrtzUwfWJDHgLSiVBgDZnRLHaI7VThTUFCAlJSUS5YfP34cdrsd8+cvQFZ2Fuw2G44cOYKOjlC9qFarhVqthsfjET84YwFpVaQ2IEqepgMkztS+06B2IyWrQTQjoQEZ7c2JImP7yJmZ0HW7kKSpQYrhvLCcqZzqei5WqCFIMH4OTDEmjjWOELI6fS7/pbXICggX8tWgUilrUiTKd1UhITdeWLLkrqbs6KtBAny+pB7rn14lXN1RqVFoPtsKZ5eLBXkaw4I8BkSlWpEQnYgWfwMCypEPSJgIS6C4eCGWLVs6sMxkMkGlUqG9vQM5M3Jwz+bN6O7uhtFoxLp16/DTn/5UDLS48847xbLy8nLs2LFjTERZKanElCeD6fqmPE0VSGiNFqdwadPNv16DztYE1J2dgYPn74DcLiNBXYcU03lE6dpHNPyi25sI66wc4TZlRkbQF8Du3+zDoedLLqlDvufrd4Smul0BcmsvfnQhtv73NvS19IkyKxLWS8Ze9pfPXXhIWdP7/nwYr31jK6LTo9Db1CsyvbOXZMDZc2mTEmZ6wII8BlB2ZnZeFspOHhd1tuEKJYds2fIGtm17VzxOTU3Fk089hbJTp9DZ2YGnnnoSNTU1eOaZZ5CXl4cnnngCK1asgN8fQFdXN95++x08/vjHcPr0abS0tIz6eKiHtdnshFY/OdpRjhf9AqvV+ZGc0Yik9EYxOKOv2yrE+Vj5eqj6fEhELRL0DTBr+i47/IIsvWZvPpJmpUEVhj2sRVw0MgL6gCFUtz9OiM+VxjKic2Cw6LHhH28RtcDDIVG1JkVAo9fggf+8e0hMd8G9c0WCFVnEVAJ17zfuQNPpFgT9EgrX5WHnL/cKcaaa5Du+slHEhqmO+IHvbBZWtVavwcP/fS8aTjYJa5pKqjIWpInnaH/3f/vuIWVYyz66WGyPQmTM1IUFeSxOok6N9KJUmI9HwoPwvrq12UL9n8n9/NBDD8Hr8eCll16G0+nAli1b0NTUJNzU8fHxwgrWanXih97pdMLlCg1yUCrH5sdeH9AhOq7hmj2spxsktJStTbfEtGb41mjR2ZIguoSJ/totGsSrG5BuqhSTqWj4BeGVDOgM5mDR/FAmcLhBArf47mLYu+yoa6gLDV8ZB6Ks0Vjz8EroLVdPrOr/7uYsybzmeoW35A95nFSQIP5SSdKB5w7DmmTF3DtnCxP4xJYySJKMuOwY4fKesTz74nbWXdxOTEa0uA2HjrvwlrwhFzJpRZeGmZipBwvyGEBfmNQ5KUjQJKFLbruupgQTxbx581BUVIQXXngB3d1dwnp+//33xXMJCQnCRU3vorT0ONra2rB582Z87GMfRWlpKZqbm8fkGHRBNWIT28dkW1MZauEphl+kNyKwXA1brxU1p3NRWrUuNJlKbkSCvl6MXDQXFA90ggrH7wm5Z+/72maR1DRu+1Eqb9ocaLVWhYwF6cIiLt1yErJEGdhKrP3Uyks7bzHMNWBBHiPismKRmJCA6lYdvNrwTlKiBK1Vq1bB4XAIge3vnqRQKDF79mx86EMPwxoVhZdfekm4pwOBAJ599lkYDEb09fWOTbclGdAGdbBG945+W9MEhVKGRucXjUjoVrTsqOiv3d6YhMqyRWirTcGce2ZCFcYzkEmUhVjeJMG8Ge9nxtIsRCVHwtZuF96jiESLSPTiBh7M9TI1vhVhAF0VFyzJx9G/HhFTnsK5r3VUVBTmzJmDvXv3oa8v1OSffjzmz5+HT37yUyKe/POf/xyVFRUDyVuUXU23sUIlqWBUyaI3NHNj0MSrhLRmxKc2Y9bi49jyl39CalFqWH/2piLkio/NjBE3hhkN4Zf5MYnJWZSJGGUcFGH+i5iVnQ2dToczZ84MLDObzXjo4YdhNptgtzuwaOFCfPjDH8bSpUvHLGY8GIWsRIzVEZb9qidjzLmzLR5qy0zR6pEtM4aZnLCFPJbxsdQo5Ofko76hBn5N+GYOazVa1NbWorGxcWAZlT7RCDpaFhVlFTfC4XQKVzYwtsJJFnK81QblOLWPnE7IkgI1Z/KRXjz3mnWzDMOELyzIYwh12ckpzsbh6ih0aloRruzbtxcHDx6A33+x9KS3txff+MY3LlmXXNbBYCiLd6x7WMfGtkF1g/2/nTaz6BVtNDthsYYyx/sJBlTo7YoSAytMlqlf4+xx69HUMB8bP3Ixm5dhmMkHC/IYW8kFa3IR+1IcuoMdYsRgOBIMBsVtOD7f+M2oHY4hqIU1ulskKl0PlE92pmQeSnauhNeth1bnxdwVhzF32RHygyPg16C1PhUfvHYH5iw7gvkrD4nX2HusomyIGnEkZ9ZDow3fevHrpbs9HsakNbDEXayTZRhm8sEx5DGG6hELZxVC7zOMW53lVMCsVMIcdf3jCN1OI/a8dSsUCglLNuwSFvLuLbfB0WdBZ0sitj73IN589mG0NSTD5wk1VggG1EKgO1oScHzPUlSUzsZUgS42Kk4uRe7KQmj0fH3NMJMZFuRxyLaes3EWYoOhxgHM5TErAXPEUFfzSPD7tPB6dEjNqcXsxceQnncOAb9aDGxQKiUh0JR5PPhayGk3i9fMX3UQM4rOoKUubcr8W7ra4mBzFSN7SRYnczHMJIcvqccY0VVnbiqyErLQ0tsY1sldE4VSVsKskcR4wuvFYu1DwbwynD4yX9TgttaniAlK1thuqDUB3Prw66ityEF1WcHAa4xmh3Btn9y/CB0tiWJW8VRAEslchchYvEpMHZoshMYIyuP6HaRSJM42ZyYbLMjjADWjn7uuCKf/fAqdEW1cFzr8Q0e9hi1u6AzuG0rmamtMhlrjh07vgVrrR2tDKno6YhGXfPlEOhLqDQ9uQV1FjrCsU7LqMRUgl3xj43qs/9DQOb7hjLPbiVPbzsBpH79kO7Vag6INMxGdFjVu+2CY8YAFeRygK/PCNflIezUDPVIXgqoxzlKe5FDz/9i49huagVxXkYu2xiTc/sirmLXoOCpOzMYbf3gU58/mXlGQaT/mSDtmLS7FVIEMzKpTRYjJWyqmjU0Ga5Ay9o+/fQpHjh2Gchy1UnLL6G7qxl1ful0MargaXXXd2PP7A1j66EIk5l8MM/k9fuz+7X5ExFuw6KEFOHeoFmXvnsHGf1gLo9V4XcfT3diD7T/bhbWfXiUmQp3ZUYENn6PtcGtNZigsyONEZGIEFqxegNr3zqPH2MlWcj8yoAlqkJAYmrN8vag0figUMnq7oiHJCti6SYwkmCPsmC6QGFNy2/mKZbjlS8VQacK3VeZgaDpST0cPlLGAyjJ+6SvKCBmONgd8bv81BZmEt/1cB7wu3yXH2t3QO5CYaYjQi05cyhtoS+r3BNBa1Q6/2yf6W9N0KBrtyDDDYUEeJ+hHcv7mIpTsPgqb1MtW8iC0AR2sMT03dF6zCqqE2/nIBytxYt9i+P0a5MysQM4UiQuPlMZz2TClroc1OXKiD2VaQKMXsxZliBGKzh4XXL0uMZWJxJw688XnxIrRif0x8p7GXmEZ0zqDZyPThbrYzhTp5c2MLfypGEfoinr+ynmoe/88ek1dbCWLlpkKmGjObEz3DZ1TncGDOz78Mppr09HbGY3ImB6kzzgv4sn9xCe34r4n/4zYpDZMRSjTvPLMehR/dP6ksY7DGhkIeAPwDbKSybru7+NONJxowtG/leLeb96J+tIGHHm5FAaLDm6bB85uF2KzYsTcY1O0EZV7qrH3j4eEK0Nr1MISb4EUCG2r/ngDjr9xCvd84w6Yo00T8naZ8IUFeZxZcNccnNx3EqVyDyQF920mayLa4oJGd2NNSChUGhHVB4v11JBlg6HmH3lzL/bpnmru6rPH5iIi8zakz0udFLHjcIfc1bt+vU+4pfuRgjLaqjsQmx6aVxz0B+Gxe4QrO+ALoqW8VQjwzPX5sLXZ8bunnkNrRZsYw7r3D4dQeEsuljy6UAj9tp98IF5PBGg7jtB2GGY4LMjjCP1Y0pXz/NXzUPdODbrM7dPeShZDJUw+aLWj6wo2XXWIsszPV96CW76wcIgrlLlxlCql8GZFJkUMLCMBpXGKV8IYaUDhLXnChW2KNsEcbYSj2ymSxOi1OUuzxHN0o/Vqj9Txv4i5JizI4wzNpl30wAIc33MCtkAv/GrftBZl6mEdbbVBo+f67BvqynViARLm3ImYC5YbM3qow9ncu2YjY/7FhjHkvu6q67nqxTaJbejBxStEsqKVKgVU/c+J+HMEFCpO4mKuDX9KbgKUyLH63hWI8yRiuqMPaBEZ1XvDQyWmsxhTU5P6+tux4H6OHYcr0elRwqXtdVzMaaAkMHZRMyOBBfkmucSKNs1CYfpMGHymad3j2ihpEBXfOW1dzjeKFFThTMky5G3YBMuFbN5JCX32p/DnPyLOIhqSlL5ZBnuHA90NPTix5ZSIJTPMtWBBvkmYooxY++FVSPSmiDjqtEQGDJLmhlpmTnfruKE6G/bgAyhYk4/JCrl5dTodJKcsWmeO280NqBUUv712BrpSo4I5xnzR/XzxYGGMMoiyJYLqmc2xJihUCmgNGljiLl4U0cUlXSRpDVpRX7zuM6vg6HTi9598Di999TVRmkYiTRnxYjsxZnGRzjDDUcjj2VSWGQKVUrzzP+/j7X1vonsaNgtRSkrkOxPxj1/89bSYUzxW2HsjsP21J7D8M19CalEKJiv0U0NJT3ufP4DOzi4oVOPUeAZaLH9gCXJGMHCDErBcfW6RYT1YlMnFTMtVaqUQZfru+pxeGKOMCPgC8Dq8ou6Ytk/rUkKXzqQdaETioXKo3tDrqZWux+6FwWqAFAjC5/KLLl0sysxwWJBvMp113fj9V/6Ek75j8Gk800qUNX4tFmqM+Lt/+g1UKi4BG+kAiYPv3QrE/z+semLFlKg7psYZFFcdD+jrpLPooeHGG8wkhLOsbzIxaVHY+LF16PxFO+o05yBP5YDaMNRBNWLi7NPpGmRUkO+qrmIGOm334/bPFk+ZdotkGU7qODjDjBNT4xs+iaDa0cI1eViyaCkindFTOsFlCDKgktRIiO8SvaiZa+Oym3H84L1Y9NjtoqsTNwFhmKkNC/IEoDVpcctTq1EYOQt6n2HaiDJNeYqJoxai0+QNj8Iy9vvUOLJzPdKX34fU2ZM3bswwzMhhQZ4AyNKxJkZg06dvQ7aUJ5plTAcsUMMcaeOSpxFQfnw+POoPo/j+BVMibswwzLVhQZ5A13Xuimys2bwacY5EKKSpH1mNMPhgtDgm+jDC3jpua0hBVdUjWP7xdWI4AcMw0wMW5Ik8+SolFj9UjJWLV8HqjpnSrmua8hSllWA0c7nT1ejrisL+7Y9g0WP3ISYjmuPGDDONYEGeYKhJ/fpPr8HcxPkweyKmrChrglqYDR4YTONT7jIV8Lj1KNl1OzJXPYzM4nQWY4aZZrAghwHUyeeOp29Dnq4QWr9+SoqyJqhBZFQfVGpuIXg5ggEVDu9YB23K41j4wIIpU+LEMMzI4W99mCR5pc1Lwean70J2IFdYk1MNnV+PuATuYX05AgEVTh1aBLfqE1j64ZVQaVVsHTPMNIQFOUxQKpXIW5mDOz58O1L9mVAF1VPHUpYBLY1dpJInZuipkRQ4VzYL52s/gVWf3CjaLHK9McNMT1iQwwgqb1n00AJsuud2pDgyoJJUUyahi1zW0fGdE30oYdcWs6Y8F2fLP4kNX3hQjOlkGGb6woIchuVQSz60ELfefStSXFPDUlbKKsRa3NAbOaFrsBjXVeSh5MAnsfwT9yOWM6oZZtrDghxmkLtSb9Zh7ZMrsOHWDUhxZkBJlrI8uac8xUa4oFIFJ/pQwgJZAmrL83Bk35NY+7nHkDI7aaIPiWGYMIAFOUxR69S45VMrcdtdtyLVkSn6QE9W6IIiNsoGlZoFOeSmzsfRQ3+HNRfEmGPGDMOI30o+DeEJ/UhTl6ZVjy/Dxk0bkOrJmLTua21QC2tM97QveQoGlcJNffTgE1j96YeQOjuZxZhhmAEmr9k1jQZRrPv0ahitRrz90juo1VUjoPJPqjnKFkmLiKjead3DWgoqcfrIfNTUPYWNX34AcdmxLMYMwwyBBXkSWMrkvl76yELoLTpsffYdnAtWwKN1TxpRNqpkREb3YNpObvJqceLAMrT1PoG1n7sTcVkxE31YDMOEISzIkwQS5QX3zBVzcd/4v62o8JyGQ28Le1GmkieTQgWz1YbpKsb73rkDActHcesXb4U51jzRh8UwTJjCMeRJNowif3UuHvv3h7E8dTVinPFQSOH9L6TRkiatf1payN1tcXj3pcdhzv8i1n32DphiTBN9SAzDhDFsIU/COuWUWUl44N82I/IXETh4+CBajA1hG1emRLSomD4oFJMwG20Ufanrqmbg1LEHkHf7o5i1oUB4OBiGYa4G/0pM0rgydXXa/NVNSH09Ge8+9z5qVFVw6y6MNgwjYdYGtEhIaMZ0cVH7vFqcOrAEDa0fxfKn7uBMaoZhRgwL8iQvi1r0UDHic+Kw7TfbcarpBHoMnQiGSwMOGVAHtIidBi0zqSd1V1scDu+8G6aM+3Hnv66GKZr7UjMMM3JYkCc5KrUSWYsy8Ejqg0j/Sxr27NiLZl09PJrwyMKmoRKRMT1T2ioO+DWoLpuF06UPYvY996JwXR40Os1EHxrDMJMMFuSp4sJOisCt/7AOWcUZ2PncXpxqPIFecxeCqsCEZljHmnwwmR1TsgaZxLijORHH962HKvYB3P6vtyAqOVLE+RmGYa4XFuSpVK+sVaNgTR4ScxOQ/UomDu44hHpfDZw6O2TlzU+qUkCBKL0fGp0PU02I3U4jzh4tRn3DXZh5x53IW5ULrVHDzT4YhrlhFLJMPy/MVKL/X1pbUo/9Lx5Gyckj6DK1wavxhFa4SQacOqDGpigV7vnYX6HTezHZodMaDKpQVzkDJw7ejpiZd2HRg4uEd4L7UTMMM1rYQp6C9ItD5sJ0JBUkYPaeQhx87TBON5SJpC+f2ntTRFkb0CMyqgNanXdKlDK11qfi9LE1kE23YeXn1iIxL154JRiGYcYC/jWZ6qMcLXrMvWM2shZm4PR7Rdi/5QDqbLXoMrSPe+2yIahFVGz3pI4fBwNK9HTG4NThFbB7bsesO9Yie0kWdCbtRB8awzBTDHZZTyNkSYaz24mT75xByTtHUdlZAZuhF95xyshOsSfgqQffw4zZ5ZiMwyCa69JQdXIOet13IX/9EhSsLRBCzO5phmHGA7aQpxGU/Uu9lJc9tggz1+WjfFcljm8/gfPt59ChaINX64akkMZEnCnDWi+pJ1XLTIoRe90GtDUmo/zESgQ0K5G7dhlWFGfCFGXk7GmGYcYVtpCnefKX2+bBuYM1KNt+BidPnES3uhN2Qy+CygvNRW5QnNVBNWZ6Y/FPX30GGq0f4SzCsqyAy24WtcT15xdAG7sO+bfMRdaidGj0oXpitooZhhlvWJAZIcx+jx+dNd04veMsqo6dQ3VrFfpUPaIdZ1AZuG5h1vp1WG5W4/G/exZqTZh0DhsmxCTCZA3XVc9Bn3MV4vJnYdbGObAmW6HRq1mEGYa5qbDLmgm14TRokTwzEYkF8VjSuRBNZc0o31eF8pMV6HC1oVfVA4/GCUkpQaaemIprD5WIj+qDYgLqn68kwFJQJXpNd7fF43z5HHR3z0JE2hJkbJiJ5MIkWOLM7JZmGGbCYAuZuaLVTElgHrsH5w7XovZoPeoq61HTfB4OlR0erUskg8mDpzj1i7QMRLis+NjycixetxuKCZgQ2V9dTz2muzviRMlSS30GnN7FMCfPRsrsDGQtzhTzpSm2zi5phmEmGhZkZkQEfAG4et3obe5D3ckGVJVUo6ujG13uDvQEuuFVuxFQBsRgC0kRRLwtAU9u3o3C4hM3rezJ59WIpCyPW4/ejli0NBTAZpsBWZOO2Nx8pM2dgZj0aJiijVw/zDBM2MGCzNwQwUAQ9g4HOmu60FnXjZaqVjTXt6ClpRmuoAsWSYV1qw9hxuzTsFj7oNb4hTCLucgKOWRMX7CuryTYAz3kZAUZ3UP+SpISTpsZ9j4rejri0dsVA1t3HHxSKgyxhYhMyUR8TizismIQlRYFtUbF/2mGYcIaFmRmTNzbQX9Q3PxuP9prutDT2IO+5g7Y27vgdTqhlLug03ZBreyAStkLraYXKnUQFoozD3Z7D8Pr0sPlMCEY1CIgxcHni4BfikcgGA+13gxTdASi0uIRkRCN+BnxMEQYoNaqoNKo2BXNMMykggWZGVekoASv0wuvwwe/1w+fyy8yuskFTvftnY5BpvClaAwaRMRbRIyXmnIo1SrxV2fSib/9ZUkMwzCTHRZkZsIY6VwTTrhiGGY6wGVPzITBQsswDHORCShIYRiGYRhmOCzIDMMwDBMGsCAzDMMwTBjAgswwDMMwYQALMsMwDMOEASzIDMMwDBMGsCAzDMMwTBjAgswwDMMwYQALMsMwDMOEASzIDMMwDBMGsCAzDMMwTBjAgswwDMMwYQALMsMwDMOEASzIDMMwDBMGsCAzDMMwTBjAgswwDMMwYQALMsMwDMOEASzIDMMwDBMGsCAzDMMwTBjAgswwDMMwYQALMsMwDMOEASzIDMMwDBMGsCAzDMMwTBjAgswwDMMwYQALMsMwDMOEASzIDMMwDBMGsCAzDMMwTBjAgswwDMMwYQALMsMwDMOEASzIDMMwDBMGsCAzDMMwTBjAgswwDMMwYQALMsMwDMOEASzIDMMwDIOJ5/8DnZVp4GqS2DgAAAAASUVORK5CYII=", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up GraphVision AI Models from Hugging Face...\n", + "\n", + "🚀 Analyzing: ./../Test/PieChart.png\n", + "----------------------------------------\n", + "📊 Detected Chart Type: PIE\n", + "\n", + "=========== GraphVision-AI ===========\n", + "\n", + "{\n", + " \"chart_type\": \"pie\",\n", + " \"title\": \"Tha Learning App\",\n", + " \"data\": {\n", + " \"Mathematics\": 30.34,\n", + " \"Science\": 23.11,\n", + " \"Social science\": 16.99,\n", + " \"English\": 22.5,\n", + " \"Hindi\": 7.07\n", + " }\n", + "}\n", + "\n", + "Time: 0.6006572246551514 seconds\n", + "\n", + "=========== DePlot ===========\n", + "\n", + "TITLE | <0x0A> Mathematics | Mathematics | Science | Social science | English | Hindi <0x0A> BVJU's | 46% | 46% | 46% | 54% | 54% <0x0A> Mathematics | 72% | 81% | 79% | 54% | 54%\n", + "\n", + "Time: 10.269865274429321 seconds\n" + ] + } + ], + "source": [ + "compare_models(\"./../Test/PieChart.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d85430e5-5b2d-4615-9cd1-19a931924513", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up GraphVision AI Models from Hugging Face...\n", + "\n", + "🚀 Analyzing: ./../Test/hbar2.png\n", + "----------------------------------------\n", + "📊 Detected Chart Type: HBAR_CATEGORICAL\n", + "\n", + "=========== GraphVision-AI ===========\n", + "\n", + "{\n", + " \"chart_type\": \"hbar_categorical\",\n", + " \"title\": null,\n", + " \"x_axis_label\": \"Average Trip Duration (Seconds)\",\n", + " \"y_axis_label\": \"Start Station\",\n", + " \"data\": [\n", + " {\n", + " \"category\": \"University and Emerson\",\n", + " \"value\": 7088.45\n", + " },\n", + " {\n", + " \"category\": \"Califomia Ave Caltrain Station\",\n", + " \"value\": 4628.76\n", + " },\n", + " {\n", + " \"category\": \"Redwood City Public Library\",\n", + " \"value\": 4590.23\n", + " },\n", + " {\n", + " \"category\": \"Park at Olive\",\n", + " \"value\": 4432.11\n", + " },\n", + " {\n", + " \"category\": \"San Jose Civic Center\",\n", + " \"value\": 4209.7\n", + " },\n", + " {\n", + " \"category\": \"Rengstorff Avenue / California Street\",\n", + " \"value\": 4173.64\n", + " },\n", + " {\n", + " \"category\": \"Redwood City Medical Center\",\n", + " \"value\": 3969.51\n", + " },\n", + " {\n", + " \"category\": \"Palo Alto Caltrain Station\",\n", + " \"value\": 3216.13\n", + " },\n", + " {\n", + " \"category\": \"San Mateo County Center\",\n", + " \"value\": 2726.41\n", + " },\n", + " {\n", + " \"category\": \"Broadway at Main\",\n", + " \"value\": 2483.8\n", + " },\n", + " {\n", + " \"category\": \"Cowper at University\",\n", + " \"value\": 2482.5\n", + " },\n", + " {\n", + " \"category\": \"Redwood City Caltrain Station\",\n", + " \"value\": 2429.7\n", + " },\n", + " {\n", + " \"category\": \"South Van Ness at Market\",\n", + " \"value\": 2408.42\n", + " },\n", + " {\n", + " \"category\": \"San Antonio Caltrain Station\",\n", + " \"value\": 2392.25\n", + " },\n", + " {\n", + " \"category\": \"San Antonio Shopping Center\",\n", + " \"value\": 2297.51\n", + " }\n", + " ]\n", + "}\n", + "\n", + "Time: 3.1365838050842285 seconds\n", + "\n", + "=========== DePlot ===========\n", + "\n", + "TITLE | <0x0A> Start Station | Average Trip Duration (Seconds) <0x0A> San Antonio Shopping Center | 2301 <0x0A> San Antonio Caltrain Station | 2307 <0x0A> South Van Ness at Market | 2310 <0x0A> Redwood City Caltrain Station | 2311 <0x0A> Cowper at University | 2312 <0x0A> Broadway at Main | 2315 <0x0A> Palo Alto Caltrain Station | 3075 <0x0A> Redwood City Medical Center | 3951 <0x0A> San Jose Civic Center | 4304 <0x0A> California Ave Caltrain Station | 4613 <0x0A> University and Emerson | 7105\n", + "\n", + "Time: 15.55116605758667 seconds\n" + ] + } + ], + "source": [ + "compare_models(\"./../Test/hbar2.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "8ed9ac31-f59d-4f7f-bad6-37e66000176d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('TITLE | <0x0A> Start Station | Average Trip Duration (Seconds) <0x0A> San Antonio Shopping Center | 2301 <0x0A> San Antonio Caltrain Station | 2307 <0x0A> South Van Ness at Market | 2310 <0x0A> Redwood City Caltrain Station | 2311 <0x0A> Cowper at University | 2312 <0x0A> Broadway at Main | 2315 <0x0A> Palo Alto Caltrain Station | 3075 <0x0A> Redwood City Medical Center | 3951 <0x0A> San Jose Civic Center | 4304 <0x0A> California Ave Caltrain Station | 4613 <0x0A> University and Emerson | 7105',\n", + " 15.70194411277771)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "run_deplot(\"./../Test/hbar2.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "086adda0-cf6d-4d97-b538-27cbcc82b64b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up GraphVision AI Models from Hugging Face...\n", + "\n", + "🚀 Analyzing: ./../Test/hbar2.png\n", + "----------------------------------------\n", + "📊 Detected Chart Type: HBAR_CATEGORICAL\n" + ] + }, + { + "data": { + "text/plain": [ + "('{\\n \"chart_type\": \"hbar_categorical\",\\n \"title\": null,\\n \"x_axis_label\": \"Average Trip Duration (Seconds)\",\\n \"y_axis_label\": \"Start Station\",\\n \"data\": [\\n {\\n \"category\": \"University and Emerson\",\\n \"value\": 7088.45\\n },\\n {\\n \"category\": \"Califomia Ave Caltrain Station\",\\n \"value\": 4628.76\\n },\\n {\\n \"category\": \"Redwood City Public Library\",\\n \"value\": 4590.23\\n },\\n {\\n \"category\": \"Park at Olive\",\\n \"value\": 4432.11\\n },\\n {\\n \"category\": \"San Jose Civic Center\",\\n \"value\": 4209.7\\n },\\n {\\n \"category\": \"Rengstorff Avenue / California Street\",\\n \"value\": 4173.64\\n },\\n {\\n \"category\": \"Redwood City Medical Center\",\\n \"value\": 3969.51\\n },\\n {\\n \"category\": \"Palo Alto Caltrain Station\",\\n \"value\": 3216.13\\n },\\n {\\n \"category\": \"San Mateo County Center\",\\n \"value\": 2726.41\\n },\\n {\\n \"category\": \"Broadway at Main\",\\n \"value\": 2483.8\\n },\\n {\\n \"category\": \"Cowper at University\",\\n \"value\": 2482.5\\n },\\n {\\n \"category\": \"Redwood City Caltrain Station\",\\n \"value\": 2429.7\\n },\\n {\\n \"category\": \"South Van Ness at Market\",\\n \"value\": 2408.42\\n },\\n {\\n \"category\": \"San Antonio Caltrain Station\",\\n \"value\": 2392.25\\n },\\n {\\n \"category\": \"San Antonio Shopping Center\",\\n \"value\": 2297.51\\n }\\n ]\\n}',\n", + " 2.6699750423431396)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "run_graphvision(\"./../Test/hbar2.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "378e38ae-d1c9-4296-97b2-db657ba3f2ec", + "metadata": {}, + "source": [ + "## Real testing" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "452753d6-a099-484a-b344-1079bb2db898", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "\n", + "from transformers import (\n", + " Pix2StructProcessor,\n", + " Pix2StructForConditionalGeneration,\n", + " DonutProcessor,\n", + " VisionEncoderDecoderModel\n", + ")\n", + "\n", + "from graphvision import GraphExtractor" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9a83113a-e5b5-4d81-8feb-a17f5bda8764", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights: 100%|███████████████████████████████████████████████████| 285/285 [00:00<00:00, 1854.97it/s, Materializing param=encoder.layernorm.weight]\n", + "Loading weights: 100%|███████████████████████████████████████████████████| 285/285 [00:00<00:00, 2196.68it/s, Materializing param=encoder.layernorm.weight]\n", + "The image processor of type `DonutImageProcessor` is now loaded as a fast processor by default, even if the model checkpoint was saved with a slow processor. This is a breaking change and may produce slightly different outputs. To continue using the slow processor, instantiate this class with `use_fast=False`. \n", + "Loading weights: 100%|██████████████████████| 484/484 [00:00<00:00, 1736.99it/s, Materializing param=encoder.encoder.layers.3.blocks.1.output.dense.weight]\n", + "The tied weights mapping and config for this model specifies to tie decoder.model.decoder.embed_tokens.weight to decoder.lm_head.weight, but both are present in the checkpoints, so we will NOT tie them. You should update the config with `tie_word_embeddings=False` to silence this warning\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🧠 Booting up GraphVision AI Models from Hugging Face...\n" + ] + } + ], + "source": [ + "device = \"mps\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "# Pix2Struct\n", + "pix_processor = Pix2StructProcessor.from_pretrained(\"google/pix2struct-base\")\n", + "pix_model = Pix2StructForConditionalGeneration.from_pretrained(\"google/pix2struct-base\").to(device)\n", + "\n", + "# DePlot (Pix2Struct fine-tuned)\n", + "deplot_processor = Pix2StructProcessor.from_pretrained(\"google/deplot\")\n", + "deplot_model = Pix2StructForConditionalGeneration.from_pretrained(\"google/deplot\").to(device)\n", + "\n", + "# Donut\n", + "donut_processor = DonutProcessor.from_pretrained(\"naver-clova-ix/donut-base\")\n", + "donut_model = VisionEncoderDecoderModel.from_pretrained(\"naver-clova-ix/donut-base\").to(device)\n", + "\n", + "# GraphVision\n", + "extractor = GraphExtractor()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "795463db-ade2-4918-adb1-2f2e0b8c8c05", + "metadata": {}, + "outputs": [], + "source": [ + "def run_graphvision(image_path):\n", + "\n", + " start = time.time()\n", + " result = extractor.extract(image_path)\n", + " end = time.time()\n", + "\n", + " return result, end - start" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "637fa1ae-1dc1-4557-b07e-ccb19e8eac5f", + "metadata": {}, + "outputs": [], + "source": [ + "def run_deplot(image_path):\n", + "\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + "\n", + " inputs = deplot_processor(\n", + " images=image,\n", + " text=\"Generate underlying data table of the figure below:\",\n", + " return_tensors=\"pt\"\n", + " ).to(device)\n", + "\n", + " start = time.time()\n", + "\n", + " predictions = deplot_model.generate(**inputs, max_new_tokens=512)\n", + "\n", + " end = time.time()\n", + "\n", + " output = deplot_processor.decode(predictions[0], skip_special_tokens=True)\n", + "\n", + " return output, end - start" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "4bd53dd1-1177-4a84-ac7f-80002275c876", + "metadata": {}, + "outputs": [], + "source": [ + "def run_pix2struct(image_path):\n", + "\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + "\n", + " inputs = pix_processor(\n", + " images=image,\n", + " text=\"Describe the chart\",\n", + " return_tensors=\"pt\"\n", + " ).to(device)\n", + "\n", + " start = time.time()\n", + "\n", + " predictions = pix_model.generate(**inputs, max_new_tokens=512)\n", + "\n", + " end = time.time()\n", + "\n", + " output = pix_processor.decode(predictions[0], skip_special_tokens=True)\n", + "\n", + " return output, end - start" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "e981b17c-e9a1-46b4-8c13-2531d7214659", + "metadata": {}, + "outputs": [], + "source": [ + "def run_donut(image_path):\n", + "\n", + " image = Image.open(image_path).convert(\"RGB\")\n", + "\n", + " pixel_values = donut_processor(image, return_tensors=\"pt\").pixel_values.to(device)\n", + "\n", + " start = time.time()\n", + "\n", + " outputs = donut_model.generate(pixel_values)\n", + "\n", + " end = time.time()\n", + "\n", + " result = donut_processor.batch_decode(outputs, skip_special_tokens=True)[0]\n", + "\n", + " return result, end - start" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "575720f8-b703-40e8-a020-03aa4359e327", + "metadata": {}, + "outputs": [], + "source": [ + "def compare_models(image_path):\n", + "\n", + " img = Image.open(image_path)\n", + "\n", + " plt.figure(figsize=(6,6))\n", + " plt.imshow(img)\n", + " plt.axis(\"off\")\n", + " plt.title(\"Input Graph\")\n", + " plt.show()\n", + "\n", + " # GraphVision\n", + " gv_output, gv_time = run_graphvision(image_path)\n", + "\n", + " # DePlot\n", + " deplot_output, deplot_time = run_deplot(image_path)\n", + "\n", + " # Pix2Struct\n", + " pix_output, pix_time = run_pix2struct(image_path)\n", + "\n", + " # Donut\n", + " donut_output, donut_time = run_donut(image_path)\n", + "\n", + " print(\"\\n=========== GraphVision ===========\")\n", + " print(gv_output)\n", + " print(\"Time:\", gv_time)\n", + "\n", + " print(\"\\n=========== DePlot ===========\")\n", + " print(deplot_output)\n", + " print(\"Time:\", deplot_time)\n", + "\n", + " print(\"\\n=========== Pix2Struct ===========\")\n", + " print(pix_output)\n", + " print(\"Time:\", pix_time)\n", + "\n", + " print(\"\\n=========== Donut ===========\")\n", + " print(donut_output)\n", + " print(\"Time:\", donut_time)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "a5ad679f-4359-4c69-8a3a-128e9a17f7d6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "🚀 Analyzing: ./../Test/hbar2.png\n", + "----------------------------------------\n", + "📊 Detected Chart Type: HBAR_CATEGORICAL\n", + "\n", + "=========== GraphVision ===========\n", + "{\n", + " \"chart_type\": \"hbar_categorical\",\n", + " \"title\": null,\n", + " \"x_axis_label\": \"Average Trip Duration (Seconds)\",\n", + " \"y_axis_label\": \"Start Station\",\n", + " \"data\": [\n", + " {\n", + " \"category\": \"University and Emerson\",\n", + " \"value\": 7088.45\n", + " },\n", + " {\n", + " \"category\": \"Califomia Ave Caltrain Station\",\n", + " \"value\": 4628.76\n", + " },\n", + " {\n", + " \"category\": \"Redwood City Public Library\",\n", + " \"value\": 4590.23\n", + " },\n", + " {\n", + " \"category\": \"Park at Olive\",\n", + " \"value\": 4432.11\n", + " },\n", + " {\n", + " \"category\": \"San Jose Civic Center\",\n", + " \"value\": 4209.7\n", + " },\n", + " {\n", + " \"category\": \"Rengstorff Avenue / California Street\",\n", + " \"value\": 4173.64\n", + " },\n", + " {\n", + " \"category\": \"Redwood City Medical Center\",\n", + " \"value\": 3969.51\n", + " },\n", + " {\n", + " \"category\": \"Palo Alto Caltrain Station\",\n", + " \"value\": 3216.13\n", + " },\n", + " {\n", + " \"category\": \"San Mateo County Center\",\n", + " \"value\": 2726.41\n", + " },\n", + " {\n", + " \"category\": \"Broadway at Main\",\n", + " \"value\": 2483.8\n", + " },\n", + " {\n", + " \"category\": \"Cowper at University\",\n", + " \"value\": 2482.5\n", + " },\n", + " {\n", + " \"category\": \"Redwood City Caltrain Station\",\n", + " \"value\": 2429.7\n", + " },\n", + " {\n", + " \"category\": \"South Van Ness at Market\",\n", + " \"value\": 2408.42\n", + " },\n", + " {\n", + " \"category\": \"San Antonio Caltrain Station\",\n", + " \"value\": 2392.25\n", + " },\n", + " {\n", + " \"category\": \"San Antonio Shopping Center\",\n", + " \"value\": 2297.51\n", + " }\n", + " ]\n", + "}\n", + "Time: 2.6706950664520264\n", + "\n", + "=========== DePlot ===========\n", + "TITLE | <0x0A> Start Station | Average Trip Duration (Seconds) <0x0A> San Antonio Shopping Center | 2301 <0x0A> San Antonio Caltrain Station | 2307 <0x0A> South Van Ness at Market | 2310 <0x0A> Redwood City Caltrain Station | 2311 <0x0A> Cowper at University | 2312 <0x0A> Broadway at Main | 2315 <0x0A> Palo Alto Caltrain Station | 3075 <0x0A> Redwood City Medical Center | 3951 <0x0A> San Jose Civic Center | 4304 <0x0A> California Ave Caltrain Station | 4613 <0x0A> University and Emerson | 7105\n", + "Time: 16.26478385925293\n", + "\n", + "=========== Pix2Struct ===========\n", + "Describe the chart.> 5% Error Threshold:\n", + " - Recall: 55.66% | Precision: 57.82% | F1: 0.5672\n", + " > 10% Error Threshold:\n", + " - Recall: 63.43% | Precision: 65.88% | F1: 0.6463\n", + "----------------------------------------------------------------------\n", + "\n", + "🟩 CHART TYPE: HBAR_CATEGORICAL (199 images)\n", + "\n", + " [ TYPE 1: Global Chart Text (Average Match %) ]\n", + " - Title Accuracy: 100.00%\n", + " - X-Axis Label Accuracy: 91.76%\n", + " - Y-Axis Label Accuracy: 86.30%\n", + "\n", + " [ TYPE 2: Data Category Labels (Text on axes/pie slices) ]\n", + " - Recall (Found true labels): 93.58%\n", + " - Precision (Valid preds): 99.64%\n", + " - F1 Score: 0.9652\n", + "\n", + " [ TYPE 3: Data Values ]\n", + " > 5% Error Threshold:\n", + " - Recall: 87.77% | Precision: 93.44% | F1: 0.9052\n", + " > 10% Error Threshold:\n", + " - Recall: 88.45% | Precision: 94.17% | F1: 0.9122\n", + "----------------------------------------------------------------------\n", + "\n", + "🟩 CHART TYPE: PIE (200 images)\n", + "\n", + " [ TYPE 1: Global Chart Text (Average Match %) ]\n", + " - Title Accuracy: 77.17%\n", + "\n", + " [ TYPE 2: Data Category Labels (Text on axes/pie slices) ]\n", + " - Recall (Found true labels): 86.84%\n", + " - Precision (Valid preds): 96.47%\n", + " - F1 Score: 0.9140\n", + "\n", + " [ TYPE 3: Data Values ]\n", + " > (Not evaluated: FigureQA dataset omits numeric values for pie slices)\n", + "----------------------------------------------------------------------\n", + "\n", + "🟩 CHART TYPE: DOT_LINE (200 images)\n", + "\n", + " [ TYPE 1: Global Chart Text (Average Match %) ]\n", + " - Title Accuracy: 100.00%\n", + " - X-Axis Label Accuracy: 88.02%\n", + " - Y-Axis Label Accuracy: 67.10%\n", + "\n", + " [ TYPE 2: Data Category Labels (Text on axes/pie slices) ]\n", + " - Recall (Found true labels): 71.17%\n", + " - Precision (Valid preds): 80.27%\n", + " - F1 Score: 0.7545\n", + "\n", + " [ TYPE 3: Data Values ]\n", + " > 5% Error Threshold:\n", + " - Recall: 63.48% | Precision: 71.60% | F1: 0.6730\n", + " > 10% Error Threshold:\n", + " - Recall: 66.43% | Precision: 74.92% | F1: 0.7042\n", + "----------------------------------------------------------------------\n", + "\n", + "Total Time: 708.52 seconds\n" + ] + } + ], + "source": [ + "import os\n", + "import json\n", + "import difflib\n", + "import time\n", + "from graphvision import GraphExtractor\n", + "\n", + "# --- CONFIGURATION ---\n", + "DATASET_DIR = \"./../FigureQA_Dataset/sample_train1\"\n", + "IMAGES_DIR = os.path.join(DATASET_DIR, \"png\")\n", + "ANNOTATIONS_PATH = os.path.join(DATASET_DIR, \"annotations.json\")\n", + "\n", + "# Thresholds\n", + "TEXT_MATCH_THRESHOLD = 0.80\n", + "\n", + "extractor = GraphExtractor() \n", + "\n", + "def text_similarity(str1, str2):\n", + " if not str1 and not str2: return 1.0\n", + " if not str1 or not str2: return 0.0\n", + " return difflib.SequenceMatcher(None, str(str1).lower().strip(), str(str2).lower().strip()).ratio()\n", + "\n", + "def calculate_value_error(pred_val, true_val):\n", + " try:\n", + " pred_val = float(pred_val)\n", + " true_val = float(true_val)\n", + " except (ValueError, TypeError):\n", + " return float('inf')\n", + "\n", + " if true_val == 0:\n", + " return 0.0 if pred_val == 0 else float('inf')\n", + " return abs(pred_val - true_val) / abs(true_val)\n", + "\n", + "def safe_div(n, d):\n", + " return n / d if d > 0 else 0.0\n", + "\n", + "def calc_prf1(tp, true_total, pred_total):\n", + " recall = safe_div(tp, true_total)\n", + " precision = safe_div(tp, pred_total)\n", + " f1 = safe_div(2 * (precision * recall), (precision + recall))\n", + " return precision, recall, f1\n", + "\n", + "def main():\n", + " print(f\"Loading annotations from {ANNOTATIONS_PATH}...\")\n", + " with open(ANNOTATIONS_PATH, 'r') as f:\n", + " ground_truth_list = json.load(f)\n", + " \n", + " TARGET_CHARTS = [\"vbar_categorical\", \"hbar_categorical\", \"pie\", \"dot_line\"]\n", + " \n", + " metrics = {\n", + " chart: {\n", + " \"type1\": {\"title\": [], \"x_label\": [], \"y_label\": []},\n", + " \"type2\": {\"true_total\": 0, \"pred_total\": 0, \"tp_cats\": 0},\n", + " \"type3\": {\"tp_5\": 0, \"tp_10\": 0}\n", + " } for chart in TARGET_CHARTS\n", + " }\n", + "\n", + " total_images = len(ground_truth_list)\n", + " processed_count = 0\n", + " skipped_count = 0\n", + " start_time = time.time()\n", + "\n", + " print(\"\\n🚀 Starting Evaluation...\")\n", + " print(\"-\" * 50)\n", + "\n", + " for idx, item in enumerate(ground_truth_list):\n", + " chart_type = item['type']\n", + " img_idx = item['image_index']\n", + " \n", + " if chart_type not in TARGET_CHARTS:\n", + " skipped_count += 1\n", + " continue\n", + "\n", + " img_path = os.path.join(IMAGES_DIR, f\"{img_idx}.png\")\n", + " if not os.path.exists(img_path):\n", + " continue\n", + "\n", + " # 1. Run Prediction\n", + " pred = {}\n", + " try:\n", + " pred_raw = extractor.extract(img_path)\n", + " if isinstance(pred_raw, str): pred = json.loads(pred_raw)\n", + " elif isinstance(pred_raw, dict): pred = pred_raw\n", + " except Exception as e:\n", + " print(f\" ⚠️ Error extracting {img_idx}.png: {e}\")\n", + " continue\n", + "\n", + " # ==========================================\n", + " # TYPE 1: Global Chart Text (Title, X/Y Labels)\n", + " # ==========================================\n", + " true_title = item.get('general_figure_info', {}).get('title', {}).get('text', \"\")\n", + " true_x = item.get('general_figure_info', {}).get('x_axis', {}).get('label', {}).get('text', \"\")\n", + " true_y = item.get('general_figure_info', {}).get('y_axis', {}).get('label', {}).get('text', \"\")\n", + "\n", + " metrics[chart_type][\"type1\"][\"title\"].append(text_similarity(pred.get(\"title\", \"\"), true_title))\n", + " \n", + " if chart_type != \"pie\":\n", + " metrics[chart_type][\"type1\"][\"x_label\"].append(text_similarity(pred.get(\"x_axis_label\", \"\"), true_x))\n", + " metrics[chart_type][\"type1\"][\"y_label\"].append(text_similarity(pred.get(\"y_axis_label\", \"\"), true_y))\n", + "\n", + " # ==========================================\n", + " # GROUND TRUTH PARSING (Handling FigureQA Lists & Pie Charts)\n", + " # ==========================================\n", + " true_data_points = []\n", + " for m in item['models']:\n", + " name = m.get('name', '')\n", + " x_vals = m.get('x', [])\n", + " y_vals = m.get('y', [])\n", + " \n", + " # Ensure they are lists\n", + " if not isinstance(x_vals, list): x_vals = [x_vals]\n", + " if not isinstance(y_vals, list): y_vals = [y_vals]\n", + " \n", + " max_len = max(len(x_vals), len(y_vals))\n", + " \n", + " # Allow pie charts with names but no coordinates to pass through for text evaluation\n", + " if chart_type == 'pie' and max_len == 0 and name:\n", + " true_data_points.append({\"candidate_labels\": [name], \"val\": 1.0}) \n", + " continue\n", + "\n", + " for i in range(max_len):\n", + " x_coord = x_vals[i] if i < len(x_vals) else None\n", + " y_coord = y_vals[i] if i < len(y_vals) else None\n", + " \n", + " # FigureQA might store the label in `name`, `x`, or `y`. \n", + " # We collect all strings to ensure we don't miss the true label.\n", + " candidates = [name]\n", + " if isinstance(x_coord, str): candidates.append(x_coord)\n", + " if isinstance(y_coord, str): candidates.append(y_coord)\n", + " candidates = [lbl for lbl in candidates if lbl]\n", + " if not candidates: candidates = [\"\"]\n", + " \n", + " # Determine the true numerical value\n", + " if chart_type == 'hbar_categorical':\n", + " true_val = x_coord if isinstance(x_coord, (int, float)) else y_coord\n", + " else:\n", + " true_val = y_coord if isinstance(y_coord, (int, float)) else x_coord\n", + " \n", + " true_data_points.append({\n", + " \"candidate_labels\": candidates,\n", + " \"val\": true_val if true_val is not None else 1.0\n", + " })\n", + "\n", + " # ==========================================\n", + " # PREDICTION PARSING (Handling Your JSON Variations)\n", + " # ==========================================\n", + " pred_data = pred.get('data', [])\n", + " standard_preds = []\n", + " \n", + " if isinstance(pred_data, dict):\n", + " # Handles Pie Charts: {\"Math\": 30.34}\n", + " for k, v in pred_data.items():\n", + " standard_preds.append({\"label\": str(k), \"val\": float(v) if isinstance(v, (int, float)) else 0.0})\n", + " \n", + " elif isinstance(pred_data, list):\n", + " # Handles Bar and Line Charts\n", + " for pt in pred_data:\n", + " if not isinstance(pt, dict): continue\n", + " # Look for 'category' (bar) or 'class' (line)\n", + " label = pt.get(\"category\") or pt.get(\"class\") or pt.get(\"label\") or \"\"\n", + " \n", + " if chart_type == \"hbar_categorical\":\n", + " val = pt.get(\"value\") or pt.get(\"x\") or 0.0\n", + " else:\n", + " val = pt.get(\"value\") or pt.get(\"y\") or 0.0\n", + " \n", + " standard_preds.append({\"label\": str(label), \"val\": val})\n", + "\n", + " # ==========================================\n", + " # SCORING TYPE 2 & 3\n", + " # ==========================================\n", + " metrics[chart_type][\"type2\"][\"true_total\"] += len(true_data_points)\n", + " metrics[chart_type][\"type2\"][\"pred_total\"] += len(standard_preds)\n", + " \n", + " available_preds = list(standard_preds)\n", + " \n", + " for true_pt in true_data_points:\n", + " best_match_idx = -1\n", + " min_error_for_best_score = float('inf')\n", + " \n", + " for i, p_pt in enumerate(available_preds):\n", + " # Check prediction against all possible ground truth labels\n", + " max_text_score = max([text_similarity(t_label, p_pt[\"label\"]) for t_label in true_pt[\"candidate_labels\"]])\n", + " \n", + " if max_text_score >= TEXT_MATCH_THRESHOLD:\n", + " error = calculate_value_error(p_pt[\"val\"], true_pt[\"val\"])\n", + " \n", + " # If multiple predictions share this label (like points on a line graph), \n", + " # we select the one closest in mathematical value to the ground truth\n", + " if error < min_error_for_best_score:\n", + " min_error_for_best_score = error\n", + " best_match_idx = i\n", + " \n", + " # If a match was found\n", + " if best_match_idx != -1:\n", + " metrics[chart_type][\"type2\"][\"tp_cats\"] += 1\n", + " \n", + " # We skip value accuracy scoring for Pie charts since ground truth is missing\n", + " if chart_type != 'pie':\n", + " if min_error_for_best_score <= 0.05:\n", + " metrics[chart_type][\"type3\"][\"tp_5\"] += 1\n", + " metrics[chart_type][\"type3\"][\"tp_10\"] += 1 \n", + " elif min_error_for_best_score <= 0.10:\n", + " metrics[chart_type][\"type3\"][\"tp_10\"] += 1\n", + " \n", + " available_preds.pop(best_match_idx)\n", + "\n", + " processed_count += 1\n", + " if processed_count % 50 == 0:\n", + " print(f\"🔄 Processed {processed_count} images...\")\n", + "\n", + " # --- PRINT FINAL REPORT ---\n", + " print(\"\\n\" + \"=\"*70)\n", + " print(\"📊 MULTI-LEVEL ACCURACY REPORT\")\n", + " print(\"=\"*70)\n", + " print(f\"Total Images in JSON: {total_images}\")\n", + " print(f\"Images Processed: {processed_count}\")\n", + " print(f\"Images Skipped: {skipped_count} (Filtered out unneeded chart types)\")\n", + " \n", + " for c_type, m in metrics.items():\n", + " if len(m[\"type1\"][\"title\"]) == 0: continue\n", + " \n", + " print(f\"\\n🟩 CHART TYPE: {c_type.upper()} ({len(m['type1']['title'])} images)\")\n", + " \n", + " print(\"\\n [ TYPE 1: Global Chart Text (Average Match %) ]\")\n", + " print(f\" - Title Accuracy: {safe_div(sum(m['type1']['title']), len(m['type1']['title'])) * 100:.2f}%\")\n", + " if c_type != \"pie\":\n", + " print(f\" - X-Axis Label Accuracy: {safe_div(sum(m['type1']['x_label']), len(m['type1']['x_label'])) * 100:.2f}%\")\n", + " print(f\" - Y-Axis Label Accuracy: {safe_div(sum(m['type1']['y_label']), len(m['type1']['y_label'])) * 100:.2f}%\")\n", + " \n", + " p2, r2, f2 = calc_prf1(m['type2']['tp_cats'], m['type2']['true_total'], m['type2']['pred_total'])\n", + " print(\"\\n [ TYPE 2: Data Category Labels (Text on axes/pie slices) ]\")\n", + " print(f\" - Recall (Found true labels): {r2*100:.2f}%\")\n", + " print(f\" - Precision (Valid preds): {p2*100:.2f}%\")\n", + " print(f\" - F1 Score: {f2:.4f}\")\n", + " \n", + " if c_type == 'pie':\n", + " print(\"\\n [ TYPE 3: Data Values ]\")\n", + " print(\" > (Not evaluated: FigureQA dataset omits numeric values for pie slices)\")\n", + " else:\n", + " p3_5, r3_5, f3_5 = calc_prf1(m['type3']['tp_5'], m['type2']['true_total'], m['type2']['pred_total'])\n", + " p3_10, r3_10, f3_10 = calc_prf1(m['type3']['tp_10'], m['type2']['true_total'], m['type2']['pred_total'])\n", + " \n", + " print(\"\\n [ TYPE 3: Data Values ]\")\n", + " print(f\" > 5% Error Threshold:\")\n", + " print(f\" - Recall: {r3_5*100:.2f}% | Precision: {p3_5*100:.2f}% | F1: {f3_5:.4f}\")\n", + " print(f\" > 10% Error Threshold:\")\n", + " print(f\" - Recall: {r3_10*100:.2f}% | Precision: {p3_10*100:.2f}% | F1: {f3_10:.4f}\")\n", + " print(\"-\" * 70)\n", + "\n", + " print(f\"\\nTotal Time: {time.time() - start_time:.2f} seconds\")\n", + "main()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34e0f67d-080e-4356-bbb1-d5fc2da13a81", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "caecfd13-2dcd-4b6d-8bc1-fde27fca432f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b302f562-07ac-4fd4-ab08-0e543be31a44", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tfenv", + "language": "python", + "name": "tfenv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/Training.ipynb b/notebooks/Training.ipynb new file mode 100644 index 0000000..1d301d9 --- /dev/null +++ b/notebooks/Training.ipynb @@ -0,0 +1,12927 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 329 + }, + "id": "CdEBywfwJyEX", + "outputId": "46419848-e54b-4de1-c515-bdc7abd4101b" + }, + "outputs": [ + { + "output_type": "error", + "ename": "ValueError", + "evalue": "mount failed", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_1581/1408506528.py\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mgoogle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolab\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mdrive\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mdrive\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/content/drive'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/colab/drive.py\u001b[0m in \u001b[0;36mmount\u001b[0;34m(mountpoint, force_remount, timeout_ms, readonly)\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmountpoint\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mforce_remount\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout_ms\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m120000\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreadonly\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 96\u001b[0m \u001b[0;34m\"\"\"Mount your Google Drive at the specified mountpoint path.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 97\u001b[0;31m return _mount(\n\u001b[0m\u001b[1;32m 98\u001b[0m \u001b[0mmountpoint\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[0mforce_remount\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mforce_remount\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.12/dist-packages/google/colab/drive.py\u001b[0m in \u001b[0;36m_mount\u001b[0;34m(mountpoint, force_remount, timeout_ms, ephemeral, readonly)\u001b[0m\n\u001b[1;32m 270\u001b[0m \u001b[0;34m'https://research.google.com/colaboratory/faq.html#drive-timeout'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 271\u001b[0m )\n\u001b[0;32m--> 272\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'mount failed'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mextra_reason\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 273\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mcase\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 274\u001b[0m \u001b[0;31m# Terminate the DriveFS binary before killing bash.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: mount failed" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "from google.colab import drive\n", + "\n", + "# 1. Mount Drive if you haven't already\n", + "drive.mount('/content/drive')\n", + "\n", + "# 2. Create a specific folder in your Drive for this project\n", + "drive_path = \"/content/drive/MyDrive/Spectra_YOLO_Project\"\n", + "os.makedirs(drive_path, exist_ok=True)\n", + "\n", + "# 3. Create a SYMLINK (The Magic Step)\n", + "# This tells Colab: \"When you think you're saving to /content/runs, actually save to my Drive\"\n", + "!rm -rf /content/runs\n", + "!ln -s /content/drive/MyDrive/Spectra_YOLO_Project /content/runs\n", + "\n", + "print(\"✅ Shortcut created! Your progress will now save to Google Drive in real-time.\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xDMsk76SNi1W", + "outputId": "e367521b-e8b9-4b61-84fb-89acebe067e6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n", + "✅ Shortcut created! Your progress will now save to Google Drive in real-time.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Create a local folder on the Colab disk (much faster than reading from Drive directly)\n", + "!mkdir -p datasets\n", + "!unzip -q /content/drive/MyDrive/Spectra/yolo_dataset.zip -d datasets/" + ], + "metadata": { + "id": "2mQiJlLfJ_Sp" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from ultralytics import YOLO\n", + "\n", + "# Load model\n", + "model = YOLO(\"yolo11n.pt\")\n", + "\n", + "# Train on T4 GPU\n", + "# We can use a larger imgsz (640) and batch (32) because T4 has 16GB VRAM\n", + "model.train(\n", + " data=\"/content/drive/MyDrive/Spectra/charts.yaml\",\n", + " epochs=10,\n", + " imgsz=640,\n", + " batch=32,\n", + " device=0, # 0 is the index for the T4 GPU\n", + " amp=True\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p1JDMfBRKECj", + "outputId": "2b32a420-7916-4b01-cfee-ff2c7b0efe99" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[1;30;43mStreaming output truncated to the last 5000 lines.\u001b[0m\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14263.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.015492 -0.026336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14268.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0863 1.0932 1.1128 1.1277 1.1266 1.0863]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14269.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2485]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14272.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1328 1.0808 1.0557 1.0826 1.1096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14275.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1009]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14276.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0299 1.023 1.0173 1.0104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14286.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0607 1.0626 1.0588 1.0607]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14292.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041133 -0.061243 -0.056673 -0.09415 -0.067642 -0.041133 -0.016453 -0.067642]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14294.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0811 1.072 1.211]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14295.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0246]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14296.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.039792 -0.18685 -0.027682 -0.16263 -0.079585 -0.1263 -0.12543 -0.12111 -0.15009 -0.40744 -0.031142 -0.16955 -0.28157 -0.67041 -0.18728 -0.48183 -0.015571 -1.1834 -2.474 -0.048443 -0.018166 -0.08045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14299.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3309 1.2677 1.2677 1.2919 1.1739 1.1739 1.1739 1.1739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14303.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0649 1.1344]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0145 1.0145 1.0118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14311.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0249 1.0431 1.0555 1.0785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14314.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0506 1.0697 1.0725 1.1078]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14316.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.023673 -0.028571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14328.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11146 -0.051805 -0.098116 -0.10753]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14335.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0889]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14340.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0842 1.097 1.0822 1.0495 1.1713 1.1713 1.1713 1.1713 1.0307 1.0277 1.0307 1.0149]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0616]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14348.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1182 1.2304 1.3595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14352.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2244]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14354.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.05988]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14355.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14356.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.109 1.1079 1.1068 1.1068]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14358.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0172]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14362.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0807 1.0718 1.0204 1.0293]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14364.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2599 1.2632 1.2697 1.2785 1.2708 1.2752 1.08 1.0877 1.08 1.0724 1.0175 1.0844 1.0724 1.0647 1.0647 1.0603 1.0603]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14373.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10015 -0.03775 -0.087827 -0.11864 -0.10786]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1697 1.1155 1.1155 1.1697 1.1443 1.1697 1.1732 1.1824 1.1882 1.1882]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14381.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2859 1.1328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14382.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2377 1.1533]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14383.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0285 1.0596 1.2655 1.2409 1.2383 1.2539]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14387.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0686 1.0596]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14388.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0966 1.0412 1.1016 1.1026 1.1167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14391.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0188 1.018 1.0196 1.018 1.0171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14392.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1533 1.0361 1.0624 1.0931 1.1544 1.0208 1.0142 1.0832 1.1314 1.0153 1.0668 1.0252 1.0657]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14393.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0443 1.3514]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14395.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0354 1.1034 1.1091 1.085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14398.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011461 -0.092646 -0.11079 -0.099331]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14399.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1972]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14404.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0373]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2066 1.2454 1.2511 1.0936 1.0696 1.0776]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14421.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0121 1.0132 1.0121 1.011]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14426.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0814]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14429.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3701]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14438.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0156 1.0156 1.0156 1.0156 1.3264 1.3264 1.3264 1.3264 1.0455 1.0455 1.0156 1.0156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14448.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1546 1.1546 1.1546 1.1546 1.1546 1.1546 1.1546]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14450.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14452.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.314 1.3073 1.3086 1.3086 1.3113 1.3167 1.0148 1.027 1.128 1.1739 1.1806 1.186 1.3208 1.3234 1.3302 1.3356 1.3423 1.3504 1.4973 1.5 1.504 1.5067 1.5094 1.5108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14453.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.99007 -2.2331 -0.99081 -2.2346 -0.99007 -2.2331 -0.17426 -0.052941 -0.13529]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14461.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0586]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14466.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1009 1.1094 1.1321 1.3381 1.3878 1.429 1.2543 1.2685 1.3253 1.3793 1.3125 1.3224]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14467.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.20971 -0.54752 -0.058884 -0.029959 -0.29029 -0.70868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14469.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1854]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14471.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3966 1.365 1.365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14478.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4144 1.4569 1.5045 1.5573]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14479.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14492.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0324]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14501.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14502.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.107 1.0479 1.0691 1.1093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14512.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.25203 -0.13821 -0.65312 -0.22764 -0.028455]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14513.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0985 1.054 1.3792 1.2753]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14523.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.015274 -0.18508]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14525.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2619.7 5239.3 2450.2 4900.4 2952.2 5904.3 3895.8 7791.4 3189.4 6378.6 2859.5 5718.8 2.1735 4.2261 6.8811 13.641 15.502 30.884 45.832 91.544 38.386 76.652 192.39 384.66 198.24 396.35\n", + " 287.94 575.76 479.68 959.25 510.6 1021.1 381.06 762 317.99 635.86 512.31 1024.5 819.49 1638.8 1111.7 2223.2 727.56 1455 635.16 1270.2]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14534.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.022422 -0.023318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14540.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.043159]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14543.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2875]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14546.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0992 1.0647 1.0511 1.0365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14557.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10009 -0.31618 -0.19738 -0.51076 -0.04116 -0.033676 -0.052385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14559.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1723 1.1083 1.1181]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14565.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.272 1.272 1.2755 1.2766 1.2824]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14570.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.063067 -0.34211 -0.024501 -0.076225 -0.13612 -0.085753 -0.38748 -0.10526 -0.19873 -0.61343 -0.072595 -0.18058 -0.019056]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14575.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1947 1.2489 1.2257 1.1394 1.0653 1.0896 1.0675 1.1095 1.0653 1.1969 1.1538 1.1781 1.1438 1.1925]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14576.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1496 1.1851 1.1485 1.1715]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14581.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.01304 -0.01793]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14582.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.0106]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14587.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14590.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1198]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14591.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0384 1.0625 1.0691 1.0998]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14595.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 7502.5 15005 9239.8 18479 16269 32538 7.1058 14.1 10.502 20.892 12.283 24.455 218.01 435.91 203.86 407.62 203.94 407.76 1.2]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14605.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.101 1.1332 1.1079 1.0287 1.0815 1.0413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14610.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1159]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14611.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.0547 -2.3147 -0.22328 -0.016379 -0.05 -0.088793 -0.16465 -0.53448 -0.024138 -0.25345 -0.068966 -0.21509 -0.63534 -0.047414 -0.1181 -0.34871 -0.90259 -0.012931]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14614.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0254 1.0134]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14621.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.037736 -0.056604 -0.039377 -0.21657 -0.051682 -0.086136 -0.046349 -0.23052 -0.061526 -0.037736 -0.054553 -0.24692 -0.014766 -0.061526 -0.083675 -0.30517]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14627.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10837 -0.31554 -0.12351 -0.34582 -0.082869 -0.10996]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14628.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0373 1.0483 1.0362 1.022 1.045 1.0198]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14629.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0765]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14635.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0362 1.0624 1.0624 1.0302 1.0583 1.0644 1.0201 1.0503 1.0453 1.0101 1.0412 1.0443]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14645.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14650.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.47311 -1.127 -0.47311 -1.127 -0.6742 -1.5292 -1.4041 -2.9891 -0.77864 -1.7381 -9092.8 -18186]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14651.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.048618]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14662.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.067977 -0.10729]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14664.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.049261 -0.066502 -0.028736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14665.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1047]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14668.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0153]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14676.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1602 1.2509 1.0671]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14677.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0446 1.0595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14680.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.015702 -0.015702]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14681.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2997 1.0422 1.0409 1.3174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14682.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1209]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14693.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.020979 -0.13831 -0.012432 -0.12121 -0.13092 -0.3582 -0.11228 -0.3209 -0.20086 -0.49806 -0.056721 -0.20979 -0.15928 -0.41492 -0.16628 -0.4289 -0.18376 -0.46387 -0.21445 -0.52525]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14695.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0768 1.0768 1.0384 1.0384]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14700.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0386 1.0493 1.0628 1.0242 1.0531 1.0589 1.0638 1.0705]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14703.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3753 1.3686 1.3537 1.3388]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14704.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0517]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14711.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.073338]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14712.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0664 1.0106]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14713.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0691 1.085 1.0579]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14720.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14727.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0304 1.2409]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14733.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0564 1.0624]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14736.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.27435 -0.64935 -0.17735 -0.45536 -0.27192 -0.64448 -0.31575 -0.73214 -0.25568 -0.61201 -0.34294 -0.78653 -0.012987 -0.025974]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14746.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5316 1.5498 1.547 1.5456 1.5035 1.5035 1.5035 1.5035 1.5035 1.5035 1.5035 1.5035 1.7532 1.7532 1.7532 1.7532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14748.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.022798 -0.17409]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14751.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018237 -0.037487]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14754.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1834]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0507 1.0408 1.0375 1.0915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14769.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.026549 -0.55221 -1.2142 -0.75044 -1.6106 -0.044248 -0.028761 -0.16726 -0.12434 -0.35841 -0.023009 -0.043363]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14774.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2171 1.3185 1.3378 1.275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14775.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0199]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14777.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0936 1.0432 1.2922 1.2695 1.3045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3517 1.1496 1.3688]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14782.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4536 1.0644 1.1456 1.3531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14783.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1713]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14785.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.372 -0.043 -0.0535 -0.463 -0.135]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14787.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1025 1.1025 1.2859 1.1025 1.1025 1.1025 1.1025 1.2859 1.1025 1.1025 1.1025 1.1025 1.2859 1.1025 1.1025 1.1025 1.1025 1.2859 1.1025 1.1025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14793.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0582]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14805.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2545 1.2928 1.266 1.2928]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0236 1.0123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14811.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0587]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14812.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14814.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.0162]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14824.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.062]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14836.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.02237 -0.025684 -0.026512 -0.14706 -0.5609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14841.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.047761 -0.053731 -0.0199 -0.046766]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14846.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1888 1.1878]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14849.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.057471 -0.083595 -0.061651]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14861.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1232 1.0922 1.073 1.0575]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14862.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0126]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14872.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.183 1.1227]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0829]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14892.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0783 1.0745 1.0821 1.0811]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14893.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012573 -0.096712]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14896.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018817 -0.076165 -0.34229 -0.018817 -0.23208 -0.65412 -0.017025 -0.34453 -0.87903 -0.020609 -0.023297 -0.23656]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14899.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0231 1.0267 1.0329]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14903.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.072368 -0.14693 -0.14364 -0.074561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1845 1.0512]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14907.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262 1.0675 1.1777 1.2906]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14911.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0118 1.0147 1.0206 1.0284]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14920.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1712]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14921.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.017766 -0.018613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14931.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2022]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14939.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14942.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.096889 -0.304 -0.20844 -0.52711 -0.012444 -0.013333 -0.037333 -0.10578 -0.017778 -0.016 -0.037333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14943.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1188 1.1389 1.0668 1.1198]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14950.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14951.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1205 1.1246 1.1277 1.1226 1.2268 1.2268 1.2543 1.2594]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14953.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1856 1.2153 1.2255 1.2244 1.1856 1.2096 1.1925 1.1663 1.1674 1.1822 1.1697 1.1708 1.2153 1.1492 1.1412 1.1424 1.139 1.1663 1.0467 1.0467 1.0729 1.0729 1.0683 1.0672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14954.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.015291 -0.18858 -0.022426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14955.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.088139 -0.047334 -0.35364 -0.01741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14962.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.040123 -0.020576 -0.022634 -0.010288 -0.034979]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14964.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0684 1.2821 1.2062]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14967.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.27803 -0.20359 -0.24215 -0.77309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14984.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.065552 -0.24322]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14986.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.12]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14987.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0297]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14989.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0351]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14992.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0228 1.0774 1.0695 1.0934]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/14993.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0609 1.0699 1.186 1.0879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15000.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0706]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15001.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0689 1.0918 1.1486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15012.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0873 1.1182 1.1337 1.137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15016.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 13.645 27.189 3.3201 6.5394 1.8867 3.6726 3.4139 6.7271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15017.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15021.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15025.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1014]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15037.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10735 -0.3183 -0.27485 -0.6533 -0.091061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15038.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15039.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1571 1.0251 1.0478 1.136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15048.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0669 1.1388 1.0793 1.0434]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15049.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.1786 -4.6215 -1.1264 -2.5172 -5.9167 -12.098 -6.0427 -12.35 -1.3391 -2.9425]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15050.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8109 3.507 1.0167 1.9184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15051.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1963]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15052.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15054.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0356]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15056.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0613 1.9949 1.3337 1.2709 1.0741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15061.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1283 1.2933 1.3302]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15063.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0125 1.5983 1.4529]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15073.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0675 1.0675 1.0675]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15075.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15076.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0201 1.4368]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15078.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1313]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15084.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0707 1.0543 1.0223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15086.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1305 1.1635 1.2047 1.239 1.2747 1.3104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15088.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0372 1.046 1.0361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15089.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15094.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0416 1.0478]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.176]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15105.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.152]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15109.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1584 1.1011 1.0461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15112.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1519 1.2902 1.1867 1.1755 1.1496 1.0292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15115.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1252 1.1239 1.1239 1.1227 1.1227]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15117.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1551 1.4164 1.0796 1.0281]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15122.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0703 1.0814]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15126.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2301 1.2301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15127.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0756 1.0342 1.0218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15129.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1038 1.1483 1.2172 1.1515]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1445 1.1635 1.1265 1.0437]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15134.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0807 1.0705 1.1841 1.325 1.1852 1.292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15135.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0745]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15136.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0315]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15139.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15140.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.08898 -0.27918]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15141.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0242 1.0526 1.08 1.1095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15143.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.046778 -0.22245 -0.11642]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15151.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0988]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15153.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.7122 -6.1143 -0.67247 -5.821 -12.332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.226 1.6753 1.2504]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15162.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15164.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.3949 -3.0054 -24.712 -49.639 -6.875 -13.966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15166.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0359 1.0666 1.0772]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15172.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0201]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15173.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15175.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1679 1.1767 1.157 1.1603]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15177.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4813]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15181.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.084007 -0.27942]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15183.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.020219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15187.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1227]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15193.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.7538 -1.6255]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15197.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0312 1.0451]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15203.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0968]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15206.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0733]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15207.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.0611 -4.2233 -0.38712 -0.87531 -1.4654 -3.0318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15208.png: ignoring corrupt image/label: negative class labels or coordinate [-8.8483e+06 -1.7697e+07 -47.269 -94.853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15210.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15215.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0895]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15216.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0716]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15223.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.01035]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7642 2.4984 4.8137 4.9448 9.7065]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15236.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.078 1.0223 1.029 1.0424]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15242.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0317 1.0559]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15243.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2716]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15246.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0734]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15250.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3028]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15253.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0762 1.0722 1.0722 1.0722 1.0762 1.0722]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15260.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0717]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15262.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0596]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15264.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1793 1.1739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15269.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15271.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0902 1.1216 1.1353 1.0559 1.0382 1.1059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15275.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0149]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15279.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.039036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15283.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0972 1.2625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15285.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2255]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15287.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2138 1.0976]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2946 1.3527 1.3598 1.1756 1.1785 1.2096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15293.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0146 1.0146 1.0146 1.0146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15297.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0572 1.0514 1.0368 1.0194 1.0116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15301.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1715 1.3417]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15304.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2258]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.027 1.2892]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15310.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1395]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15313.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4235 1.4248 1.4248 1.1817]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15315.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.078313 -0.27155 -0.11909 -0.35311 -0.10612 -0.32715 -0.081094 -0.27711]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15318.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15323.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1464]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15328.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138 1.0502]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15337.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1571 1.1482 1.1561 1.1561 1.1571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15343.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1593]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15352.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1204 1.2062 1.1761]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15354.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0227 1.1196 1.2267 1.3438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15364.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2841 1.1534 1.2466 1.2477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15365.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0591 1.0519 1.0436 1.0363 1.028 1.0207]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15370.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0131 1.0219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15373.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1932 11.338 22.536 18.707 37.273 12.991 25.842 18.089 36.038 19.329 38.519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15376.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2288 1.2232 1.1907 1.2274]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.101]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15384.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.081]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15390.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2325 1.2325 1.2325 1.2325 1.2325 1.1792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15391.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.042208 -0.19944 -0.021336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15399.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.3474 -2.8098 -0.75093 -1.6169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15400.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1935 1.2573 1.2438 1.2774]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15404.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2419 1.2174 1.1839 1.1472 1.1148 1.0736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1578]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15407.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15410.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1334 1.1376 1.1334 1.0893 1.0767 1.0798]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0392]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15412.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203 1.0947]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15421.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.1002 -4.3093 -1.1252 -2.3594 -0.18322 -0.47539]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15423.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.146 1.146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15425.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0533 1.0533 1.0533 1.0533]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15430.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15432.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1687]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15434.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.014 1.0168 1.0187 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15436.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0805]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15440.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15441.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2624]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1075]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15448.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0153 1.0728 1.0613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0352]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15462.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0842 1.0414 1.0709 1.1285]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15466.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2315 1.2336 1.0581]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15470.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12831 -0.38289 -0.093686 -0.013238 -0.15275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15481.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15499.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2038 1.2038 1.3174 1.2421 1.2791 1.2038]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15511.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15513.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1002]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15517.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 149.11 297.6 38.271 75.931 244.5 488.38 1.2396]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15519.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.8927 9.6667 2.4555 4.7921 1.5891 3.0594 3.3372 6.5556 1.6691 3.2193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15520.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1126 1.1572]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15525.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15531.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1792 1.634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0983]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15535.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1285]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15538.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15553.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15556.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2346]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1788]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15572.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15574.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15578.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292 1.0282 1.0379]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15581.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15585.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15614.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15615.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0376 1.0859 1.0387 1.015]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0241 1.0809]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15621.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4462 1.4717 1.4334 1.2224]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15622.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0195]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15624.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1287 1.1611 1.1611]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15625.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.085 1.0307]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15629.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0929 1.0826 1.1732 1.1365 1.1273 1.1594]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15635.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15636.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2855 2.4686 2.1698 4.2372 1.1525 2.2025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15641.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.2798]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15644.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.147 1.125 1.076 1.096 1.124]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15649.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1558]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15654.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.272 1.2734 1.283 1.2706 1.2692 1.2761]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15656.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15657.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214 1.108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15659.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0249 1.0411]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15660.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4479 1.4521 1.4438 1.4411]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15663.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15666.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0661]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15667.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1389 1.0179 1.0158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15676.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.050915 -0.035402 -0.27128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15685.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1289 1.0767 1.1133 1.1411]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15689.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3644 1.3671 1.3671 1.3685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15698.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2382]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15706.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1183]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15708.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1767 1.1652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15710.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1005]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15711.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2988 1.0168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15716.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2102]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15717.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0399 1.1197 1.0875]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15720.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0206 1.0172 1.0378 1.0458]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15721.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3677 1.1615 1.1569 1.1477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15723.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.2484 -4.5949 -0.43987 -0.97785 -0.045095 -0.18829 -0.013449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15724.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0124]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15728.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0381 1.0901 1.1443 1.2009 1.2806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15729.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15730.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0675 1.0675 1.0675]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15733.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0312 1.1158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15735.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0115 1.0115 1.0115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15736.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15739.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0265 1.9289 1.2673 1.3534]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15746.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0465 1.3297]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15772.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.077189 -0.29724 -0.13825]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15775.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.028203 -0.15633 -0.028203 -0.15633]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15777.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15778.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15785.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2329 1.1096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15788.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0274 1.2577 1.2029 1.2434]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15792.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0126 1.0485]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15793.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203 1.0203 1.0284]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15796.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 7.0278 13.918 9.5774 19.017 3.5434 6.9488]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15801.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.098832 -0.30907 -0.1177 -0.34681 -0.061995]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15804.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3689]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15818.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1004]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15822.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0471]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15826.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15827.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.0627 -2.2257 -0.2593 -0.61893 -0.10437 -0.47209 -1.0445]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0565]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15834.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1001]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15837.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1584 1.3067 1.2438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15841.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3276 1.3276 1.3276 1.3276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15844.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0404]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15849.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1442]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15853.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15854.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4715]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15859.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15865.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0101]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15866.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0979]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15872.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.027]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15873.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0164]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15879.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1691]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15883.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0173]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15889.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0748]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.038 1.2334 1.4274]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15892.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3739 1.2599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15894.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0572]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15897.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15912.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0669 1.0405 1.0618]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15914.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0121 1.0121 1.0173]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15924.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2546 1.2282 1.1147 1.0206]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15936.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1578 1.0955 1.0995 1.0935]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15937.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1353 1.2069 1.3191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15939.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0172]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15941.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.1759 -0.10982 -0.41011]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15946.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15949.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0679 1.0316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15951.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0439]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15952.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15955.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15960.png: ignoring corrupt image/label: negative class labels or coordinate [ -4.6845 -9.5459]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15961.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0529]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15968.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15974.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0362]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15975.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15976.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2262 1.2262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15980.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0239 1.0149]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15988.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0636]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15989.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.173]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15990.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11277 -0.0625 -0.29348 -0.074049 -0.31658]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15991.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1472]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15997.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1954 1.2762]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/15998.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1254]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0955 1.0325]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16008.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16010.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16022.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1237]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16024.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0845 1.0729 1.0625 1.0544 1.0451 1.0359]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16025.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0424]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16029.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018098 -0.14057 -0.066498]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16037.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16041.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0854 1.0374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16046.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0525 1.0525]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16052.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.015 1.014 1.015 1.0401 1.0531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16055.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3021 1.3021 1.3043 1.3043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16064.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1158 1.1113 1.1038 1.1143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16069.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16076.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0458]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16083.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0693 1.2056 1.0584 1.1484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16085.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.023007]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16087.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1684 1.0263 1.0848 1.0664 1.1615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16098.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.14815 -0.39401 -0.032703 -0.16312 -0.24153 -0.58077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1639 1.2163 1.2129 1.2129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16104.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041791 -0.31343 -0.96318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16106.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0394 1.0178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16107.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2859 1.1378 1.6606 1.111 2.0809]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16115.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0432]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16119.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0467]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16122.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0633]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16126.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0238 1.1037]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16128.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0683]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1187 1.1465 1.1744 1.1806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16144.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1029]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16149.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5339]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16152.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0682 1.116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16157.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4551 1.3034 1.0506 1.0885 1.1854]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1491 1.1435 1.1222 1.1413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16160.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.61624 -1.3347 -0.2296 -0.56142]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16162.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2577]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16166.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2335 1.2255 1.2403 1.2403 1.2403]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16169.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0344]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16173.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8709 1.8742 1.0456 1.9566 1.1106 2.0868 1.2343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16176.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1445 1.0996 1.1178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16179.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1171 1.1171 1.1171 1.1751]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16183.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12004 -0.010397 -0.138 -0.020321 -0.15785 -0.034026 -0.18526]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16186.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16187.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0264]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16189.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16190.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0401 1.0401 1.0401 1.0401 1.0401 1.0401]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16191.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0803 1.0823 1.0842 1.0852 1.0862]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16192.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.111]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16200.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16204.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.3147 -2.8977 -0.059099 -0.38649 -0.016886]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16212.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.153]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16215.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1102 1.2107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0809 1.3685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0183]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16227.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1783]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16228.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3062 1.1431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16229.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0428]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0635 1.0894]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16234.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0372]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16236.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.98182 -2.2727 -9.4008 -19.111]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16239.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16245.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0994 1.1451]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16247.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0576 1.0536 1.0536 1.0335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16250.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1217]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16256.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.017045 -0.29773]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16260.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2332 1.2332 1.2332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16263.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.18215 -0.30523 -0.9477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16285.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1247]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16294.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.071732 -0.24873 -0.075976 -0.25722]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16298.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0229 1.0229 1.0431 1.0532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16299.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0447]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16300.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2705 1.2761 1.2773 1.2739 1.2807 1.275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16306.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1073 1.0739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.031]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16310.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16312.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2624]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16313.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0899 1.0979 1.0609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16315.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1273]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16318.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1658]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16324.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16326.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.403 1.3904 1.3413 1.335 1.2859 1.2355]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16330.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.084365 -0.12345 -0.34288 -0.27477 -0.64551 -0.25426 -0.60449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16331.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.69591 -1.4954]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3053 1.3133 1.3201 1.3269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16340.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027933 -0.40596 -1.1117 -0.11173 -0.52328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16341.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1973 1.201 1.1005 1.1042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0275 1.0674]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16343.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1987 1.0795]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16358.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1075]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16369.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2371]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16371.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1565]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16373.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0845 1.1059 1.1008 1.0743 1.0815]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16375.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2384]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.145 1.0444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16382.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1436 1.1436 1.1436 1.1436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16384.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0926 1.0522]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16393.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.32514 -0.83554 -0.43762 -1.0605 -1.405 -2.9953]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16397.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0101 1.2011]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16405.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1985 1.1985 1.1985 1.1985]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0135 1.0683 1.0797 1.0383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16409.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0639 1.0897 1.1671]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16410.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1985]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16418.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16421.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2575]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16422.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.103 1.3251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16433.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1251 1.1719]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16440.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1332 1.1269 1.1121 1.0497 1.0592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16445.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2 1.2 1.2616]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16456.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0574 1.0574]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16462.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0741 1.1111 1.1493 1.1887 1.2292 1.272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16464.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0143 1.0133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1297]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1227 1.0966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16470.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4154 1.3119 1.3472 1.3699 1.3245 1.2816]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16472.png: ignoring corrupt image/label: negative class labels or coordinate [-8.9137e+05 -1.7827e+06 -47.469 -95.284 -1.3868e+05 -2.7736e+05]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16477.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16481.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2534 1.2534 1.2534 1.2534 1.2534]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16482.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0686 1.1851]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16487.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1147]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0122 1.0591 1.1161 1.1792 1.1599 1.1945]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0568]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16510.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0544 1.0729 1.0229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16517.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1494]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16518.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0559 1.1315]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16523.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0282 1.0135 1.1172 1.168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16524.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0474]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16527.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1169 1.0569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16529.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.32046 -0.73965]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16532.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.111 1.1258 1.0663 1.1258 1.0663]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16555.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0469 1.0184 1.0827 1.1112 1.0327]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2638 1.2638 1.0951]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3545 1.3215 1.2897 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16568.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0268]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16569.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16571.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16579.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0495 1.0527 1.2002]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16580.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0892]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16584.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0414]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16586.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.0322 1.1063 1.1147]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16590.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1131 1.039 1.1141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16593.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1298]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16615.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1527]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0323]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16624.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2905]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16628.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0627]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16630.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2785 1.3061 1.328 1.3452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16636.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11487 -0.016028 -0.28317]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16638.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0912 1.0764]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16645.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1055 1.4694]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16652.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0388]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.103 1.0601]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16659.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0377 1.0205]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16660.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4786 1.4461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16665.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.1674 -2.5069 -1.4028 -2.9778 -1.7375 -3.6472 -1.0125 -2.1972]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16671.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16674.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16681.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1019 1.1325 1.1461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16683.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1558]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16686.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16689.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.02 1.1551 1.2099]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16690.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0252 1.0602 1.1915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16697.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509 1.1824 1.1811 1.1687 1.1849]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16704.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16707.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2691 1.2668 1.2566 1.2634 1.2543]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16710.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1005]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16717.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2923 1.1954 1.1185 1.3785 1.3692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16720.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3733 1.4097]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16721.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1063 1.0825 1.0406]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16723.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16730.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1721 1.1721 1.1721 1.0259 1.0259]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16731.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16733.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.89396 -1.8864 -0.7641 -1.6267 -1.5326 -3.1636 -1.7065 -3.5115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16735.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0159 1.0677 1.092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16736.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16738.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0457]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16739.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0241]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16740.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.23996 -0.047992 -2.6479 -5.6288 -4.4319 -9.1969 -0.012733 -0.35847]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16743.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16753.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1101 1.1101 1.1143 1.1175 1.1185 1.1217]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16754.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0968]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16771.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1548 1.1562 1.1712 1.1397 1.1562 1.063]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16775.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0631 1.0145]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16779.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0842 1.1232]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16796.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8031 1.311 1.4807 1.8046 1.0549 1.933 1.0314 1.8859]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16797.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1263]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16799.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16807.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.14477 -0.3871 -0.62156 -1.3407 -0.16011 -0.41778]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16817.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16832.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.101 1.0893]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16834.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0452 1.0452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16836.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0337]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16844.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2306]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1319]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16851.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16852.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4631 1.3569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16853.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0657]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/16860.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.135]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22410.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1403 1.4115 1.1786 1.4115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22422.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0346]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22426.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1001 1.1466]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22429.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0753 1.1219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22432.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.031 1.0635]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22443.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1577 1.2093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22444.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.072308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22450.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22451.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1685 1.2368]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22452.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.28429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1107 1.1573]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22454.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3264 1.4064 1.1621 1.1857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22456.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22460.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.06]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22464.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0209 1.0626]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22474.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0495 1.096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22478.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22479.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22487.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22490.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0218 1.2303 1.0633 1.2729]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22491.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1559 1.1876]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22492.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0488 1.0947]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22499.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0371]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22506.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22510.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0372 1.0832]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22512.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0607 1.0986]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22513.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0733 1.1342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22514.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0506]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22526.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0627 1.0978]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22527.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22530.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1253 1.1561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22537.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0331 1.0605]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22538.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22544.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22546.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0123 1.4321 1.0754 1.4938]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22547.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4094 1.502]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22548.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1724 1.2038]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22560.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1405 1.2071]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22562.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0315 1.0162]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22563.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.109 1.1553]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22566.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2225 1.0144 1.2592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22569.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0387 1.0853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22571.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0838 1.1304]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22574.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0421 1.0702]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22577.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3008 1.1577 1.0715]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22578.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.245 1.3119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22581.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0537]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22587.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0642 1.1112]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22591.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22606.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1868 1.3777]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22609.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1026 1.1507]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22612.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22613.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0107 1.037]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22617.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1407 1.7508 1.2125 3.3308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22622.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0418]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0992]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22628.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12615 -0.092308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22630.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.076923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22631.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1413 1.177]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22634.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22641.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2846 1.3688]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22644.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 17.222 2.9008 2.4608]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22646.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.7923 11.595 38.737 7.0015 5.8538 76.383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22653.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393 1.0852]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0967 1.1344]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22662.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1831 1.0264 1.2223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22663.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1166 1.1462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22675.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22683.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22687.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1334 1.1638]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22690.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0458 1.1137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22691.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1931 1.2625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22692.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1466 1.1965]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22701.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0251 1.3164 1.0686 1.361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22705.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.024615 -0.19385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22706.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0981 1.169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22714.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22716.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0658 1.127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22718.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0739 1.1433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22719.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0865 1.1228]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22725.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1273 1.177]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22727.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1455 1.1956]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22730.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22748.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3783 1.051 1.4359]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22749.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0863 1.1564]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22754.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0333 1.0782]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22755.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22757.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22758.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0654 1.0385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22760.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0396 1.1034]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22762.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0281]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22772.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.074 1.1354]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22773.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1427 1.1933]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22777.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0455 1.0736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22778.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2593 1.3333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22782.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1259 1.1659]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22784.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0299 1.2934 1.557 1.0698 1.3333 1.5969]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22785.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0474 1.1119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22787.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0846 1.1548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22802.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2211 1.2978]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22803.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 30.583 30.606 30.583 2.3846 1.8554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22810.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 43.572 373.47 27.008 101.62 124.63 583.35 2178.6 13071 28.865 24898 30536]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22812.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.018]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22814.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2472 1.3284]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22825.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0362 1.0969]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0785 1.1249]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22830.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0263 1.0595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22837.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0596]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22841.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013846 -0.016923 -0.012308 -0.053846 -0.063077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22843.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22849.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0595 1.097]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22850.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 28.102 28.122 28.102 2.1908 1.7046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22854.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0511 1.0837]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22859.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0888 1.3939 1.1498 1.4549]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22866.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22873.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.049231 -0.015385 -0.012308 -0.026154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22876.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0311]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22877.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1006]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22880.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.4169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22887.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0613 1.1089]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0851 1.1314]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22894.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.02]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22897.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1963 1.023 1.227]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22899.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0957 1.1667]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22902.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 9.6564 1.2393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22903.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10923 -0.36308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22910.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0264 1.1138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22912.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0148]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22915.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22917.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0331]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22919.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0297 1.0621]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22920.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0607]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22923.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.86]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22924.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.31539]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22926.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0822 1.1529]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0268 1.0608]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22929.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0564 1.1033]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22931.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1098 1.1733]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22935.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0221]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22936.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22942.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1599 1.1981]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22943.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0163]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22945.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2845 1.3553]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22948.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2295 1.3092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22950.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2128 1.2903]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22954.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2085 1.0462 1.25]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22961.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1696 1.2085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22963.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1554 1.1917]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22968.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2119 1.2637]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22972.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0163 1.3055 1.06 1.3492]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22978.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22981.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0481]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22984.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1304 1.1606]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22986.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3061 1.3606]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22992.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1784 1.252]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22995.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0849]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/22996.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0781 1.1255]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23004.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.054 1.0814]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0985 1.1707]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23009.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0603 1.107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23021.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.095714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23026.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 8.3623 34.987]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23029.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0558]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23031.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.095385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23035.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.127 1.1564]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23038.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1218 1.1941]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23039.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23040.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 63.155 4.9738 4.2654]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2543 1.31]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23048.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0186 1.055]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23051.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.010769 -0.052308 -0.095385 -0.45231 -0.53231 -0.57231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23053.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6162 1.9669 1.5023 1.2815 1.4323]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23058.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0606 1.1065]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23059.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0223 1.0769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23061.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 436.01 2421 829.72 648.75 7.211e+05 1.1649e+05 46753]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23065.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0181 1.0513]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23070.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0912 1.1548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23071.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0312]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23073.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0166 1.0498]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23078.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23084.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23089.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0341]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23090.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0218 1.3087 1.0654 1.3523]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23093.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0508 1.0865]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23100.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1334 1.1631]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23107.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1506 1.182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23116.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3222 1.4085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23117.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23126.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0828 1.152]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23129.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23137.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1273 1.162]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23139.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23140.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23143.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1622 1.2035]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23150.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2584 1.0529 1.309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23154.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0338 1.0785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23157.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1083 1.1447]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23172.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1602 1.2361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23187.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.069231 -0.026154 -0.078462 -0.064615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0493 1.1109]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23189.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0164 1.3023 1.0736 1.3595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23198.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10769 -0.23539]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23201.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 26.094 26.113 26.094 2.0343 1.5829]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23208.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0547 1.102]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23209.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1342 1.4488 1.1977 1.5123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2491 1.012 1.2902]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0708]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23229.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1187]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23233.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.6715 2.6069 2.6377 2.8585 2.4246 2.4354]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23234.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 28.102 28.122 28.102 2.1908 1.0539 1.7046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23244.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.22769 -0.22769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23246.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1042 1.1417]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23247.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1164 1.1803]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23248.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027692 -0.027692 -0.021538 -0.049231 -0.12461 -0.12308 -0.14769 -0.22615 -0.23077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23249.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1331 1.1969 1.2458]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23255.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3653 1.4537]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23256.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1187 1.1917]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23258.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0422]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23262.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23264.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0186 1.0631]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23271.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23274.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0581 1.1274]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23277.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.13 1.4229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23278.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0217 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0675 1.1373]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23297.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013846 -0.010769 -0.013846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23303.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0463 1.1146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23306.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.142 1.179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23316.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.03]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23320.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1308 1.1677]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23329.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23330.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0589 1.1059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23331.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23332.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0102 1.0512]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23334.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1895 1.2383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23337.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0111 1.23 1.0554 1.2731]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.05 1.1159]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23344.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0785 1.1062]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23351.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171 1.0571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23352.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0515]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0137 1.0471]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23363.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23368.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0306 1.3188 1.6056 1.0737 1.3618 1.6486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23373.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0139 1.0802]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23376.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0748 1.1175]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23383.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1951 1.0269 1.2374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23384.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23388.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0607]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23389.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 8.8171 3.1857 2.5 5359.2 8.8171 2.5 9.2214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23392.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.191 1.2426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23397.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23401.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0361 1.0962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23403.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0482 1.0768]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23412.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1455 1.1759]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23416.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23423.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.06]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23425.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.144 1.2103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23428.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0523 1.5015 1.4846 1206.1 1586 2263.3 2238.8]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23429.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0414 1.0877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23434.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0863 1.1208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23435.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1229 1.151]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23441.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23442.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5403 1.6369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23443.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1134 1.1713]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23449.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1676 1.2355]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23452.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 28.102 28.122 28.102 2.1908 1.7046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.178 1.2549]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23457.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0194]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0817 1.1209]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23471.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0392]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23477.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0188 1.0553]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23478.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.023077 -0.046154 -0.26154 -0.32]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23481.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1307 1.1806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23485.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0736 1.1172]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23486.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0821 1.1455]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23488.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0837 1.1222]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23507.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23510.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1923 1.0231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23511.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.016923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23515.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.19846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23518.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0896 1.1277]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23519.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1384 1.2032]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23527.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.082 1.1156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23533.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.044286 -0.011429 -0.034286 -0.017143 -0.012857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.335 1.335 1.0376]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23537.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3392 1.2023 1.1938 1.1962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23542.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23543.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1571 1.1636 1.2314 1.2321 1.1943 1.23]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23545.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0253]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23552.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1679 1.217]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23556.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.015 1.0489]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0752 1.1377]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23559.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3885 1.4794]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23561.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0463 1.0919]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23563.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0512]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23568.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1789 1.2422]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23572.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0335 1.0778]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23579.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0636 1.0899]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23581.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0438 1.1077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23583.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1434 1.1815]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1777 1.41 1.2023 1.6531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23601.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0861 1.1336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23609.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2165 1.2699]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23611.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1137 1.1622]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23616.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3438 1.4316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23619.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1425 1.2073]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0487 1.2779 1.0832 1.3114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23624.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1878 1.2203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23626.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.3046 2.9262 1.88 2.6 3.6338 2.3385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23628.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1684 1.2158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23629.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0331 1.0608]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23636.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0404 1.0831]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23639.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3652 1.0449 1.4449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0134 1.0401]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23647.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23650.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1557 1.4803 1.2054 1.5285]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0535]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23665.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157 1.0432]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23666.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2013 1.2487]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23668.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0118 1.0375]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23669.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.018]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23670.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.078 1.1261]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23674.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.02]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23678.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23680.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1932 1.2452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23681.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0344]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23693.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3291 1.4156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23700.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2146 1.2192 1.2185 1.2131 1.2192 1.2223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23702.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23703.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.149 1.1868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23704.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0253]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23709.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1624 1.192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23710.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1072 1.1353]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23713.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3843 1.0424 1.4433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23715.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1908 1.2427]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23718.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1547 1.1923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23722.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0943 1.1762 1.5943 1.0943 1.2388 1.5943]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23725.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0233]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23726.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1573 1.2073]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23727.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7077 2.1631 3.1492 5.68]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23729.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0511 1.0946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23730.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0957 1.1322]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23735.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2942 1.0156 1.3648]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23741.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0615 1.2916 1.0968 1.3257]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23742.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0317 1.4555 1.095 1.5189]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23747.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.197 1.249]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23752.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12 -0.081538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23756.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23759.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0908 1.1646 1.1431 1.033 1.4046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23763.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0211]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23766.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1483 1.1955]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23783.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.028 1.0647]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23784.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23789.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.25 1.1138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23799.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3029 1.3872]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23801.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1525 1.6246 1.2478 1.7185]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23805.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.0654]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23808.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.064286 -0.071429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23809.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0492]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23816.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.13692 -0.13692 -0.13692 -0.13692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23824.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1947 1.2342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23825.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0898 1.1359]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23826.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0608]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0339]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1733 1.2027]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23834.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23842.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0243 1.0839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0127 1.0571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23847.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1488 1.2239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23862.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1719 1.2362]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23864.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.6385 2.6569 2.5577]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23871.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0415 1.1021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23873.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23874.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0662 1.0431 1.06 1.0623]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23875.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0423 1.0881]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23877.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2266 1.3059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23880.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0325]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23885.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2021 1.2421]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23886.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0701 1.297 1.1149 1.3418]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23888.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0653]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23907.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1845 1.223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23913.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23914.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.139 1.1764]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23923.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7123 1.4569 1.7431 1.6815 2.2108 1.94 1.08 1.2415 1.7508 1.7785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23928.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0804 1.116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23931.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2695 1.6113 1.3206 1.6624]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23935.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23937.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2417 1.3228]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23940.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.024615 -0.084615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23949.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.1692 2.8277 3.4323 1.1404 3.5185 1.5723 2.0431 1.2026 1.9031]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23958.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0287 1.0632]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23964.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2503 1.3045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23970.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1098 1.1489]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23972.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2283 1.2832]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23973.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0122]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23979.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0587 1.1051]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23986.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.313 1.0173 1.3658 1.4138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23987.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1776 1.4303 1.2158 1.4672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23990.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0704 1.1123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23994.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0279 1.0732]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/23999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24002.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24003.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1826 1.2335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24010.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0544]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24012.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24014.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0367 1.0709]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24016.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138 1.0467]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24017.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1618 1.213]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24021.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.169 1.0125 1.2082]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24023.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1985 1.0292 1.0508 1.1711 4.9954 4.4292 5.3323 5.5738 1.2213 8.6062]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24024.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0545 1.1003]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24029.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2201 1.2712]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24031.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1326 1.1821]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24036.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.4685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24038.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.264 1.3363]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24042.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4043 8.6643 10.501 1.0496 13.954]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24046.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0347 1.2606 1.0688 1.2935]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24063.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4559 1.5499]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24064.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12923 -0.032308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24069.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1467 1.1847]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24073.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0637 1.1112]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24076.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.17857 -0.22143 -0.22714 -0.24]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24077.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0347]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24079.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0776 1.3625 1.134 1.4189]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24080.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24085.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1019 1.3433 1.1384 1.3787]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24092.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0731 1.0162 1.0246 1.0108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0305]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0731 1.1196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24109.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1246 1.1621]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24111.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0505]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24113.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0883 1.1362]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24114.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0499 1.1097]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24116.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2119 1.0351 1.2426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24119.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2191 1.2896]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24129.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1009 1.3355 1.1481 1.3827]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0846 1.0108 1.2696 1.5306 1.0606 1.3216 1.5826]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24134.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1211 1.1711]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24135.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.098571 -0.13 -0.09 -0.14571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24137.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.129 1.1673]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24138.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1665 1.1967]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24141.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2035 1.2569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24147.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.7054 3.0008 5.9023 3.2546 4.9385 1.0492 1.0138 1.1715 1.0623]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24148.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2712 1.3263]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24149.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203 1.0551]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24151.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326 1.3155 1.0895 1.3724]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24156.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.019 1.0631]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24167.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2862 1.3422]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24170.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0229 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24173.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24178.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.039 1.0848]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1411 1.1789]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24182.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1398 1.2021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.041]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24192.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0324]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24197.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.074 1.1204]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24201.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24204.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0508 1.0966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24212.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.090769 -0.089231 -0.030769 -0.032308 -0.032308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24214.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.087 1.1496]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1405 1.1911]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24227.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0293]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24234.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.086154 -0.083077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24236.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0277]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24237.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24238.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.363 1.4512]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24240.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1588 1.2239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24253.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.041 1.0747]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24254.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24255.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.012 1.0443]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24256.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2093 1.2832]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24264.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0876 1.1234]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24268.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1389 1.1774]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24274.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24278.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.024286 -0.017143 -0.36714 -0.16429 -0.42143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24282.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0215]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24288.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1434 1.1735]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24300.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0629 1.1211]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24301.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2236 1.2628]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24304.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.086154 -0.26 -0.038462 -0.016923 -0.29077 -0.021538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24306.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1669 1.8762 2.5985 6.2269 5.1585 20.591]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1973 1.2483]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24308.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1615 1.2129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24310.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.055 1.1004]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24313.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.073846 -0.026154 -0.086154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24314.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24317.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0478 1.0907]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24319.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0457 1.0734]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24336.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0323 1.0595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24339.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1176 1.1652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24341.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1044 1.1519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24343.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.29 1.4464 1.1186 1.3021 1.4593 1.1379]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24347.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24352.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.095 1.14 1.1454]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24358.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.069231 -0.17692 -0.20769 -0.13231 -0.12769 -0.12308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24366.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.1]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24369.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0314]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24371.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0455 1.0703]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24378.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0186 1.0532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24381.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0992]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24382.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0872 1.3605 1.6337 1.1424 1.4157 1.689]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24386.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0537]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24391.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24392.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.072308 -0.14615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24394.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0107 1.0554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24401.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0895 1.1188]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0143 1.0636 1.0407 1.0364]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24415.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0314 1.0655]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24416.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1647 1.2037]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24418.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1759 1.2524]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24420.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.057 1.1009]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24421.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.026 1.0929]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24424.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0229 1.0862]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24428.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0317]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24430.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0211]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24431.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138 1.4297 1.0761 1.492 1.1384 1.5543]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24432.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3739 1.0347 1.4329 1.0937 1.4934]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24433.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0213 1.0471 1.0718]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24436.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0231 1.0862]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24440.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2031 1.2816 1.3612]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24445.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1577 1.1955 1.2343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24449.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0338 1.0912]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24450.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1059 1.1773 1.2488]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3206 1.3771 1.0593 1.4336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24456.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1739 1.2233 1.2727]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24457.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018571 -0.012857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24459.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1774 1.2142 1.2511]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24461.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.0453 1.0784]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24462.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0295]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24466.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1062 1.1532 1.2016]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24473.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0754 1.1043 1.1333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24477.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0164]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24478.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509 1.0856 1.1202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24479.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7654 1.7423 1.9623 1.9346 1.5631]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24484.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.022]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24488.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1764 1.1064]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24493.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.043 1.157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24497.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0315 1.0944]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2386]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24501.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0737 1.102 1.1303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24502.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.032 1.0587]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24504.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2093 1.6826 1.2809 1.7528 1.3511 1.823]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24506.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10923 -0.061538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24507.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.9479 1.6221 1.4329 1.8086 1.3957 1.0614 3.0371 2.695 2.2514 3.4321 1.7936]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24508.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.0777]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24510.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0207]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24513.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2204 1.2959 1.3726]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24515.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24518.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1299 1.1805 1.2296]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24525.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0512 1.1137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24527.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0973 1.1454 1.1935]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24531.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.32 1.6869 1.5985 1.8631 2.3 2.1354 2.0146 1.1623 1.0269 1.6292 1.0615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24535.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.052]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24536.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0491]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24537.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0747 1.1421 1.2095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2403 1.2942 1.3482]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24542.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0379]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24543.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.043077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24545.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0889 1.1561 1.2234]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24547.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24552.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24553.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1334 1.182 1.2316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0493 1.0752 1.1011]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24559.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0466 1.0889]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24560.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0134 1.0401 1.0678]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24562.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24568.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1407 1.1763 1.2129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24573.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0387]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24575.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0415 1.0859]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24580.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2049 1.2829 1.3608]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24582.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1507 1.1894 1.227]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24588.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.152 1.4759 1.2003 1.5241 1.25 1.5724]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24589.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24592.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.058 1.3254 1.0989 1.3663 1.1385 1.4059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24596.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24599.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24601.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1457 1.1952 1.2438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24602.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0363 1.1 1.1624]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24605.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1157 1.1649 1.2141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24609.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1765 1.2061 1.037 1.2357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24612.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.048571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24616.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0422 1.0738]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24617.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 13.554 16.843 14.294 18.439 52.823 1.0293 43.884 12.543 9.9657 11.103 10.52 1.0555 11.549 295.28 283.86 303.4 316.43 342.87 1.0816 532.19]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0476 1.3374 1.6271 1.0902 1.3814 1.6712 1.1342 1.424 1.7152]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24622.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0274]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24627.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0487 1.0931]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24628.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 6.2077 8.6846 4.9508 7.1708 9.1446 12.088 17.982 27.129 7.4815 6.6554 10.008 1.0104 12.269 3.9369 3.2662 6.5969 2.7508 1.3769 1.0343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24632.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1076 1.1446 1.1802]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24638.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24641.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0347]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24642.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3222 1.4052 1.4895]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24645.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0934 1.1612 1.229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24647.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0296 1.0742 1.1188]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24652.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0378 1.0811]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24662.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0924 1.3289 1.1273 1.3637 1.1633 1.3998]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24663.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 7.0357 7.3007 6.805 6.0529 1.4843 1.385 1.2757 1.3]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24664.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24665.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3757 1.0779 1.3664 1.565 1.3664 1.7229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24666.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0139 1.0587 1.1035]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24675.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0904]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24683.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3465 1.0242 1.4046 1.0823 1.4613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24686.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1712 1.2432 1.3161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24692.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0428]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24693.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0641 1.1091 1.1554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24695.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 6.7515]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24697.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.065714 -0.061429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24699.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1627 1.232 1.3026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24701.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0167 1.0431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24707.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2689 1.3245 1.3812]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24712.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.535 1.0757 1.42 1.2864 1.2786 1.1957 1.3264]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24714.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.12 1.0543 1.0579 1.1574 1.0621 1.1948]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24715.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0542 1.1182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24721.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1188 1.1911 1.2634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24722.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.144 1.1727 1.0106 1.2014]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24723.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0201 1.0859 1.1516]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24731.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24733.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1846 1.2171 1.0386 1.2485]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24734.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0146 1.0472]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24736.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0649 1.1329 1.2009]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24741.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0953 1.1318 1.1673]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24742.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0273 1.07 1.1115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24745.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.062857 -0.1]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24746.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0408 1.4707 1.1059 1.5344 1.1696 1.5995]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24748.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0824 1.1528 1.2231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24751.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.1577 1.2254 2.2392 3.0685 2.0669]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24752.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2199 1.2705 1.3199]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24761.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0456 1.1128 1.1785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24764.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0988]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24767.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0359 1.0793]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1164 1.418 1.1613 1.4642 1.2062 1.5091]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24770.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.075714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24772.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0278]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24773.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0801 1.1067 1.1347]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24783.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.16154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24784.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0206]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24788.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24789.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1212 1.1579 1.1946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24791.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0881 1.1223 1.1578]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0582]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24799.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0233 1.0493]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24802.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1008 1.1492 1.1966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24805.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.264 1.0263 1.3059 1.0683 1.3478]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24806.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0325]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171 1.145 1.1164 1.2707 1.5864]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24814.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2301 1.2806 1.3311]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24820.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0374 1.1044 1.1715]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24823.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3058 1.3891 1.4712]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24827.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0332 1.0645]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24830.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.018 1.0453 1.0726]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24833.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1172 1.3408 1.1497 1.3747 1.1836 1.4085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24836.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1798 1.2109 1.0322 1.2431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24844.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0514 1.4865 1.1162 1.5527 1.1824 1.6176]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24849.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24851.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.068]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24858.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0812 1.1496 1.2179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24872.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0497 1.1139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24874.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0327]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24879.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0848 1.1199 1.155]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24881.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2607]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24882.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.091429 -0.07]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24885.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0857 1.0129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24887.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 494.38 400.85 158.44 140.03 1.2146 1.1377 1.0472 80.752 50.192 61.343 1.0888 32.556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24889.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0224 1.0835]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1401 1.214 1.2878]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24897.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0314]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24903.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0478]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24906.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1082 1.1376 1.167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24912.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1006 1.1703 1.2413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24916.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0512 1.0779 1.105 1.1046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24921.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0869 1.2066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3687 1.0431 1.4266 1.101 1.4846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24931.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0243 1.0878]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24933.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0353 1.0777]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24935.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2029 1.4536 2.0086]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24938.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0217 1.066 1.1112]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24942.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0282 1.0608]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24945.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0314 1.0641]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24948.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.09]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24952.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0185]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24959.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0401]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24973.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0356 1.0957]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24976.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24980.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0464]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24988.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0145 1.0483 1.0822]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24995.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2186 1.9314]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/24998.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25000.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1232 1.1602 1.1982]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25001.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0329]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.206 1.0236 1.2385 1.0561 1.271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25007.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4329 1.5189 1.03 1.605]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25011.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0986 1.1348 1.172]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25017.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0325 1.0755]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0385 1.1004]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25020.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2291 1.2694 1.0392 1.3107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25022.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0673 1.1313]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25024.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6921 1.4094 1.0771 1.4962 2.2057 2.3343 1.583 2.5857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25028.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0387]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25033.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0446 1.0715 1.0984]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25035.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0246]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25037.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0411 1.103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25038.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2364 1.235 1.8436 2.4707 2.2536]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25045.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0765 1.1919]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25047.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1025 1.1728 1.243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25048.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.455 1.5501 1.0129 1.644]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25053.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25055.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0317 1.0573 1.0819]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25056.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1623 1.2968 1.43]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25065.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0362]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25068.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0516 1.1151]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25074.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1801 1.2197 1.2582]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25075.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1455 1.1765 1.2065]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25085.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0173 1.2814 1.0568 1.3208 1.0962 1.3602]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25087.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1099 1.1403 1.1698]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25088.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0676 1.1309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25093.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0843]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25094.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1096 1.1468 1.1841]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.176 1.2069 1.0284 1.2389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25101.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0208 1.0354 1.0562 1.0169 1.0321 1.0584]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0892]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25110.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.07 1.3732 1.1159 1.4179 1.1606 1.4638]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25111.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1395 1.1889 1.2382]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25114.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0234 1.0669]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25117.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0364 1.099]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25118.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.039 1.0816]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0448 1.1092 1.1736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25122.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.28714 -0.15429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25129.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.022]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25130.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.177 1.4295 1.2151 1.4676 1.2518 1.5056]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25131.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.09 -0.29286 -0.22857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25137.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.039]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25142.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2216 1.2602 1.0418 1.2987]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25144.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0386 1.0784]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25149.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0182 1.0599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25151.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.043 1.1052 1.1686]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25154.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0362]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25164.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393 1.071]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25166.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.104 1.1726 1.2401]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25169.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0999 1.1348 1.1686]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25172.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1542 1.228 1.3018]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25174.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0322 1.0644]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25179.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0263]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25181.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1031 1.1395 1.1769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25182.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0118 1.0732]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0418 1.0757 1.1107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25187.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1835 1.2356 1.2877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25189.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0314 1.0765 1.1217]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25191.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1947 1.271 1.3486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25197.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2218 1.0385 1.2534 1.0711 1.2861]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25203.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1678 1.2061 1.2444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25216.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.013 1.0719]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2342 1.3128 1.3913]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25222.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0278 1.0593 1.0908]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25224.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6405 1.0366 1.7466 1.1428 1.8528]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0764 1.1199 1.1634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25234.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1651 1.2041 1.242]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25238.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.091429 -0.21]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25245.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2511 1.4043 1.559]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25248.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2302 1.3056 1.381]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25262.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0322]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25271.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0306]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25277.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4153 1.5083 1.6]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25278.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0704 1.3044 1.1062 1.3391 1.1408 1.3738]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25279.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.038571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25281.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25282.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0329 1.0914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25291.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1828 1.2216 1.2604]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25297.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0189 1.061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25304.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0649]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25305.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1514 1.2937 1.436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25308.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0167 1.2194 1.0472 1.2486 1.0764 1.2792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25313.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2962 1.0508 1.3395 1.0941 1.3827]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25315.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1371 1.1678 1.1986]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25316.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1697 1.6527 1.2422 1.7251 1.3146 1.7976]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25320.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0253]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25325.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1001 1.3378 1.1352 1.3741 1.1715 1.4093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25331.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2954 1.5654 2.1631]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1917 1.2446 1.2963]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25340.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.0501]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25341.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.019 1.0521 1.0864]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25347.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25350.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0911 1.1609 1.2308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25351.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1118 1.1473 1.1827]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25352.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0507 1.0835 1.1173]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25354.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.016]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25355.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171 1.0782]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25363.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.111]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25366.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.114 1.1626 1.2112]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25381.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1547 1.1911 1.2286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25386.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0764]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25392.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.08 1.1154 1.1518]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25394.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1475 1.1861 1.2237]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25395.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0468 1.0909 1.1351]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25398.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.042 1.0863]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25402.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25403.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25405.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1674 1.2064 1.2455]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0291]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25410.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0895 1.1187 1.1466]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1513 1.2244 1.2987]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25428.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0464]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25434.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292 1.2619 1.5348 1.0286 1.3029 1.5757 1.0696 1.3438 1.6166]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25437.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.9629 1.6929 1.9093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25439.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0457]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25440.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.35 3.3693 3.5457]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25459.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1328 1.1709 1.2078]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25460.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.087143 -0.11143 -0.012857 -0.14429 -0.014286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25464.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0197 1.2399 1.0522 1.2736 1.086 1.3062]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25466.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0661 1.1299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 138.49 2.1057 139.54 1.7993 149.11 2.1814]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25471.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0588]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25473.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3843 1.4712 1.5596]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25476.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2216 1.2982 1.3762]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25478.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2098 1.5543 1.2621 1.6066 1.313 1.6588]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25479.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.010769 -0.038462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25481.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0692 1.0585 1.0738 1.0618]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25484.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0395 1.074 1.1084]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25487.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0187 1.0613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25488.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1944 1.2333 1.2736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25491.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0156 1.077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25496.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0315]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0856 1.1144 1.1433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25502.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6443 1.1629 1.7614 1.0262 1.3493 1.8186 1.0678 1.7993]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25504.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0377 1.0804]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25506.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2733 1.3259 1.0263 1.3785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25508.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1866 1.5259 1.2371 1.5763 1.2888 1.628]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25514.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0318 1.0585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25515.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1578 1.1865 1.0225 1.2152]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25519.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0897 1.1187 1.1478]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25523.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1071 1.1412 1.1754]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25524.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.8771 3.9486 7.54 3.8386 5.3586 1.7243 6.1514 10.584 1.6086 4.5743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25526.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0189]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25530.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2235 1.5508 1.2728 1.6001 1.3221 1.6495]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25535.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1275 1.197 1.2666]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1598 1.1982 1.2366]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25540.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196 1.3171 1.0647 1.1793 1.1098]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25545.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157 1.0821 1.1477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25555.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.22143 -0.2 -0.16571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0164 1.055 1.1314 1.2194 1.2572 1.0449 1.2949]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25563.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0676 1.3479 1.1101 1.3905 1.1514 1.4318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25564.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1135 1.1842 1.2563]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25570.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0504 1.1139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25571.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.027 1.236 1.0582 1.2672 1.0894 1.2983]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25572.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0159 1.0568]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25576.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0796 1.1084 1.1383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25577.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0263]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25582.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1235 1.1725 1.2203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25584.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0598 1.1895 1.3192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25585.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1797 1.2093 1.039 1.239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25587.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4318 1.5169 1.031 1.6032]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25588.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3114 1.3966 1.4819]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25590.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.0613 1.1063]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25606.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25608.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0267]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25612.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0415 1.1005]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25613.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0727 1.1077 1.1426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25620.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2156 1.0314 1.2481 1.0639 1.2806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25622.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0747 1.1399 1.2063]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25630.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1007 1.1294 1.1571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25631.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0582 1.0863 1.1144]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25638.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0144 1.2226 1.0454 1.2536 1.0764 1.2857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25641.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0388 1.072]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25642.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0595 1.0877 1.1151]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0268 1.0611 1.0954]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25648.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.07]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25657.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0123 1.039]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25659.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1572 1.1868 1.0194 1.2164]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25669.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.9157 7.5714 8.7743 7.2514 5.5571 1.206 5.3029 2.2371 3.5514 3.5943 1.0241 1.3043 1.2382 3.6686 3.1071 2.93 1.04 3.2986 1.0563 5.1529 1.2704 3.2743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25670.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3063 1.6769 1.3614 1.7335 1.0459 1.4181 1.7887]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25672.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0181 1.1289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25677.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0185]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25680.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.218 1.296 1.374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25692.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0421 1.1508]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25693.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0867 1.379 1.1307 1.4217 1.1746 1.4657]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25702.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0448 1.108 1.1701]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25703.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0152 1.0466]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25704.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.015]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25707.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.15143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25709.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1022 1.2311 1.3585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25710.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4223 1.5158 1.608]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25711.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1690.4 293.77]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25715.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1374 1.1752 1.213]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25716.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.025714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25726.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0675 1.115 1.1614]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25731.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25733.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.86 1.2436 1.1607]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25738.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0673 1.1853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25740.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.16571 -0.035714 -0.17429 -0.037143 -0.18286 -0.038571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25741.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0742 1.14 1.2057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25742.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25744.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1117 1.1403 1.1689]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25745.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1407 1.2124 1.2841]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25751.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0303 1.075 1.1206]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25752.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1928 1.0113 1.2255 1.044 1.257]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25754.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3457 1.4297 1.5136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25755.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2666 1.0286 1.3082 1.0715 1.3498]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25758.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0384]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25764.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0726 1.1083 1.1441]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25773.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 6.9177 1.0431 5.8592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25776.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0616 1.126]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25779.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0489 1.0939 1.14]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25783.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25785.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25786.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.025714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25787.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.067]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25803.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0267 1.0921 1.1562]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25805.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0914 1.1276 1.1637]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25806.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.14615 -0.13077 -0.10923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25814.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1174 1.1478 1.1773]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25816.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0786 1.0189]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25818.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2901 1.347 1.025 1.4039]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25819.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0624 1.089 1.1167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25821.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1176 1.1901 1.2615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25826.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2562 1.0208 1.2979 1.0625 1.3395]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25827.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25833.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0285]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25835.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 138.49 2.1057 1.1458 139.54 1.7993 1.1939 149.11 2.1814 1.242]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25850.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1228 1.1524 1.182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25856.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0151 1.0741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25857.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4029 2.1386 1.0586 11.24 14.52 12.403 10.997 35.484 22.251 15.514 13.283]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25859.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0867 1.1226 1.1586]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25865.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1144]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25866.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0243 1.0652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25881.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1618 1.2126 1.2634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25882.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0129 1.0564 1.1008]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25883.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0593 1.1231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25889.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 32.933 28.3 23.443 27.971 2.0943 1.5229 1.2443 23.08 15.164 16.239 20.366]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1335 1.1718 1.2088]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25893.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0237]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25896.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0463 1.0793 1.1123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25897.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0742 1.1402]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25899.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0843 1.1141 1.1429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25901.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0368 1.0643 1.0926]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25902.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0144]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25903.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0318 1.0621]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0923 1.1378 1.1832]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25907.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1707 1.0243 1.1271 1.0779 1.1393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25911.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.065 1.1096 1.1533]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25918.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1281 1.1582 1.1882]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25920.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0221 1.0493]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25925.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1393 1.1774 1.2155]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0552 1.0991 1.1439]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25928.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2496 1.5784 1.9072 1.2983 1.6271 1.9559 1.0183 1.347 1.6773 2.0061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25930.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0608 1.0962 1.1306]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25940.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25941.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0598 1.1207]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25944.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0226]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25945.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0345 1.0755]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25951.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.025714 -0.13857 -0.021429 -0.014286 -0.014286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25952.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1281 1.1655 1.203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25956.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0385 1.1038 1.1704]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25957.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0493 1.0809 1.1138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25960.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191 1.0805]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25966.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.092857 -0.068571 -0.11286 -0.16714 -0.20571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25984.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0598 1.1282 1.1966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25985.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.31 1.6277]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25990.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0389 1.0727 1.1066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/25999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503 1.113]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26010.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0734 1.1091 1.1438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26011.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0706 1.1067 1.1417]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26015.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0573 1.3336 1.6098 1.0977 1.374 1.6516 1.1395 1.4158 1.692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26016.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3355 1.4225 1.5083]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26018.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1003 1.1359 1.1714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1622 1.1983 1.2344]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26023.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1163 1.1645 1.2128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26025.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0294 1.0918]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26031.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2927 1.3759 1.4577]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26033.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2217 1.2628 1.0306 1.3039]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26035.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.168 1.1987 1.022 1.2303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26040.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2082 1.2609 1.3146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0705 1.0991 1.1277]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26046.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2144 1.2942 1.3739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26051.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0213 1.066 1.1106]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26057.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2666 1.3448 1.423]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26058.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0468]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26059.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0732 1.1385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26076.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.016923 -0.013846 -0.013846 -0.024615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26077.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 387.18 4.3329 68.6 2.9043 2.2029]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26078.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0176 1.1294]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26079.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0242 1.0867]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26080.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0108 1.0526]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26094.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0266]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26095.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2534 1.033 1.2932 1.0727 1.3318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0478 1.0915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26104.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1061 1.141 1.1759]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26107.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0499 1.1137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26116.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0394 1.1066 1.1738]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26119.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26124.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1772 1.4187 1.2136 1.4551 1.25 1.4915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26133.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26137.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0361 1.0984]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26138.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0723 1.1084 1.1436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26142.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0294 1.0749 1.1193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26143.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0378 1.0638 1.0897]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26148.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0523 1.1633]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26149.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0236 1.049 1.0753]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26155.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26156.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1181 1.3612 1.1548 1.3979 1.1904 1.4335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26157.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1244 1.1529 1.1814]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0233 1.0836]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26160.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26163.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1861 1.238 1.2898]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26164.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1325 1.1817 1.2319]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26171.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.4286 1.1221 2.7414 1.4257 6.3286 1.1886 4.5771 1.7629 8.1329 1.2552 7.69]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26174.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1158 1.1525 1.1892]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26175.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0391 1.0828]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26181.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1389 1.2123 1.2857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26183.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1082 1.1564 1.2046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26184.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26185.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26186.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0384 1.0843 1.129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.126 1.1762 1.2254]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26191.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26192.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0766 1.3832 1.1229 1.4294 1.1691 1.4757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26193.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1627 1.2124 1.2634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26198.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1746 1.25 1.324]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26200.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0224 1.0671 1.1118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26204.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0571 2.6029 6.8186 16 16.053 1.3629 2.5957 6.7529 16.371 20.147 2.0329 2.61 6.3329 15.046 21.699]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26213.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0751 1.1224 1.1696]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26216.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0453 1.0906 1.137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2534 1.3072 1.3609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26229.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26232.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0178 1.0589]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26233.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7514 3.9814 10.569 185.54]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1918 1.2403 1.2888]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26237.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0871 1.1146 1.1421]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26238.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1 1.0684]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26244.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409 1.1026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26245.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.081429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26246.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214 1.0549]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26250.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26253.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3088 1.3626 1.0552 1.4164]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26254.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1746 1.2053 1.0279 1.2372]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26260.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2077 1.2246 1.2269 1.2369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26264.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26268.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 114.36 43.935 115.48 92.229 120.16 111.58]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26269.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1535 1.1842 1.0102 1.2149]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26276.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.026 1.0865 1.147]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26287.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1064]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26291.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0404 1.067 1.0945]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26293.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0304 1.2425 1.0624 1.2746 1.0945 1.3066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26296.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26301.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0195 1.625 1.8814 1.0442 1.8743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26304.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.015714 -0.44286 -0.097143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26305.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0821 1.1104 1.1387]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26313.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26320.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.039 1.1029 1.1668]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26322.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6614 1.6957 1.78 1.5421 1.4836 1.1707 1.2471 1.2071]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26330.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0764]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26331.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0179 2.5329]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26333.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0225 1.0664 1.1113]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26339.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1586 1.2083 1.2593]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26341.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.07]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1308 1.0738 1.0823]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0434]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26351.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0308 1.0943]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26355.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0433 1.108 1.1738]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26358.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0168 1.0565]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1311 1.3613 1.1656 1.3945 1.2001 1.429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26361.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0169 1.0616 1.1052]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26365.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0745 1.1099 1.1452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26368.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0472 1.1137 1.179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26370.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0166 1.0436 1.0696]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26382.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0623]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26386.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26388.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1623 1.4153 1.2005 1.4535 1.2387 1.4916]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26389.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.06]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26396.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2143 1.291 1.3677]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26398.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0454 1.0795 1.1146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26399.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0842 1.3951 1.1308 1.4417 1.1775 1.4883]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26400.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1982 1.2503 1.3024]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26404.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1602 1.198 1.2369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26410.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1517 1.1998 1.2468]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0395 1.1026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26412.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1189 1.1674 1.2158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.6757 4.9307 7.275 7.6957 5.12 5.1936 1.0521 1.4586 1.5736 1.5836 1.765 1.6164 1.0201 1.6614]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26432.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2187 1.4805 1.2577 1.5195 1.0362 1.2981 1.5585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26433.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1183]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26436.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0311 1.0761 1.1211]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26440.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0236 1.0862 1.1487]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26443.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.017 1.0603 1.1027]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26444.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0318 1.2566 1.0657 1.2895 1.0997 1.3234]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26447.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1888 1.2656 1.3413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26449.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.035714 -0.027143 -0.035714 -0.035714 -0.032857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26457.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0992 1.1689 1.2398]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26460.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26461.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1954 1.2479 1.2991]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26463.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0347 1.0786]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26464.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0359]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2089 1.2583 1.3078]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26472.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.18 -0.03]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26474.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0411 1.1097 1.1772]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26483.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0228]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26484.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0353 1.0663 1.0983]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26495.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26496.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0246 1.064]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26497.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0259 1.0871]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2717 1.0358 1.3128 1.0769 1.3539]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26504.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.068]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26507.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26509.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0531 1.0885 1.1239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26511.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1553 1.1863 1.0114 1.2174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26514.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.3408]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26516.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26520.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1242 1.174 1.223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26530.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0782 1.1475 1.2168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 9.8929 1.75 6.9114 1.1102 1.1657 9.51 1.6443 7.8771 1.1554 2.0386 10.166 2.09 8.4129 1.2005]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26536.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0267 1.0714 1.1161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26537.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0258]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26547.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26548.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 127.91 1.9486 128.88 1.6664 137.72 2.0193 1.015]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0608 1.1081 1.1543]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26566.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1747 1.2513 1.3279]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26568.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0335 1.1468]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26569.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0239 1.1337]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26570.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26573.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26574.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0487 1.1115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26582.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0959 1.1316 1.1682]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26583.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.038571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26585.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1364 1.1659 1.1955]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26592.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.028571 -0.10429 -0.11429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26594.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0448 1.3351 1.6255 1.0882 1.3786 1.6689 1.1316 1.422 1.7137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26599.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1146 1.3548 1.1501 1.3903 1.1857 1.4259]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26603.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0906]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26604.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1251 1.1558 1.1855]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26609.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.04 1.1065 1.1731]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26613.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26614.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2458 1.3266 1.4074]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26615.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26619.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.092308 -0.021538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26621.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0253]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26623.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12857 -0.24143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26627.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0674]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26637.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0127 1.0572 1.1017]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26640.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0447]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26641.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0516 1.3479 1.0958 1.3921 1.1401 1.4363]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26642.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0664 1.1314]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0362 1.2593 1.07 1.2931 1.1025 1.3269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26646.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0694 1.1376 1.2071]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26651.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0547]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26653.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0104 1.0531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26662.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.037 1.0693]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26663.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0135]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26664.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0621]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26668.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 100.06 1.6336 3.8014 1.0307 132.76 2.6421 8.5864 172.81 2.5264 5.1393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26671.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2408 1.2955 1.3503]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26674.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.028 1.0727 1.1174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26675.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3625 1.0233 1.4231 1.0839 1.4823]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26676.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2859 1.0441 1.3284 1.0866 1.3709]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26677.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.46769 -0.49385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26681.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0959 1.1441 1.1911]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26682.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.2962 1.6531 3.4285]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26694.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.064]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26696.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1845 1.2602 1.3358]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26697.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0426 1.0864]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26702.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0365 1.0994]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26705.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2054 1.2454 1.0179 1.2864]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26707.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26708.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.014]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26724.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.078]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26725.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0342 1.0618 1.0893]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26726.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26729.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4076 1.058 1.4696 1.1201 1.5317]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26733.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26737.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0687 1.1038 1.139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26742.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0355]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26747.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1192 1.2485 1.2908 1.51 1.0985 1.0485]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26748.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0325 1.0956]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26757.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0159]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26763.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1566 1.1864 1.0181 1.2151]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26767.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1197 1.1497 1.1798]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26776.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0304]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26777.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3064 1.3638 1.0391 1.4211]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26778.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0233 1.0852]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0346]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26784.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0641 1.0914 1.1187]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26787.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26788.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0264 1.0722 1.1169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26790.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0998 1.1347 1.1696]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26791.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3532 1.0355 1.4099 1.0908 1.4652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26797.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0456 1.1109 1.1751]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26798.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1471 1.1829 1.2176]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26803.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0589 1.0939 1.1289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26804.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0268 1.0882]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0249 1.0519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26811.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.03 1.4414 1.1657 1.0256]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26815.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0266]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26817.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.8923 4.9308 5.3908 5.5462 1.0597 4.7938 3.2769 6.7815 6.9738 9.06 1.0923 9.4692 1.06 1.6508 1.2892 1.1249 1.3185]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26820.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26822.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.041]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26828.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1786 1.2273 1.2761]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26830.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.063 1.0912 1.1194]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26841.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3807 1.4229 1.4171 1.46 1.0222]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26854.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0476]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26855.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26861.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2678 1.0396 1.3091 1.0797 1.3492]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26863.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2497 1.3269 1.4029]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26868.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0356 1.0675]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26869.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4899 1.5868 1.039 1.6837]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26875.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0285]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26876.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0144 1.0391]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26879.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0147 1.0419 1.068]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26883.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0428 1.2543 1.0754 1.2858 1.1068 1.3183]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26884.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1542 1.1923 1.2303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26889.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1722 1.2478 1.3233]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5069 1.5854 1.3469 1.3708 1.3323]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26892.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1194 1.1562 1.193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26900.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0394]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26903.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26904.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0551 1.0831 1.1111]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0435 1.4698 1.108 1.533 1.1711 1.5975]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26906.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0321 1.0569 1.0829]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26909.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0615 1.1243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26912.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1291 1.2026 1.2761]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26917.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0116 1.0732 1.1347]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26919.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.022 1.047 1.073]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26921.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0838 1.1198 1.1559]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26923.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2044 1.2578 1.31]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26924.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0892 1.158 1.2268]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26929.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.069 1.097 1.126]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26932.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0412 1.3381 1.0857 1.3826 1.1302 1.4271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26933.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0388]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26934.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0348 1.0606]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26937.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26939.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.31231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26941.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 31.401 31.903 19.161 24.441 28.404 32.821 55.221 71.639 40.801 34.771 42.21 41.543 1.0243 1.11 1.0229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26949.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0411 1.1561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26953.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1737 1.2036 1.0329 1.2335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26954.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.207 1.3459 1.4847]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26956.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0807]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26960.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1143 1.187 1.2585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26962.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2528 1.3049 1.012 1.3556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26963.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0675 1.1313]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26968.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26971.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26973.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5354 1.2492 1.4454 1.0141 1.6085 1.2808 1.076]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26976.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 677.82 1929 6171.9 1.117 58.657 755.6 2091.3 6219.1 1.1516 44.97 386.14 2176.6 1.0971 6647.9 1.1848 62.097]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26983.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0688 1.1355 1.2036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26990.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0951]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26994.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0477 1.0752 1.1019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/26996.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.14714 -0.25143 -0.15714 -0.084286 -0.055714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27001.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1785 1.011 1.2087 1.0401 1.2378]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27008.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1407 1.1707 1.2007]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27009.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0209]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27010.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0703 1.1177 1.1652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27013.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1748 1.2056 1.0292 1.2365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27015.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2953 1.3517 1.0294 1.4081]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27027.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0636 1.0906 1.1176]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27030.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0653 1.1244]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27034.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1061 1.1343 1.1625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27037.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2018 1.4609 1.2409 1.5 1.0208 1.2799 1.5391]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27043.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2277]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0739 1.1213 1.1676]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27046.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1865 1.2176 1.0386 1.2497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27047.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0127 1.4041 1.0712 1.4625 1.1309 1.5222]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27048.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0668 1.1015 1.1361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27049.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1783 1.4344 1.2175 1.4737 1.2555 1.5116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27051.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2514 1.3074 1.362]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27052.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0452 1.0868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27053.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0152 1.1205]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27054.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2119 1.2519 1.0227 1.293]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27056.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0963 1.1245 1.1528]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27066.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0225 1.1353]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27067.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0816]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27068.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0544 1.0882 1.1211]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27069.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.112 1.184 1.2549]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27070.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0351 1.0793 1.1246]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27074.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0331]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27079.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27080.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.5408 1.5708 1.1444 3.5977 1.3677 1.5423 1.1946 4.4138 1.2262 1.5523 1.2448]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27084.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.7093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27086.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0472 1.1101]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27088.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0309 1.1424]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27089.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 105.63 40.58 1.0938 106.65 85.184 1.1218 110.98 103.06 1.1497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27090.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.022 1.0817]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27093.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4415 1.5351 1.6286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27095.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0481 1.161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0993]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27097.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0546 1.1004 1.1472]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27113.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0696 1.2906 1.1028 1.3238 1.1359 1.3569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27116.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.8085 1.1969]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27118.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0107 1.0726 1.1346]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27120.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0903 1.1259 1.1616]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27122.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.030769 -0.018462 -0.08 -0.016923 -0.044615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27123.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0286 1.0717]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27124.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.57429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27125.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.08 1.1279 1.1759]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27126.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0237 1.2445 1.0564 1.2773 1.0892 1.3101]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27130.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1891 1.2289 1.2687]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27131.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0356 1.3229 1.6088 1.0782 1.3656 1.6529 1.1223 1.4082 1.6956]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27134.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0227 1.049]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27135.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.1317]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27143.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1512 5.5546 5.2615 1.2215 1.2919]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27153.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1514 1.2022 1.253]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27154.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3683 1.4569 1.5467]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27157.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0354 1.04 1.0654 1.0177]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27163.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0331 1.0763 1.1196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27178.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0801 1.1277 1.1754]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0501 1.0851 1.1192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27186.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 113.75 43.702 114.86 91.737 119.52 110.99]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1898 1.2419 1.2939]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27189.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27190.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1044 1.1533 1.2013]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27195.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.056 1.1161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27201.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0584]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27215.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1732 1.2105 1.2467]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27217.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0562 1.1198]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27219.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.094286 -0.067143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27222.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0554 1.02 1.0277 1.0762 1.0585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27225.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0726 1.1012 1.1299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27227.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1929 1.2432 1.2924]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27228.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0629 1.13 1.1972]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3519 1.033 1.4089 1.0888 1.4647]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27241.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0608 1.105 1.1492]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27242.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.22 1.3857 1.2386 1.4743 1.5129 1.3579 1.7479 1.4586]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27244.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0177 1.0497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27251.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2446 1.3003 1.3549]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27258.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0148]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27260.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0907 1.1251 1.1595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27261.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2486 1.3039 1.3591]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27266.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0416 1.434 1.1002 1.4927 1.1589 1.5513]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27268.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1042 1.1405 1.1769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27270.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.206 1.2837 1.3614]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27272.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0312]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27274.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0175 1.06 1.1015]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27276.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0365 1.1019 1.1682]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27277.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0416 1.0822]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27278.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2716 1.6007 1.3199 1.6504 1.0404 1.3695 1.6986]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27280.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0555 1.0826 1.1096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27285.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4662 1.56 1.0262 1.6552]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27289.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3491 1.0149 1.4074 1.0745 1.467]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27291.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0296 1.1418]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0149 1.2327 1.0474 1.2652 1.0798 1.2977]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27295.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0495 1.1086]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27298.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2384 1.3168 1.3964]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27302.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.17846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27303.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.244 1.2957 1.3474]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0232]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27314.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0706 1.1353]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27315.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2207 1.1107 1.5071 1.6086 1.1693 1.4036 1.315]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27316.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1016 1.1684 1.2353]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27317.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0125 1.045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27318.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0457 1.1105 1.1752]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27322.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0184 1.13]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27323.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0767 1.1124 1.1472]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27326.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.021429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27328.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0505 1.1094]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27329.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.075385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27331.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.015385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27335.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2673 1.0288 1.3088 1.0703 1.3514]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27336.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.8193 6.1264 8.4814 1.3379 5.6971 2.9486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0701 1.1805]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27343.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.052308 -0.027692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0317 1.0589]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27357.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0455]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27360.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0298]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27363.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0665 1.1132 1.1609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27367.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 11.815 1.7469 1.5538 1.0123 11.887 1.7785 1.66 1.0569 11.967 1.8723 2.0362 1.1006]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27369.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27378.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0325 1.0958]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27382.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0593 1.1219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27385.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0482 1.1086]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27388.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27390.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.248 1.3025 1.3569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27392.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1936 152.37 58.334 1.2371 153.85 1.0132 122.81 1.4214 160.1 1.0443 148.65]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27395.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.031 1.0721]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27401.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1376 1.1682 1.1988]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27406.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.022857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27412.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4085 1.0579 1.4711 1.1192 1.5325]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27415.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0636]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27424.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.02 -0.26]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27427.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27434.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1126 1.183 1.2535]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27435.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.095 1.4101 1.1422 1.4573 1.1894 1.5045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27439.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0333 1.0963]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27452.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0851 1.1206 1.156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27457.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0408]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27458.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.055385 -0.14154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27461.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1083 1.1372 1.167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27465.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.027 1.0612 1.0953]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.024]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27472.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0181 1.0508]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27473.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0484 1.0915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27477.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1178 1.1476 1.1775]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27479.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0421 1.3212 1.0842 1.3633 1.1248 1.4053]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27480.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.8857 1.05 4.8993 7.1871 4.9807 1.0379 5.9443 7.9 4.6421 6.3407 6.685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27483.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0297 1.0724 1.1139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27486.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0344]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27491.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27494.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27495.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.075714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27497.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0201]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27499.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0105 1.0376 1.0637]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27501.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2775 1.3324 1.0202 1.3873]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0678 1.1146 1.1613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0266 1.06 1.0935]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27506.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0122 1.3967 1.0699 1.4544 1.1277 1.5122]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27508.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0366]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27509.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.093 1.1409 1.1889]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27512.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1517 1.2261 1.3017]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27525.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1345 1.1846 1.2347]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27526.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.05]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27527.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0231 1.0508 1.0785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27529.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0152 1.058]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27530.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0743 1.101 1.1286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27531.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1781 1.2547 1.3302]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2282 1.5549 1.2767 1.6034 1.3267 1.6519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27537.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1987 1.0178 1.2302 1.0493 1.2627]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27538.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2382 1.3176 1.3982]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27541.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2672 1.3211 1.0172 1.375]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27543.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3163 1.374 1.0465 1.4317]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27544.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0648 1.0937 1.1216]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27547.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0584 1.3565 1.1023 1.4018 1.1477 1.4471]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27553.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0337 1.0769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27554.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0622]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0431 1.07 1.0969]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27559.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.039 1.0718 1.1047]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27561.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0302 1.4558 1.0934 1.519 1.158 1.5822]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27562.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1823 1.2591 1.3348]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27571.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0852 1.3866 1.1294 1.4323 1.175 1.4779]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27574.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.125 1.1987 1.2714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27581.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.216 1.2945 1.3741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27582.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1211]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27583.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.0399]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27587.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.3571 1.3114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27588.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.028 1.0532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27591.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1179 1.1655 1.2131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27592.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171 1.06 1.104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27598.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0177]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27599.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.064 1.0988 1.1348]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27602.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.095714 -0.15571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27604.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3062 2.5062 9.3492 9.0215 12.409 17.64 24.385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27614.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0347]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27617.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0887 1.1347 1.182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0403 1.074 1.1066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27624.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.106 1.1784 1.2497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27628.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0185]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27634.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1073 1.1552 1.204]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27639.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.0532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27645.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0269 1.0699]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27648.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0954 1.1668 1.2372]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27651.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1333 1.257]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27652.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2666 1.0283 1.3093 1.07 1.351]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27653.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.059 1.1063 1.1525]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27655.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27659.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0931 1.1644 1.2347]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27663.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1311 1.1683 1.2055]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27671.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4159 1.5077 1.5994]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27672.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0143 1.2968 1.0572 1.3397 1.0989 1.3826]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27673.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0417 1.0849 1.1271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27674.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27675.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2113 1.2643 1.3174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27680.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10429 -0.11 -0.16 -0.055714 -0.062857 -0.08]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27685.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0982]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27686.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0586 1.4021 1.0178 1.6593 1.0594 1.8071 1.102]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27687.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27695.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.184 1.2353 1.2867]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27699.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27706.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0346 1.0215]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27711.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0649]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27719.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.1336 3.4143 11.052 7.6764 8.6657 8.3021 9.8986 14.697 22.562 15.001 13.2 5.4693 6.5943 14.905 25.763 22.056 18.036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27728.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2272 1.2805 1.3338]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27742.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.23846 -0.24462 -0.22769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27743.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3306 1.3878 1.0612 1.4449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27747.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0526 1.4598 1.1136 1.5208 1.1745 1.5817]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27751.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1458 1.1951 1.2444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27760.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1503 1.1995 1.2486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27763.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2088 1.2589 1.3091]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27767.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0711 1.1406 1.2101]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27769.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0259 1.0525 1.0804]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27776.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0927 1.121 1.1502]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27779.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2642 1.3153 1.0241 1.3665]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27783.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0487]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27784.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0964 1.1254 1.1543]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27790.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.037143 -0.048571 -0.062857 -0.055714 -0.07 -0.094286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27801.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0114 1.0443]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27802.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0351 1.0785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.109 1.24 1.3697]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27809.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.208 1.2612 1.3133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27810.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2507 1.5171 1.0253 1.2917 1.5567 1.0649 1.3313 1.5977]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27811.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0729 1.1424 1.2119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27813.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0226 1.0548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27815.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0117]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27820.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.6077 1.0102 3.6285 1.0428 3.8185 1.0746]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27821.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1448 1.6193 1.2154 1.6914 1.2874 1.762]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1046 1.5341 1.1686 1.5982 1.2326 1.6636]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27833.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0611 1.1704]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27834.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0379]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27837.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.13385 -0.13385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27838.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5069 1.37 1.1003 1.8623 1.0285 1.1717 1.4415 1.7338 1.243 1.6238]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27839.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1527 1.2277 1.3027]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0658 1.13]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27846.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.39857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27848.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0679]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27851.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.179 1.2092 1.0326 1.2406]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27856.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.238 1.291 1.3452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27863.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.282 1.3572 1.4339]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27865.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0145 1.0799 1.1453]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27870.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0562]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27872.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 138.49 2.1057 1.1869 139.54 1.7993 1.2592 149.11 2.1814 1.3327]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27875.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.5957 2.5286 2.5036 2.5186]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27877.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.19231 -0.20461 -0.013846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27881.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0342 1.1557 1.2759]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27882.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.6129 7.0757 12.88 15.026 162.08 337.42 386.95 566.16 2.4171 2.3357 4.6729]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27883.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0978 1.1462 1.1945]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27884.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0205 1.2401 1.0539 1.2721 1.086 1.3055]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27886.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0511 1.1193 1.1864]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27887.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0306 1.0633 1.0974]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.0548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27898.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0498 1.1177 1.1857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27899.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2351 1.2753 1.0438 1.3167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27902.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0328 1.0753]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27904.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0973 1.1447 1.1922]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0374 1.0998]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27907.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0176 1.0604 1.1044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27915.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0122 1.0551]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27916.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0507]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27917.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0253]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27919.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0437]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27922.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0318 1.1447]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27923.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0146 1.0463]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27925.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0225 1.0481]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27946.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0979 1.1469 1.1948]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27948.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3276 1.4125 1.4987]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27949.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4571 1.2557 1.2314 1.0171 3.0936 1.6171 1.4164 1.6064 1.1486 1.0324 1.0936]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27953.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0237]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27956.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0814 1.1274 1.1723]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27957.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0839 1.1504 1.218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27961.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0242 1.0668 1.1104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27964.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0467]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27968.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0764 1.1116 1.1477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27972.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0375]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27979.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0643 1.1114 1.1585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27980.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.1543 4.8614 2.4771 2.0514 1.7043 1.4029 2.8429 2.4471 3.28 311.3 332.81 150.27 134.6 116.2]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27984.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2198 1.2995 1.3778]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27985.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1987 1.2766 1.3544]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27987.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1056 1.1767 1.2479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27991.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0932 1.2136 1.334]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/27993.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0893 1.0903 1.0936 1.12 1.3014 1.1487]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28004.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2126 1.2846 1.3567]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0329 1.0588]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28007.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0558 1.1194]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28010.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.083077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28012.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0122 1.0415]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28014.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1504 1.1889 1.2274]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28016.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203 1.0457 1.0701]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28025.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3938 1.0301 1.4308 1.075 1.2615 1.1199]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28028.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1015]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28033.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3429 1.4306 1.5171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28036.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0886 1.3111 1.1216 1.3441 1.1546 1.3784]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28038.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0945 1.1614 1.2283]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28039.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.201 1.0196 1.2335 1.0521 1.266]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28046.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5185 1.4431 2.0115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28050.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0181 1.0601]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28053.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4827 1.577 1.0444 1.6713]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28055.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0986 1.1693 1.2401]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28056.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0113 1.0726]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28061.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.28286 -0.18]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28063.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1705 1.502 1.2204 1.5519 1.2702 1.6018]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28066.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0202 1.0648 1.1095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28080.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0265 1.0924 1.1583]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28084.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0242 1.089 1.1538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28098.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1171 1.1474 1.1763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.066 1.0986 1.13]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28100.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0904 1.139 1.1866]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28104.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0135 1.0404 1.0673]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28105.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0245 1.0906 1.1567]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28106.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0148]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28107.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.141 1.2142 1.2884]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28109.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0346 1.0804 1.1253]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28110.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0529 1.0963]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28111.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0342 1.0605]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28114.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1892 1.2272 1.0118 1.2651]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28117.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1921 1.2843 1.1257]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28120.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1164 1.1621 1.2078]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28123.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0178 1.2392 1.0512 1.2714 1.0845 1.3048]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28127.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0536 105.63 40.58 1.0836 106.65 85.184 1.2114 110.98 103.06]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 92502 1.295e+05 7.0122e+05 1.0495 2855]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28139.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28140.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0461 1.0785 1.1119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28141.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1066 1.1768 1.2483]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28145.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0987 1.1282 1.1576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28146.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0936 1.1637 1.2327]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28150.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2201 1.0346 1.2532 1.0666 1.2862]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28151.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2575 1.5306 1.0247 1.2978 1.5722 1.0663 1.3394 1.6125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28156.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1803 1.2564 1.3337]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28157.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2632 1.0263 1.3053 1.0674 1.3463]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28169.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2464 1.0436 1.1693 1.3986 1.0293 1.0229 1.3779 1.5214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28175.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0808 1.1508 1.2195]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28176.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.252 1.3058 1.3609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28178.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0544 1.119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0988 1.1436 1.1871]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28181.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1048 1.1335 1.1612]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28183.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0525 1.0875 1.1225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0105 1.0443 1.0782]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28189.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0687 1.1336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28191.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28193.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3683 1.0286 1.427 1.0887 1.487]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28196.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2581 1.0396 1.2971 1.0786 1.335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28198.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3985]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28199.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1095 1.1389 1.1674]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28204.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28205.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0261]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28209.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2091 1.553 1.26 1.6052 1.3122 1.6561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28212.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0713 1.132]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28214.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0693]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28223.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0151 1.0599 1.1036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28225.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2787 1.3349 1.0189 1.391]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2817 1.0393 1.3244 1.0819 1.367]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0755 1.1216 1.169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28232.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0254 1.3051 1.0678 1.3475 1.1102 1.3898]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2262 1.3056 1.3849]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28237.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28239.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0188]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28240.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0261 1.0528]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28242.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.055 1.274 1.0881 1.3072 1.1213 1.3392]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28253.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0261 1.0599 1.0938]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28255.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0994 1.2206]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28257.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1494 1.2002 1.251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28262.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.02 1.0656 1.1102]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28264.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1845 1.2331 1.2817]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28269.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0199]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28271.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.26143 -0.15286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28276.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 6.8957 1.11 5.68 1.4829 1.2757 9.28 2.1443]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28279.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3029 1.5471 2.1964 2.08 8.9979 8.6686 7.7757 8.0271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28284.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1378 1.208 1.2772]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28293.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.38 1.26 1.0736 1.1536 1.3579 1.0843 1.1264 1.6614 1.3357 1.1571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28299.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0523]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28300.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1204 1.2427]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28303.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2163 1.2689 1.3216]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28306.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.063]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28311.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1146 1.1631 1.2116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28315.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1156 1.1451 1.1746]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28317.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0211 1.2316 1.0524 1.263 1.0837 1.2954]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28320.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28328.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0308 1.0642 1.0986]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28334.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0281]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28336.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1938]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 9.3523 14.418 7.3462 6.0831 103.28 104.81 50.498 35.077 2.2015 2.1708 1.2954]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28343.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.031429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28345.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0508 1.0953]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28346.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.04 -0.091429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.0977 1.1946 3.3554 1.2448 13.768 1.296]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28350.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0185]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28353.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1526 1.2036 1.2546]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28360.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1281 1.1649 1.2004]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28361.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0217]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28366.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1216 1.1941 1.2665]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28368.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1928 1.2397 1.2865]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28369.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0193 1.062]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28376.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.054 1.1692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28377.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1037 1.1738 1.2437]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0166]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28387.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1237 1.5889 1.1948 1.66 1.2644 1.7296]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28390.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.052 1.0857 1.1184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28391.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1111 1.1474 1.1838]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28393.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.185 1.2253 1.2646]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28396.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1545 1.1837 1.0198 1.2119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28397.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3159 1.4004 1.4849]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28400.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0699 1.1383 1.2077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0223 1.2808 1.5392 1.0616 1.32 1.5785 1.0995 1.3593 1.6177]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28407.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1838 1.2147 1.0363 1.2468]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28408.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0473 1.1145 1.1828]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0451]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28412.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28415.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28418.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1426 1.2162 1.2898]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28421.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0252 1.1376]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28428.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1594 1.1973 1.2352]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28430.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3465 1.0111 1.4057 1.0703 1.4649]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28431.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0514 1.0851 1.1177]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28439.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1355 1.1825 1.2296]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28442.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0219 1.2421 1.0548 1.2749 1.0887 1.3078]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28444.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0639 1.193 1.3234]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1056 1.1351 1.1647]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28452.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.012 1.0451 1.0792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28455.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.031429 -0.048571 -0.11286 -0.11571 -0.018571 -0.035714 -0.042857 -0.29429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28456.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.0355 1.0614]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28459.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1103 1.1382 1.1662 1.1941]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28467.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011429 -0.011429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.014 1.0719]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28470.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0165 1.0426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28471.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0636 1.0636 1.2271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28472.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0422 1.085 1.1265 1.1693]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28474.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0394 1.08]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28475.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28479.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.035 1.0678 1.1007]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28486.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0354 1.0803 1.1261 1.171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28488.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0641 1.3475 1.1073 1.3893 1.1491 1.4325 1.1923 1.4744]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28491.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0864 1.1151 1.1437 1.1734]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28493.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2133 1.2533 1.0244 1.2944 1.0644 1.3344]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28494.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013846 -0.016923 -0.013846 -0.010769 -0.044615 -0.013846 -0.066154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28496.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 243.47 1415.2 231.02 1201.4 336.38 251.79 1663.1 230.98 1747.7 435.65 264.27 1775.4 231.01 1947.1 549.01 285.52 1953.6 230.98 1866.4 1.0857 881.56]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1038 1.1403 1.1756 1.2121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28499.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0362 1.0628 1.0882]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28501.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0812 1.3641 1.1232 1.4062 1.1667 1.4482 1.2087 1.4902]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.0679]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1814 1.2332 1.2851 1.3369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28508.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0297]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28510.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1954 1.2357 1.0106 1.2749 1.051 1.3141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28511.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0564 1.0153 1.0406 1.0658]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28512.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2274 1.0187 1.2648 1.0548 1.3009 1.0921 1.3383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28523.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0236 1.2408 1.0667 1.1083]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28526.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0347 1.0679 1.1001]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28530.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1435 1.1812 1.2199 1.2576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28535.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1923 1.0193 1.2228 1.0498 1.2533 1.0804 1.2838]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28536.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0213 1.063 1.1038]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28537.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.25714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28538.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.051429 -0.042857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28541.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1305 1.1675 1.2044 1.2426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28543.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.177 1.2273 1.2775 1.3289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28546.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0142 1.2714 1.9221 1.0386 1.225 1.063]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28547.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.035 1.0806 1.1263 1.1719]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28553.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0105 1.0372 1.0627]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.015 1.045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28560.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1435 1.3904 1.1803 1.4282 1.217 1.465 1.2549 1.5017]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28561.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28564.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.069 1.1701]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28571.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0233 1.0661 1.1089 1.1518]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28574.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0357 1.0617 1.0877 1.1136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28577.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0294 1.0598]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28578.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.047143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28579.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.067143 -0.54]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28581.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0304 1.1309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28587.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0608 1.089 1.1172 1.1463]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28588.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0435 1.0876 1.1316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28590.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0975 1.1457 1.194 1.2422]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28591.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0179 1.0579 1.3293 2.2679 4.1614 1.0978 3.8921]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28592.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.445 2.8086 2.235 1.6179 1.7 2.7079 3.0257 2.4936 1.7664 1.0721]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28594.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0236 1.1234]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28595.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0134 1.2207 1.0446 1.252 1.0758 1.2832 1.107 1.3144]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28598.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28599.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28601.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.044 1.0895 1.1351 1.1806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28602.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1634 1.233 1.3026 1.3722]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28607.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0772 1.1126 1.1481 1.1835]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28609.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0248]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28611.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6064 1.6071 1.6064]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28616.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.0367 1.0628]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28617.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2514 1.0188 1.2918 1.0592 1.3336 1.101 1.374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0443 1.0871 1.065 1.0936 1.0771 1.105 1.0929 1.1243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1507 1.1797 1.0121 1.2098 1.0422 1.2389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28632.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0852 1.1191 1.1539 1.1888]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28633.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.101 1.4116 1.1469 1.4575 1.1943 1.5049 1.2403 1.5508]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28636.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0953 1.1318 1.1682 1.2047]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28639.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.075 1.1038 1.1327 1.1615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28640.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0599 1.1043 1.1478 1.1912]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28646.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4188 1.0671 1.4819 1.1289 1.5436 1.1919 1.6054]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28648.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.075 1.3561 1.6358 1.1169 1.398 1.6777 1.1588 1.4399 1.7209 1.202 1.4818 1.7628]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28650.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0186]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28651.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0302 1.0634 1.0954 1.1286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28652.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0434 1.0831]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28655.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0469]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28659.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.0666]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28660.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28661.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1193 1.1564 1.1934 1.2305]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28663.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.0429 1.0697]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28664.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0108 1.0493]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28667.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7229 1.6857 1.8736 2.2521 2.4093 2.4236]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28669.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0567]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28674.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.306 1.3894 1.4729 1.5563]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28680.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28681.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0936 1.3072 1.1255 1.3405 1.1574 1.3724 1.1893 1.4043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28688.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1249 1.1602 1.1956 1.231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28689.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0143 1.2297 1.0459 1.2613 1.0791 1.2929 1.1107 1.3261]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28697.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0799 1.1132 1.1465 1.1798]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28699.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0867 1.1233 1.1599 1.1956]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28702.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1167 1.153 1.1894 1.2257]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28705.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.013 1.0758 1.14 1.2042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28723.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0163 1.0407]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28725.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0161 1.0483 1.0806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28726.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0213 1.0591]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28727.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2209 1.0367 1.2537 1.0695 1.2864 1.1023 1.3192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28729.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.021429 -0.16429 -0.044286 -0.15857 -0.13429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28731.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0255 1.1208 1.0675 1.1662 1.1094]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28735.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.018 1.0499 1.0817]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28736.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0569 1.1008 1.1446 1.1896]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28737.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0529 1.1429 1.0259 1.0652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28739.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.26 -0.031429 -0.024286 -0.045714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28744.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011429 -0.011429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28745.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0596 1.0875 1.1162 1.1449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28749.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1757 1.4164 1.5164 1.5214 1.0371]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28752.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0226 1.0475 1.0723]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28759.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28760.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0329 1.0738]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28763.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0101 1.0359]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28766.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.011 1.0529 1.0948]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28771.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28781.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2986]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28783.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.35143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28786.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0331]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28787.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28788.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1473 1.1853 1.2233 1.2613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28791.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0669 1.1025 1.1381 1.1737]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28793.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28797.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0321]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28801.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1001 1.1446 1.1891 1.2336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28803.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1732 1.4958 1.2211 1.5437 1.269 1.5915 1.3183 1.6408]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28806.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0547]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0377]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28811.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2821]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28812.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.036 1.1028 1.1687 1.2356]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28814.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0439 1.1113 1.1775 1.2449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28823.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1881 1.227 1.2669 1.045 1.3058]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28828.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0507 1.0782 1.1056 1.1342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0487]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28830.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1294 1.1667 1.2039 1.2422]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28834.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.074 1.1095 1.1451 1.1806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28840.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0603 1.0873 1.1143 1.1414]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28841.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2694 1.3244 1.3805 1.0639 1.4367]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28842.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2236]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28846.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0772 1.1937 1.3089]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28852.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2614 1.317 1.3726 1.0578 1.4271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28854.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0651 1.1289 1.1913]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28857.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28860.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0102 1.0673 1.1245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28864.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6064 1.6071 1.6064]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28878.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.014]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28880.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.0617 1.0954]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28881.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2199 1.4579 1.018 1.256 1.494 1.0541 1.2921 1.5301 1.0902 1.3282 1.5648]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28882.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0864 1.1857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28885.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.047 1.0887]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28887.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0766 1.11 1.1434 1.1768]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28889.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0126 1.0493]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28890.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1981 1.0181 1.2306 1.0506 1.2619 1.0819 1.2931]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28893.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.043 1.0776 1.1131 1.1477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28901.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409 1.0721]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28902.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0429 1.0757 1.1096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28904.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.16714 -0.29571 -0.048571 -0.015714 -0.19286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28911.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0283]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28914.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0417]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28915.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1357 1.205 1.2729 1.3421]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28918.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1221 1.1522 1.1823 1.0117 1.2124]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28921.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1371 1.188 1.2378 1.2887]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28924.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0108 1.7492 1.3269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28925.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0567 1.0901 1.1235 1.1568]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28929.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0591 1.127 1.1936 1.2602]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28934.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1517 1.2921 1.4326 1.573]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28936.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0368 1.079 1.1223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28939.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1725 1.4824 1.2198 1.5298 1.2656 1.5756 1.313 1.6229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28941.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1307 1.1457 1.15 1.1921 1.2421]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28943.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0694 1.1033 1.1372 1.1711]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28957.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0271 1.0589]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28959.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0148]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28960.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.855 2.1921 2.0971 2.2764]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28964.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28965.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2604 1.3151 1.3698 1.0586 1.4245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28969.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0341]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28971.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032857 -0.065714 -0.11286 -0.078571 -0.13571 -0.034286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28972.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.05]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28973.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1006 1.1367 1.1729 1.209]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28974.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.029 1.058]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28976.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0293 1.0687]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28980.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.015385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28986.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0423 1.0759 1.1095 1.1445]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28992.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2543 1.0371 1.0771]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28993.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1881 1.4447 1.2258 1.4836 1.2648 1.5214 1.0459 1.3038 1.5604]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/28999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.02 1.1313 1.2413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29006.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2492 1.0661 1.1001 1.1331 1.1672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29012.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.251 1.594 1.3018 1.6461 1.3539 1.6968 1.0617 1.4047 1.749]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29018.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1353 1.1707 1.2073 1.2427]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29022.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0357 1.0262 1.0565]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29033.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3516 1.0308 1.4082 1.0874 1.4648 1.144 1.5214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29042.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509 1.0926]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29043.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0705 1.1049 1.1393 1.1748]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0134 1.0402 1.0679 1.0947]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29048.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.375 1.0542 1.4307 1.1099 1.488 1.1672 1.5437]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29049.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0325 1.0645]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29052.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29064.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0116 1.0443 1.076]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29068.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0364 1.082 1.1267 1.1723]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29069.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1709 1.2094 1.2479 1.0313 1.2852]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29070.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4086 1.0596 1.4695 1.1219 1.5319 1.1828 1.5928]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29071.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1538 1.2026 1.25 1.2974]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29073.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1118 1.1596 1.2075 1.2564]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29074.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0136 1.0581 1.1016 1.1462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29077.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.127 1.198 1.2704 1.3428]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29082.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0257 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29086.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0235 1.0565 1.0882]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29092.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0114 1.0515 1.0925]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29095.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0366 1.0801 1.1236]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29100.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0931]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0934 1.1196 1.1473 1.1736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29103.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0285 1.1531 1.2778 1.4024]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29104.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0483 1.0923 1.1362]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29105.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1159 1.3584 1.1524 1.395 1.189 1.4302 1.2256 1.4668]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29106.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1287 1.1584 1.1881 1.0198 1.2178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29108.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2349 1.2752 1.0446 1.3156 1.085 1.3571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29109.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0289 1.0545]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29110.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.034]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29112.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0337]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29113.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.7308 13.71 2.5377 4.2231 3.5385 2.8785 4.5392 5.2023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29120.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0123 1.0696]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29127.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0287]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29129.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0628 1.0915 1.1202 1.1489]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29130.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0178 1.0617 1.1056 1.1506]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29135.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326 1.1442 1.2558]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29141.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.291 1.0491 1.3341 1.091 1.3772 1.1341 1.4192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29142.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.265 1.5368 1.0353 1.3056 1.5773 1.0758 1.3461 1.6179 1.1164 1.3866 1.6584]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29143.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0185 1.0512 1.0839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29148.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29152.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29153.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0993 1.1357 1.172 1.2084]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29155.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29156.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.02 -0.12308 -0.021538 -0.018462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29165.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2384 1.3129 1.3889 1.4634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29168.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29176.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.038 1.0648 1.0916]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29183.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0202 1.0821 1.1441]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29187.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.0488]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29188.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.06 -0.029231 -0.11846 -0.092308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29189.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0698 1.0981 1.1264 1.1547]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29200.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29205.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1142 1.3583 1.1513 1.3954 1.1873 1.4314 1.2244 1.4685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29207.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0417 1.0732]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29210.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1867 1.226 1.2664 1.0415 1.3057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29212.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1443 1.1734 1.2025 1.0384 1.2316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1652 1.1958 1.021 1.2264 1.0528 1.2582]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29221.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0221 1.054 1.0859]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29223.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1208 1.1573 1.1938 1.2303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29225.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0433 1.086 1.1288 1.1715]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0773 1.1133 1.1483 1.1843]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29240.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4203 1.0665 1.4818 1.1292 1.5445 1.1907 1.6073]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29245.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.08 -0.026154 -0.018462 -0.02]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29247.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0534 1.0873 1.1212 1.1564]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29250.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0364]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29252.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0466]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29254.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0796 1.1072 1.1359 1.1635]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29255.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0341 1.075]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29257.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0886]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29258.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1935 1.439 1.2299 1.4753 1.0221 1.2675 1.513 1.0584 1.3039 1.5494]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29259.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0656 1.134 1.2024 1.2707]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29260.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.048 1.0927 1.1363]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29265.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.087143 -0.31 -0.068571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29266.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29268.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.031429 -0.034286 -0.064286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29272.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29283.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1496 1.1783 1.0157 1.207 1.0444 1.2357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29288.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0473 1.3417 1.0907 1.3863 1.1353 1.431 1.18 1.4757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29290.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1513 1.182 1.2126 1.0398 1.2433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29291.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.070769 -0.049231 -0.010769 -0.073846 -0.055385 -0.044615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29293.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503 1.0943 1.1383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29295.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0454]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29296.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1408 1.2136 1.2864 1.3592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29298.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1301 1.1791 1.2292 1.2783]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29299.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3585 1.0213 1.4182 1.0797 1.478 1.1394 1.5377]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29302.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0237 1.0523]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29304.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.05]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29305.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.028571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1069]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29310.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1859 1.495 1.2315 1.5406 1.2785 1.5876 1.015 1.3241 1.6346]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29314.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.159 1.1979 1.2359 1.0185 1.2749]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29316.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1715 1.2099 1.2483 1.0311 1.2868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29319.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1182 1.1545 1.192 1.2283]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29320.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.0417 1.0686 1.0956]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29322.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0994]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29324.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0113 1.0502]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29326.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29333.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1908 1.2671 1.3445 1.4208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2411 1.2924 1.3436 1.0532 1.3949]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29342.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011429 -0.011429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29346.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032857 -0.085714 -0.085714 -0.04]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0306 1.0731 1.1166]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29354.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1307 1.2527 1.376]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0841 1.1115 1.1399 1.1673]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29371.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1282 1.175 1.2218 1.2686]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29374.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.031 1.0762 1.1213 1.1665]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29377.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.0696]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29379.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1439 1.1745 1.2051 1.0327 1.2357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1057 1.1986 1.1764 1.0464 1.0943 1.1757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29382.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0199 1.0778]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29383.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.034 1.0569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29387.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0485 1.0762 1.1039 1.1316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29388.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.6523 1.014]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29395.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0466]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29396.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29399.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29403.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.038571 -0.031429 -0.19286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29407.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0315 1.0655 1.0996 1.1336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29410.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.05 1.0362 1.0415 1.0792 1.22 1.2831]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0485 1.0926 1.1357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29421.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1741 1.2031 1.0375 1.2322 1.0665 1.2624]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29426.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1954 1.2682 1.3423 1.4151]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29434.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2915 1.0869]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29437.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0884 1.2055 1.3225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29444.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0885 1.1233 1.1595 1.1944]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29445.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0316 1.0563]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0303 1.0561 1.0818 1.1085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29447.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29448.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0207]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.025 1.0513]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29454.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1191 1.1681 1.217 1.266]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29461.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1073 1.1435 1.1797 1.2158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29464.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0707 1.0236]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29465.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0638 1.1939 1.3241 1.453]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29469.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0238 1.0556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29473.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0942 1.1395 1.1847 1.23]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29476.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0566 1.1604]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29486.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0695 1.0981 1.1268 1.1544]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.038 1.0996 1.1612]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29500.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0126]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29501.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2056 1.2463 1.0188 1.286 1.0595 1.3267]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29511.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.36769 -0.024615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29512.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0667 1.1118 1.1569 1.2019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29513.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1924 1.2321 1.2707 1.0471 1.3104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29520.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0946 1.1307 1.1668 1.203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29522.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1523 1.1834 1.2145 1.0383 1.2446]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29526.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0835 1.1194 1.1562 1.1921]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29527.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0724 1.1184 1.1644 1.2104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29528.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29529.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0175]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29535.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.010769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29538.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0216 1.0545 1.0873]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29546.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0124 1.0569 1.1004 1.1449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29548.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.037 1.068]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29549.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.017 1.0509 1.084 1.1179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29550.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0342 1.0662 1.0983]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29551.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3873 1.0443 1.4468 1.1037 1.5076 1.1646 1.5685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29554.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.1314 2.1314 1.2679 2.315]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3444 1.0115 1.4033 1.0704 1.4622 1.1293 1.5211]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29563.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1436 1.2834 1.4217 1.5616]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29566.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2238 1.0401 1.2569 1.0718 1.2887 1.105 1.3218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29576.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0661]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29578.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 8.15 1.1164 3.2307 3.0679 8.155 3.065 3.9029 8.6236 1.0193 4.0664 4.8214 8.8564 1.3843 4.2321 5.4886]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29580.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0276 1.0704 1.1146 1.1588]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29581.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7536 2.0657 2.4157 1.9129 1.0225 1.0636]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29589.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29591.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0403 1.0988]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29593.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.43 1.5208 1.6131 1.0977 1.7038]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29595.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.09]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29598.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1474 1.1985 1.2485 1.2985]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29600.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1995 1.2392 1.0149 1.2776 1.0545 1.3172]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29609.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0694 1.2995 1.1038 1.3351 1.1382 1.3695 1.1726 1.4039]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29613.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.015385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29614.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0557 1.0899 1.1242 1.1595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29615.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0603 1.1072 1.153 1.1999]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29616.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29627.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0236]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29628.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0109 1.0349]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29630.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0463 1.0879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29632.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.022857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29640.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1066 1.4216 1.1533 1.4695 1.2012 1.5162 1.2491 1.5641]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1223 1.1525 1.1813 1.0137 1.2115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29645.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0213]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29647.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.057 1.2675 1.0892 1.2986 1.1203 1.3308 1.1513 1.3619]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29651.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1651 1.2015 1.2379 1.0289 1.2755]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29652.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0739 1.1031 1.1313 1.1605]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29653.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0334 1.4562 1.096 1.5202 1.1599 1.5828 1.2239 1.6467]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29654.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0108 1.0411]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29656.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0617 1.0961 1.1317 1.1672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29660.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0246 1.0568 1.0899 1.122]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29671.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1402 1.1903 1.2404 1.2894]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29677.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0907 1.1385 1.1863 1.2341]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29679.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1934 1.0206 1.2236 1.0508 1.2538 1.0809 1.284]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29680.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1567 1.1859 1.0234 1.2138 1.0527 1.243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29683.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2973 1.3541 1.0338 1.4095 1.0905 1.4662]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29686.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0627 1.3403 1.1045 1.3821 1.1463 1.4239 1.1881 1.4657]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29687.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.039 1.2579 1.072 1.2894 1.1034 1.3223 1.1364 1.3553]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29688.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.54429 -0.088571 -0.52429 -0.15286 -0.14714 -0.085714 -0.044286 -0.06 -0.057143 -0.26857 -0.31571 -0.45714 -0.17 -0.52429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29689.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2321 1.2849 1.3388 1.0363 1.3927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29691.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0149 1.0478 1.0797]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29692.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0321 1.095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29693.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 54320 1.5127e+06 27395 34477 36842 4.3885e+05 1.959e+09]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29694.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027143 -0.021429 -0.011429 -0.011429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29697.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0567 1.1135 1.1702]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29704.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0165 1.0574 1.0972]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29707.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1128 1.3539 1.1483 1.3906 1.185 1.4272 1.2217 1.4628]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29710.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.031 1.0931 1.1552 1.2172]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29712.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29715.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0735 1.3039 1.1083 1.3387 1.1432 1.3736 1.1781 1.4072]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29719.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8785 1.8792 1.8785 1.0349 1.0901]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29724.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.056 1.1833 1.3106 1.4379]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29732.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.028 1.0599 1.0919]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29733.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.021 1.0519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29737.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1112 1.3519 1.1475 1.3881 1.1838 1.4244 1.2201 1.4595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29738.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1154 1.0292 1.07]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29739.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.28923 -0.30769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29745.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29749.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0818 1.1176 1.1535 1.1894]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29760.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0278 1.0612 1.0937]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29761.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0213 1.049 1.0756 1.1033]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29764.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29765.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0357 1.1487 1.2618]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29771.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29772.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0692 1.0974 1.1256 1.1538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29775.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0282 1.4247 1.0874 1.4852 1.1478 1.5444 1.207 1.6035]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29777.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1587 1.2066 1.2557 1.3037]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29779.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0398 1.0739 1.107 1.1411]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29781.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0589 1.1031 1.1474 1.1906]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29782.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0704 1.0962 1.1221 1.1479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29783.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0807 1.1138 1.1468 1.1799]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29785.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0472 1.0893]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29786.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0356 1.0767]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29788.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0419 1.0749 1.1079]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29792.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0126]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29794.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0607 1.0107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0548 1.0828 1.1109 1.1389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29801.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0202 1.0465 1.0737]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29805.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0235 1.1166]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0228 1.1219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29811.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0401 1.082]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29813.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138 1.0547]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29819.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0187 1.0498]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29821.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2678 1.3179 1.0343 1.3681 1.0844 1.4182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29824.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0514 1.1864 1.1614 1.1157 1.17 1.2057 4.0407 3.5171 3.5014 4.2207 7.98 2.665]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29825.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0455 1.091 1.1365 1.182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29826.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.07]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29827.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.193 1.2418 1.2917 1.0102 1.3417]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29828.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3843 1.5757 1.6486 1.6779]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29830.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0307 1.063]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29835.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2804 1.049 1.3205 1.0891 1.3619 1.1305 1.402]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29847.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1018 1.1499 1.198 1.2461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29848.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2433 1.4944 1.0288 1.2812 1.5323 1.0666 1.3191 1.5701 1.1045 1.3555 1.608]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29852.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0415 1.0508 1.03 1.1531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29853.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.169 1.2005 1.0252 1.2308 1.0567 1.2623]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29860.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29861.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 6.2421 34.11 7.2229 25.42 8.4143 30.601 8.6093 30.682]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29862.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0432 1.0839 1.4662 1.1245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29865.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0267]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29866.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2106 1.2645 1.3175 1.0159 1.3704]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29867.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3697 1.03 1.4298 1.09 1.4898 1.1501 1.5498]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29870.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29877.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0224 1.0492 1.077 1.1039]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29880.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2485 1.12 1.8969 1.1038 1.2592 1.4338 1.7585 1.7431 1.6454 2.2254 2.5492 1.4192 1.0231 1.2577 1.6008 1.1023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29882.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0914 1.1276 1.1637 1.1999]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29886.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0994]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29890.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29894.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4857 2.0779 1.1129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29896.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0277 1.1513 1.2734 1.397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29903.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0494 1.0772 1.105 1.1328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29909.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0179 1.0424 1.068 1.0936]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29910.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0486 1.0436 1.055 1.0514]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29913.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0132 1.0547 1.0962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29915.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0199 1.1153]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29923.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1504 1.4525 1.1947 1.498 1.2402 1.5436 1.2529 1.2858 1.5892]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29924.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0298 1.0557 1.0815]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29925.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0641 1.2791 1.0965 1.3115 1.1289 1.3439 1.1613 1.3763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29933.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262 1.0538 1.0814 1.1089]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29935.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0529 1.0989 1.1449 1.1909]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29936.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29939.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0787]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29941.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2769 1.3327 1.0149 1.3898 1.0707 1.4455]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29943.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1894 1.2407 1.293 1.3453]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29944.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012308 -0.012308 -0.012308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29949.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0622 1.1256 1.1891]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29951.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0896 1.3252 1.125 1.3606 1.1593 1.3949 1.1947 1.4303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29952.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0551 1.1014 1.1464 1.1927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29960.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1731 1.2115 1.25 1.0316 1.2898]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29970.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0321 1.0569 1.0831 1.108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29971.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0591 1.0925 1.1273 1.162]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29974.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29983.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0525 1.1163 1.0364 1.1813 1.0257 1.2451]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29984.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.21714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29985.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0261]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29989.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.019 1.0531 1.0863 1.1205]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29991.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292 1.0568 1.0843 1.1119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/29999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0254 1.0709 1.1154 1.1609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30000.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.021429 -0.32571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30011.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.061538 -0.012308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30015.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2054 1.2837 1.3607 1.4377]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30026.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0478 1.325 1.0895 1.3668 1.1312 1.4071 1.1729 1.4489]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30029.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0193 1.0599 1.0995 1.1401]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30030.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.054 1.0819 1.1099 1.1378]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30033.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1125 1.1496 1.1868 1.2239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30036.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0195 1.1193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30037.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1969 1.6977 1.5323 1.1162 1.4369 2.4838 1.4454 1.2431 1.42 1.5977 1.3869 1.4815 1.7023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30038.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0571 1.0913 1.1255 1.1583]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30043.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30049.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6064 1.6071 1.6064]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30050.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30061.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1139 1.1469 1.1813 1.2156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30065.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.625 1.5086 1.455 3.8321 2.7343 3.1829 2.695 3.0821 4.73 2.76 3.5214 2.4343 4.3 4.6229 2.9736 2.5707 3.1036 1.13]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30066.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.06 1.1393 1.2371 1.2214 1.1629 1.16 1.025 1.0164 1.0693 1.0479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30077.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1934 1.2286 1.0246 1.265 1.0598 1.3013]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30078.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.096 1.1229 1.1508 1.1776]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30092.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0267 1.0712 1.1157 1.1602]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0397 1.0706 1.1014 1.1334]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30101.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0694 1.1056 1.1408 1.177]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30103.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0127 1.1184 1.2241]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30104.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0246 1.0671 1.1305 1.2365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30108.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0252]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30111.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1921 1.2439 1.2958 1.3476]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30116.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.2607 5.2521 6.7736 9.6443 10.456 9.1186]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30117.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.054]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30118.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0375 1.0705 1.1044 1.1374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0668 1.1129 1.1599 1.207]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30123.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0805]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30125.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0148 1.0562 1.0967]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30134.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 5.145 5.8407 6.2193 7.2136 5.955 6.5607 13.683 19.082 1.1079 1.1079 1.0307]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30135.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30140.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0241]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30147.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3643 1.027 1.4249 1.0863 1.4842 1.1456 1.5435]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30151.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5692 5.4554 1.4877 1.1429 1.6762 1.6862 4.2692 1.5115 1.1721 1.0762 1.83 4.9769 1.7231 1.2013 2.3046 1.8546 4.9869 1.8538 1.0355 1.2304 7.4185]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30153.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0347]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30155.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0598 1.0876 1.1154 1.1433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30157.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012857 -0.025714 -0.052857 -0.21 -0.042857 -0.30571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30158.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0426 1.0851 1.1277 1.1702]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30163.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.091429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30165.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0188 1.0524 1.0847 1.1171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30166.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1147 1.1635 1.2122 1.2598]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30171.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30172.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1508 1.1812 1.2117 1.0378 1.2431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0352]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30181.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30182.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0767 1.105 1.1345 1.1628]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0675 1.1029 1.1383 1.1726]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30185.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0311 1.0612 1.0914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30190.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30192.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0479 1.0892]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30195.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.049231 -0.027692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30197.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0149]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30198.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0814]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30199.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0818 1.5215 1.184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30202.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0318 1.0641 1.0973 1.1296]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30203.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.04]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30205.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0313]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30209.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0204 1.047 1.0729 1.0987]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30211.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0826 1.1281 1.1736 1.218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30213.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6564 1.9471 2.1807 2.4771]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30214.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.084 1.1119 1.1397 1.1676]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30216.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30218.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0452 1.3431 1.0904 1.3883 1.1343 1.4322 1.1795 1.4774]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30219.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0912 1.3248 1.1266 1.3602 1.1608 1.3957 1.1962 1.4311]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.044 1.0777 1.1114 1.1462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30223.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0692 1.0958 1.1224 1.1476]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30227.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0333 1.059 1.0848 1.1116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30228.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0717 1.4751 1.1328 1.5348 1.1925 1.5959 1.2536 1.6555]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30230.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2086 1.0367 1.2386 1.0678 1.2697 1.0978 1.2997]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0177 1.0484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30233.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.048571 -0.78857 -0.83286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30237.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.905 1.0194 6.7757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30238.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0364 1.0621]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30240.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.05 -0.051429 -0.042857 -0.028571 -0.081429 -0.032857 -0.012857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30246.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0492 1.3231 1.0906 1.3645 1.132 1.4058 1.1719 1.4472]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30252.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0102]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30257.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0946 1.1274 1.1602 1.1917]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30263.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0709 1.3016 1.106 1.3368 1.1401 1.3709 1.1753 1.406]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30264.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012857 -0.014286 -0.011429 -0.038571 -0.011429 -0.057143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30266.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1398 1.1698 1.1999 1.0284 1.23]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30269.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2305 1.0145 1.2695 1.0535 1.3074 1.0913 1.3452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30271.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.122 1.1523 1.1814 1.0115 1.2118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30272.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0868 1.1224 1.159 1.1946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30274.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30275.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0927 1.1406 1.1873 1.2352]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30278.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.083 1.1297 1.1764 1.2231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30280.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1709 1.2004 1.0339 1.2286 1.0634 1.258]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30288.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1089 1.1375 1.1673 1.1959]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30291.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0128 1.056 1.1002 1.1444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30295.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2056 1.2832 1.3594 1.4369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30296.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1075 1.1562 1.2038 1.2513]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30300.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0711 1.1357 1.1994]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30306.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3962 1.5315 1.0538 1.3108 1.3808]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30308.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0148 1.0406 1.0663 1.0921]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30310.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0815 1.1488 1.2172 1.2845]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30311.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.031 1.0572 1.082]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30314.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1489 1.4691 1.1972 1.5161 1.2454 1.5643 1.2936 1.6125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30315.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0299 1.0854]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30317.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30319.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503 1.0927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30328.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.139 1.1728 1.2065 1.014 1.2416]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30329.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0118 1.4297 1.0749 1.4928 1.138 1.5545 1.1997 1.6176]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30330.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.2862 7.25 6.4923 13.009 7.0492 5.7254 1.0225 1.4146 1.4877 1.6538 1.5823 1.5446 1.0469 1.5531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30332.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2236 1.4457 1.4143 1.2336 2.225 4.1479 1.0121 1.5329]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0574 1.2847 1.0915 1.3176 1.1256 1.3516 1.2692 1.1597 1.3857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30339.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0612 1.0967 1.1323 1.1678]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30340.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0928 1.1408 1.1878 1.2358]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30350.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.5514 11.697 1.93 8.3814 12.533 1.9857 2.4343 9.7343 10.75 2.1571 5.3757 9.1486 8.03 3.0086 9.1129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0344 1.2422 1.0655 1.2733 1.0965 1.3043 1.1275 1.3354]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30362.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1446 1.1746 1.2056 1.032 1.2355]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30363.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018462 -0.070769 -0.021538 -0.16462 -0.023077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30368.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0174 1.0512 1.0839 1.1167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30377.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0169 1.0427]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30378.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2016 1.021 1.2335 1.0529 1.2655 1.0848 1.2974]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2222 1.04 1.2547 1.0724 1.2871 1.1049 1.3184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30383.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1648 1.2023 1.2387 1.0314 1.2751]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30387.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.54429 -0.088571 -0.52429 -0.15286 -0.14714 -0.085714 -0.044286 -0.06 -0.057143 -0.26857 -0.31571 -0.45714 -0.17 -0.52429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30388.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2456 1.0135 1.2868 1.0548 1.3269 1.096 1.3681]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30390.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1528 1.2014 1.2488 1.2962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30391.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0453 1.1728 1.2989 1.4263]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30392.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.089 1.1372 1.1843 1.2325]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30394.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30396.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.048571 -0.074286 -0.04]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30399.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.044 1.2683 1.0774 1.3017 1.1109 1.3352 1.1444 1.3699]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30400.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0166 1.0773 1.139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30402.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027143 -0.041429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30404.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1196 1.1688 1.2168 1.2659]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30405.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0374 1.0723 1.1062 1.14]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30407.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.043 1.0705 1.098 1.1264]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4914 1.5436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30420.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2388 1.2796 1.0493 1.3204 1.0888 1.3612]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30425.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2098 1.2495 1.0231 1.2892 1.0628 1.3299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30426.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0584 1.1047 1.1511 1.1974]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30427.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0878 1.1159 1.1451 1.1744]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30428.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0507]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30430.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.054 1.0887 1.1233 1.1579]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30434.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0707]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30439.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0221 1.0483]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30440.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0308 1.0254 1.0353 1.0653]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30442.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1111 1.1403 1.1704 1.2006]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30444.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0596 1.1234 1.1872]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30448.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3407 1.0249 1.3972 1.08 1.4523 1.1364 1.5087]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30451.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0959 1.1328 1.1688 1.2057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30455.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0213 1.0629]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30456.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0173 1.0433 1.068]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30460.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1294 1.1785 1.2277 1.2768]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30462.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0517 1.0766 1.1028 1.129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0356 1.0694 1.1031 1.1369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30470.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.3579 1.515 1.0171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30473.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0707]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30474.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0382 1.0701]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30486.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0667 1.0934 1.1189 1.1456]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30488.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0339]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30500.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0329 1.0723]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0213 1.0541 1.087 1.1198]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30517.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1008 1.1376 1.173 1.2084]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30519.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0108 1.1189 1.2257]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30528.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1497 1.2245 1.2981 1.3729]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30530.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0565 1.4941 1.1222 1.5598 1.1879 1.6255 1.2536 1.6912]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30531.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1236 1.172 1.2214 1.2709]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30532.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2131 1.2662 1.318 1.0201 1.3711]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30538.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0647 1.1113 1.158 1.2047]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30551.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409 1.0743 1.1066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30556.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0122 1.0447 1.0772]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30572.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0469 1.1749 1.3042 1.4335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30573.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.408 1.4939 1.5798 1.092 1.6656]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30580.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1263 1.1623 1.1984 1.2335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30583.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0346]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30594.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7443 1.745 1.2179 1.7443 1.292 1.3647 1.4387]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30608.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.0421]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30611.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0487 1.3412 1.0919 1.3858 1.1365 1.429 1.1811 1.4735]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30613.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30616.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.010769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0837 1.3905 1.1294 1.4362 1.1762 1.4819 1.2219 1.5287]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30621.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.133 1.4548 1.1822 1.504 1.2301 1.5519 1.2779 1.5997]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30627.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30629.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.025 1.1721 1.4636 1.3436 2.0857 1.3029 1.0843]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30632.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0715 1.295 1.105 1.3285 1.1385 1.3609 1.1721 1.3944]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30640.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0311 1.0894]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30642.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1388 1.6116 1.2099 1.6827 1.281 1.7524 1.3522 1.8236]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30644.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1578 1.1964 1.2349 1.0172 1.2734]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30646.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0378]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30651.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30652.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.16286 -0.13571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30654.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30655.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0466]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30660.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0242 1.0514 1.0786 1.1057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30670.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0354 1.0803 1.1262 1.1712]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30672.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018571 -0.017143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30675.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.032 1.0569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30676.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30677.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0154 1.0557 1.0961]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30683.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1 1.1271 1.1553 1.1824]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30689.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0846 1.3904 1.1297 1.4367 1.1761 1.4818 1.2224 1.5282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30697.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3674 1.0404 1.4242 1.0985 1.4823 1.1553 1.5404]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30705.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0194 1.0454]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30709.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0507]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30711.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0464 1.0903 1.1332 1.1761]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30712.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0417 1.0865 1.1325 1.1774]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30715.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0329 1.2558 1.0664 1.2893 1.0999 1.3227 1.1334 1.3562]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30718.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0967 1.1446 1.1934 1.2413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30722.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.1 -0.13846 -0.16 -0.16154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30723.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.031 1.072 1.113 1.154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30724.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.116 1.1524 1.1889 1.2264]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30727.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1689 1.207 1.2463 1.0276 1.2844]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30735.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0979]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30737.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30739.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0568 1.1014 1.1449 1.1884]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30747.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2185 1.259 1.0315 1.2996 1.0709 1.3401]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30759.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1753 1.2066 1.0307 1.2379 1.0609 1.2681]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30762.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2103 1.4717 1.2484 1.5112 1.0263 1.2878 1.5493 1.0657 1.3272 1.5887]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30765.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041538 -0.033846 -0.20769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30766.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2674 1.3237 1.0105 1.3788 1.0655 1.4338]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0585 1.1646 1.2707]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30771.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0806 1.1281 1.1755 1.223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30776.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0524 1.0969 1.1404]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30778.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0678 1.1032 1.1374 1.1727]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30779.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.058 1.0919 1.1258 1.1597]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30782.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30786.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0431 1.09 1.0262 1.0385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30790.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1039 1.1518 1.1998 1.2477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30791.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0168 1.0486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.091]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30797.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1164 1.1524 1.1873 1.2222]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30801.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.02]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30802.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30804.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1489 1.1776 1.0144 1.2063 1.0431 1.2351]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30806.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0498]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30813.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2219 1.2749 1.3279 1.0252 1.3821]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30815.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30817.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0387 1.0796 1.1219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30820.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1122 1.2145]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30824.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0126 1.1091]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 7.7714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30839.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0699 1.1303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30840.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0156 1.0771 1.1375]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1274 1.4313 1.1728 1.4767 1.2182 1.5221 1.2636 1.5675]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30846.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0685 1.0977 1.1259 1.1541]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30847.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0304 1.0632 1.0972 1.1312]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30849.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0461 1.0918 1.1374 1.1831]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30855.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0168 1.0503 1.0838 1.1173]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30859.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0484 1.1123 1.1763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30862.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8785 1.8792 1.8785 1.0252]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30865.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1402 1.1704 1.2006 1.028 1.2319]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30868.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1023 1.3906 1.6776 1.1463 1.4332 1.7202 1.1889 1.4759 1.7642 1.2315 1.5199 1.8068]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30870.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0249]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30874.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0123 1.0762 1.14 1.2052]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30883.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0558 1.0842 1.1126 1.141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30884.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0942 1.123 1.1518 1.1816]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30885.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0224 1.1404 1.2571 1.3752]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30888.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0397 1.0114 1.205 1.2964 1.1921 1.0654 3.5264 3.7079 1.7757 1.6979 1.6607 1.09 1.34 1.7514 2.24 2.6657 1.7993 1.4929 1.1157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30894.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0673 1.1029 1.1385 1.1741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30898.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157 1.0472]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30902.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0646 1.1104 1.1575 1.2032]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30904.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.025714 -0.027143 -0.012857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0293 1.0878]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30907.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.051 1.0929]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30910.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0237]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30913.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0161 1.0568 1.0974]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30914.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0232 1.1364 1.2497 1.3629]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30917.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2348 1.2764 1.0438 1.3169 1.0854 1.3584]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30920.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0779]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30925.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0424 1.087 1.1317 1.1763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30931.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0987 1.1436 1.1894 1.2353]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30936.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0437]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30938.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0727 1.1073 1.142 1.1766]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30939.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30942.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0455 1.0919 1.1374 1.1839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30943.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.031429 -0.024286 -0.015714 -0.027143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30956.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2813 1.0414 1.3239 1.0839 1.3664 1.1265 1.409]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30961.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0907 1.3614 1.25 1.9386 1.2121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30965.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.165 1.1946 1.0226 1.2257 1.0522 1.2567]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30967.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0568 1.0852 1.1123 1.1407]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30969.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0192 1.1371 1.255 1.3728]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30974.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0258 1.2442 1.0583 1.2768 1.0909 1.3094 1.1235 1.3433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30980.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.146 1.1929 1.241 1.2879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30982.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262 1.0644]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30990.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.037 1.0708 1.1047 1.1395]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/30999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0847 1.155 1.2252 1.2955]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31001.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 8.0871 4.9443 4.5179 9.6921 4.59 6.0379 6.8414 13.096 7.6136 8.8914 5.6086 3.6607 2.8793 3.185 3.0193 3.7764 3.3964 3.67 1.2093 1.07 2.405]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31002.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0284 1.0932 1.1591 1.2251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0233 1.0555]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31006.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0253]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31012.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.055714 -0.33714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31013.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0431 1.0766 1.11]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31021.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.7257 3.24 3.8814 3.7407]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31022.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0375 1.0809 1.1243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31029.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0916 1.1267 1.1618 1.1979]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31030.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0126]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31031.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0258 1.0585 1.0913]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31041.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0332 1.0599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1049 1.3407 1.14 1.3758 1.1752 1.411 1.2115 1.4473]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31051.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.0522 1.0938]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31062.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0891 1.1368 1.1844 1.2321]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31065.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2233 1.2767 1.3312 1.0278 1.3845]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31067.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.269 1.3241 1.3793 1.0656 1.4344]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31068.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0379 1.078]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0328 1.0741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31074.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196 1.0767]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31076.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0469 1.0898]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31081.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0293 1.0561 1.0838 1.1106]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31086.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3055 1.3594 1.0513 1.4133 1.1053 1.4685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31087.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2161 1.0407 1.2474 1.071 1.2777 1.0436 1.1023 1.309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31088.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.044 1.0757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31094.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0496]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31097.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0473 1.0893]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1614]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31104.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0206]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31107.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0136 1.0389 1.0643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31111.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0645 1.1114 1.1574 1.2043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31116.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2235 1.2765 1.3295 1.0292 1.3825]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31117.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0977 1.1265 1.1565 1.1853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31120.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0405 1.0726 1.1036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31122.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5454 1.6123 1.2485 2.2115 2.8062]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31128.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0378 1.0814 1.125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31129.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0233 1.0653 1.1072 1.1492]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31130.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0273 1.0684]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31134.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0166]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31135.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0186 1.0445]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31137.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2586 1.2736 1.1579 1.0564 1.61 1.805 1.9864 1.8493 1.9893 2.0014 1.3571 1.1621 1.7979 2.1079 2.7214 4.1279]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31138.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0586 1.1864 1.2579]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31139.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0378 1.2609 1.0708 1.294 1.1051 1.3282 1.1381 1.3613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31140.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0681 1.1692 1.2718]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31141.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0201 1.0456 1.0703]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31153.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0546 1.1112]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31157.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.049]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31160.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138 1.2232 1.0457 1.254 1.0765 1.2859 1.1084 1.3167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31161.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.139 1.189 1.239 1.289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31162.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0173 1.0501 1.0819]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31169.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0688]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31172.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0183 1.0593]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31173.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1156 1.3361 1.1483 1.3687 1.181 1.4014 1.2136 1.434]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31177.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0524 1.0941]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31178.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1065 1.1528 1.1991 1.2454]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31179.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2402 1.0223 1.2793 1.0615 1.317 1.0992 1.3561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31182.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0233]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31183.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1987 1.0308 1.2285 1.0606 1.2582 1.0903 1.288]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31186.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0722 1.108 1.1428 1.1786]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31187.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0323 1.1]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31188.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.034286 -0.051429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31194.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.239 1.293 1.3469 1.042 1.4009]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31203.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1777 1.2294 1.2822 1.3339]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31205.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0187 1.2396 1.0521 1.2729 1.0854 1.3062 1.1177 1.3396]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31208.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0697 1.1394 1.2081 1.2768]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31209.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1159 1.3466 1.15 1.3807 1.1852 1.4148 1.2193 1.45]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31210.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0164]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31211.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0151 1.2832 1.0545 1.3226 1.0953 1.3633 1.136 1.4041]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31216.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0873 1.1218 1.1564 1.1909]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0836 1.1186 1.1129 1.1535 1.1884]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0124 1.0522]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31240.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1369 1.1747 1.2125 1.2491]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31245.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31246.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0444 1.1523 1.2602]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31247.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2097 1.4587 1.2463 1.4966 1.0352 1.2842 1.5332 1.0731 1.3221 1.571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31251.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0166 1.0613 1.1049 1.1485]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31252.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0255 1.0657 1.1059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31255.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1184 1.3471 1.1534 1.3821 1.1873 1.416 1.2223 1.451]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31256.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.145 1.1924 1.2397 1.287]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31257.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.024286 -0.03]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31260.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.19 -0.037143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31263.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0239 1.0583 1.0916 1.1259]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31268.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0188 1.0584]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31269.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1072 1.1425 1.1778 1.2131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31272.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1414 1.18 1.2177 1.2553]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31278.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0273]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31280.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.136 1.2608 1.3844 1.5092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31282.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0273]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31285.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0604 1.2808 1.0936 1.314 1.1268 1.3472 1.16 1.3803]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31289.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0173 1.1277 1.2382]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31290.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0335 1.0745 1.1145 1.1555]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31294.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0224 1.0874 1.1536 1.2186]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31298.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1007 1.1262 1.1518 1.1773]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31299.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.0429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31306.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1606 1.1968 1.233 1.0274 1.2691]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31311.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1806 1.2282 1.2769 1.3256]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31319.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.025714 -0.15286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31320.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214 1.062]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31323.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.017143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31326.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.021 1.063 1.105]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31328.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31334.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1069 1.0462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31336.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0146 1.0465 1.0775]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0234]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31341.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0215 1.0645 1.1064]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31343.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 16.435 18.313 21.965 3.1354]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31345.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0175 1.0605 1.1023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2521 1.0193 1.2934 1.0606 1.3347 1.1019 1.3747]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31351.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0391 1.082 1.125 1.168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31354.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.025714 -0.29429 -0.17 -0.13571 -0.14571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31360.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0263 1.0845]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31361.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0541]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31365.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.024286 -0.03 -0.014286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31366.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0342 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31368.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0134]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31372.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31383.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0122 1.4292 1.0753 1.491 1.1371 1.5541 1.2001 1.6158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31384.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032857 -0.021429 -0.015714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31386.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.085714 -0.094286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31387.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0224 1.0482 1.074]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31394.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31398.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0769 1.1804]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31403.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0158 1.0503 1.0838 1.1173]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31412.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0327]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31414.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2038 1.5497 1.2556 1.6001 1.3074 1.652 1.0147 1.3592 1.7038]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31417.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0846 1.3929 1.131 1.438 1.1773 1.4843 1.2224 1.5307]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31421.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0486 1.0925 1.1365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31423.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1257 1.1807]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31425.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0489 1.0837 1.1174 1.1521]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31427.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2463 1.0125 1.2883 1.0533 1.3292 1.0953 1.3712]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31435.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2364 1.2909 1.3441 1.0406 1.3972]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31441.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.52769 -0.013846 -0.012308 -0.10308 -0.08 -0.13385 -0.012308 -0.016923 -0.20769 -0.018462 -0.021538 -0.10308 -0.016923 -0.018462 -0.026154 -0.13385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31442.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2971 1.3542 1.0341 1.4101 1.0912 1.4659]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31443.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0912]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31444.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0442 1.0789 1.1137 1.1494]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31450.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0488]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0208 1.1207]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31463.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0204]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31465.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0111 1.0448 1.0775 1.1112]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0166 1.059 1.1023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31470.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0333 1.0711]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31473.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0296]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31485.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1306 1.3607 1.1655 1.3943 1.2005 1.4293 1.2342 1.4643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31486.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0708 1.1054 1.141 1.1767]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31493.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0762]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31496.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1589 1.189 1.0145 1.2201 1.0447 1.2513]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0504 1.0864 1.1214 1.1563]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31499.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.038571 -0.038571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1382 1.6921 1.1741 1.2099 1.2458]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31508.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6754]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31510.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0871 1.1347 1.181 1.2272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31519.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1906 1.2281 1.0156 1.2656 1.0531 1.3042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31520.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1463 1.1841 1.2219 1.2585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31522.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0981 1.1333 1.1698 1.205]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31524.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.084286 -0.22 -0.011429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31525.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.054 1.0975 1.1419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31526.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3285 1.3185 2.3154 1.7269 1.4454 1.022]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31543.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31545.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0682 1.1011 1.1341 1.1679]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31551.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0865 1.116 1.1445 1.1741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31553.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0425 1.0885 1.1344 1.1804]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31554.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.112 1.1457 1.1779 1.2117]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 9.665 12.356 19.173 17.871 5.9729 6.4157 6.1129 7.3021 1895.9 2273.5 2818 4037.3]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31559.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1066 1.1362 1.1649 1.1946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31565.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 5.3614]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31566.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0164]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31568.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1312 1.3626 1.1658 1.3973 1.2005 1.4319 1.2351 1.4666]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31574.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0485 1.0315 1.0245 1.1292 1.2154 1.0509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31580.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0322 1.0947 1.1564]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31584.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2098 1.2477 1.0579 1.0328 1.2856 1.0707 1.3236]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31588.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0595 1.1031 1.1466 1.1902]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31612.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326 1.2428 1.0636 1.2738 1.0957 1.3059 1.1267 1.3368]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31616.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31620.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0465 1.0891 1.1316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31622.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.024 1.0686 1.114 1.1585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31626.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3118 1.3688 1.0447 1.4257 1.1016 1.4837]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31631.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.045714 -0.05 -0.057143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31633.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.169 1.3011 1.4347 1.5668]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31638.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0491]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 296.24 283.02 273.26 288.51 302.32 14.004 23.713 22.178 30.727 32.329 2.9921]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31651.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1974 1.2369 1.0128 1.2764 1.0523 1.3159]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31655.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0638 1.6523 1.0223 1.0362]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31656.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1778 1.2092 1.0319 1.2405 1.0632 1.2708]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31661.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4177 1.5085 1.6008 1.0854 1.6915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31670.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.031]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31671.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041429 -0.061429 -0.075714 -0.048571 -0.11143 -0.05 -0.23143 -0.43286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31677.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.071 1.1754 1.2783]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31680.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1955 1.2714 1.3474 1.4233]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31682.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0369 1.0692 1.1003 1.1326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31690.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0254]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31691.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0232 1.0557]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31692.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0864 1.1093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31696.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1327 1.1797 1.2257 1.2717]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31697.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.034286 -0.027143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31699.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2523 1.0309 1.2909 1.0708 1.3295 1.1094 1.3681]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31700.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.24429 -0.12 -0.047143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31714.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.052 1.0955]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31715.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.0938 10.106 10.903 11.251 3.4377 8.4815 5.3615 1.6715 1.4354 1.4669 1.1377 1.2592 1.1715 1.3146 1.5008 2.1762 3.8338 1.2308 1.0869 1.1454]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31718.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0517 1.0945]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31722.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0451 1.2535 1.0757 1.2854 1.1076 1.316 1.1396 1.3479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31726.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1044 1.2244 1.3431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31728.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31732.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0457 1.0868 1.129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31735.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0701 1.0981 1.1262 1.1542]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31738.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0369 1.0794]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31742.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 5.0286 92.707 22.199 13.875]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31743.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1878]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31745.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31748.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2824]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31749.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0115 1.4095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31750.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0613 1.282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31753.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31755.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2762]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31762.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0828]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31764.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1696]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31766.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31772.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31774.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157 1.4049 1.7942]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31776.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1047]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31777.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2767]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31778.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31782.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31785.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31791.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31794.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0996]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31798.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31800.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31802.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.31]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31803.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31804.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.5969 1.0846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31806.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2313 1.7254]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31810.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.044615 -0.12769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31812.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31814.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.06]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31815.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0388]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31817.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1679]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31818.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1876]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31824.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0866]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31825.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2888]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31827.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3203 25.125 1.6735]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0281]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31830.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0889]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31832.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0581]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31833.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0933]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31835.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31836.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1999]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31837.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0144 1.3032]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31839.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.7657e+07 1.4868e+09 3.4396e+08 2.0072e+05]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31840.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2781]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31844.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0323 1.328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1759]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31846.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31848.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31852.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31854.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31863.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0658]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31867.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31868.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0447]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31870.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2425]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31871.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31872.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.038 1.3354]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31880.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31882.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3369 1.7092 2.2031]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31883.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0474]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31884.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2212]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31885.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31887.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.051]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31890.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31893.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3656]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31895.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2154 1.0105 1.2187]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31897.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0724]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31899.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31901.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1331]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31903.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31904.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31906.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0144]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31909.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1377]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31913.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0787 1.3716]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31917.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.88 1.4623]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31918.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0264 1.2532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31919.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 14.569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31921.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1631]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31922.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31925.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0459 1.272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31929.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0854]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31931.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0373]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31934.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1538 1.1992]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31936.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31937.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0725]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31939.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.19846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31940.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0689 1.2945]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31943.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31945.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31946.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.5969 4.9 9.5415 3.8185 4.7646]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31947.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1813]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31955.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0313]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31956.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31960.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0909]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31962.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0341]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31966.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0381]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31967.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0482]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31968.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1407]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31969.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.17077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31974.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3067]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31975.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31977.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0712 1.3016]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31978.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503 1.3483]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31981.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1574]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31982.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31983.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31984.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1349]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31985.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31988.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2794]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31992.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1997]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31995.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0348]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31998.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/31999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7931 1.0311 1.326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32003.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0737 1.3566 1.638]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1379 1.3733]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32006.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1151]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32007.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2376]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32008.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0398 1.2548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32009.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0101 1.2307]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32011.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32014.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1775]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32015.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32016.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32017.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32020.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32024.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 9.3792 5.5808]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32026.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2619]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32031.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1138 4.7292 1.0698]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32032.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3444 1.7038]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32033.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32034.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0274 1.316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32035.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32038.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0729]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32040.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32043.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1432]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32045.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2629]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32047.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32048.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1604]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32049.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.06]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32051.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2669]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32052.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1308 1.153 1.3838]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32055.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0261]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32057.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32059.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.081]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32063.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.2023 117.22]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32070.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32074.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0164]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32079.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0726]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32081.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32085.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32087.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32088.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.2421]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32092.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0545]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32094.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2423]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32101.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0772]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32103.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2887]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32111.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32114.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1579]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32128.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32131.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1791]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32133.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32134.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2087]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32137.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0871]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32138.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0363]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32140.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3124]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32141.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.015 1.3044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32147.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1287]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32148.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0814 1.3168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32150.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3773]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32151.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1364]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32152.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2511]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32153.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0986]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0248]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32162.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32165.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0725 1.2978]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32166.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0953]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32167.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.26308 -0.030769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32174.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32177.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1469]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1087]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32185.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2148]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32186.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3288]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32191.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2522 1.6091]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32193.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0998 1.3397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32194.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32196.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.017]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32204.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0865]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32206.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1391]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32210.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32212.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32213.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32222.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0238]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32223.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32224.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1377]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.204]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1151]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32237.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0613 1.2923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32238.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1745]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32239.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2884]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32241.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1931]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32244.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32245.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32249.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0725]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32255.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2508]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32259.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2706]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32260.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1008]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32266.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32270.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.24]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32273.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1099]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32276.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0325]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32279.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0349]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32281.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32282.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2602]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32284.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2257 1.5788]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32285.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.056]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32290.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1813]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2669]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32294.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.03]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32300.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.029]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32305.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2388]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2423]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1358]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32310.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2464]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32311.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3425 1.7303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32315.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3572 1.7438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32318.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2725]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32321.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3293]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32325.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1804]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32326.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1833]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32327.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32328.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32330.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.059 1.2894]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32332.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2046 1.1506 2.6923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32341.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2976]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32344.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32346.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0795]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.109]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32353.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32354.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0392]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32357.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0967 1.3245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 8.9062 14.871 11.868 1.8492 2.0108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32360.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2304]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32365.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32372.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3242]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32373.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1789 1.4326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32377.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1373]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32378.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1355]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.064 1.2956]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32381.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.302]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32383.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2656]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32385.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1204]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32386.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3283]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32389.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1993]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32391.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32392.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0943]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32396.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32407.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0863]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1732]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32414.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1515 1.86 1.1096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32417.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0956 1.3265]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32418.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.198]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32421.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32422.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32426.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.1277 2.6446]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32427.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.094]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32432.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32438.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1692 1.4225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32442.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 17848 24.725 40580]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32443.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0598]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32447.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1641]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32452.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0807]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0999 1.5673]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32454.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4285 1.0562]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32456.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1647]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32457.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0768 1.5288]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32470.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1718]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32472.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1988]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32474.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0356]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32477.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0205]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32478.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.263]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32482.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0825]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32483.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4285 1.8808 2.37]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32484.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.244]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32486.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0987]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32502.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.08]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0302]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32506.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32508.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0188]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32511.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2489]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32512.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0502]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32514.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5585 1.0385 1.2246 1.62]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32521.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32523.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0133 1.2343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32524.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4254 1.2469 1.0149 1.2943]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32528.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32529.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0128 1.3019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32532.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1311]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0363]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32535.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0784]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32537.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1047]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32540.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0589]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32541.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.26461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32542.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32545.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1667]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32550.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32551.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32552.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0165]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32559.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32560.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32564.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.8508 2.4431 2.5169 4.3292 1.7077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32566.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0703]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32575.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2922]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32576.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0855 1.3858 1.6861]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32577.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3989]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32579.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32580.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3199]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32582.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0745]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32588.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1435]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32593.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2539]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32595.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0888]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32597.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262 1.252]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32598.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2838 4.63 2.35]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32600.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0475]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32603.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0832 1.3175]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32607.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32610.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1799]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32611.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32612.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32614.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2626]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32619.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.094]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32624.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0265 1.3206]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32627.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.255 1.5949]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32628.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32630.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0952]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32633.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2615 1.4262 1.0408 1.6154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32634.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.06 1.2857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32642.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.091 1.3237]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32646.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0854]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32648.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1809]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32649.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0842]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32650.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0568]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32651.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2132]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32653.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1797]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32654.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2816]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32656.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0293 1.2397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32660.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32663.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0904]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32664.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2329]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32668.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0779]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32671.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0264]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32678.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32680.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0319]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32681.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32683.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32688.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32689.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32691.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0608 1.2788]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32692.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2334 1.5657]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32693.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32696.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32700.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32701.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2685 2.1262 1.1319 1.8792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32702.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32707.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0534]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32708.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0647 1.2964]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32709.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1056]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32710.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32713.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0246 3.3338 2.8292 2.82 1.1226 3.7092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32714.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32717.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32722.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32727.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1725]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32730.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32732.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32733.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0645 1.3698]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32734.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1643 1.4817]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32741.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1552]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32750.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027692 -0.024615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32756.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1567]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32758.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32763.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0283]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32764.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1565]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0574]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32774.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1354 1.118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1102]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32783.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32786.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1633]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32789.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32791.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0481]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32792.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 14.426 5.6569 5.8108 4.1831]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32794.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2931]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2623]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32797.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32800.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0285 1.2531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32801.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1699 1.6678]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32802.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32806.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32808.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1478]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32809.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0401 1.2555]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32811.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0198]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32812.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.9501e+05 1083.2 4424.8 1.1423]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32815.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2183]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32817.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0731]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32821.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3616]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32823.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1916]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32827.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503 1.3523]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32828.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1294]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1937]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32832.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32833.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6459]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32834.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1869]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32838.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1126 1.4267]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0716]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32848.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32851.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0619]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32855.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32858.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0118 1.2291]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32859.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32862.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32865.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3213]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32867.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32868.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0266 1.2481]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32869.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.152]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32871.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1641]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32880.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2126]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32881.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1768]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32884.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2041]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32885.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32886.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2105 1.6862]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32887.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32890.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0135 1.2365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32895.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0762]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32896.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 17.928 23.891 5.0692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32897.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0396]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32903.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0744]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32904.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.9123 2.9062 1.2586]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32906.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32908.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2232]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32909.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5123 3.0646 2.6369 3.5354 2.5492]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32910.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1375]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32911.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2205]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32924.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.21]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1394]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32928.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0135]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32929.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0535]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32932.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.3554 1.1033 2.7992]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32935.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32937.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.013 1.2321]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32938.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32939.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.27385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32940.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2209]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32941.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.075]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32944.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0878]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32946.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0632]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32948.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.201]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32951.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32954.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2174 1.6966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32955.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32957.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32958.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.3045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32960.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2819]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32962.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1406]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32966.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32968.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32972.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1546]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32973.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.1092 1.0419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32975.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0282 1.2481]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32977.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32978.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32982.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32987.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0425 1.3427]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32988.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2868 1.5646]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32989.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2646]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32993.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.016]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/32999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0774]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1233]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33007.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33013.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33015.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1399]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0117]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33021.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1591]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33025.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33026.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33030.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0734]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33036.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.017]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33037.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0713 1.3042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33040.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1913]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33042.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33043.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1384]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1552]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33045.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2785 1.5563]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33049.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33051.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.322]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33054.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33057.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1919]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33062.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1501]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33064.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0267]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33068.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 6.2474e+13 1.3194e+15 1.1858e+08 2.3716e+08]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33070.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33071.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1727 1.5116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33073.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1063]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33075.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6038 1.0169 1.0392 1.1417 1.1685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33077.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1701]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33081.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 61.175 1.8885]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33085.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33089.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2805]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33091.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1325 1.4398]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33100.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33117.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0986]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33119.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 8.6354 22.7 9.6031]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0351 1.3216]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33122.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33128.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3779]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33129.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.036923 -0.018462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33131.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0281 1.2509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33136.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33138.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0542]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33145.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0511]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33149.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0473 1.2755]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33154.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0279]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33157.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0358 1.335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1821]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33163.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33167.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33168.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1977 1.5422]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33172.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0155 1.3082]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33181.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1154 1.0238]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0847]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33186.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33193.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33197.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33200.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0659]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33205.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33206.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2459]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33208.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2306]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33210.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1903]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33211.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2078 1.5554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33213.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1593]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33229.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33238.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33239.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33241.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0753]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33243.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1099]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33246.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0529]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33249.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0807]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33253.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1991]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33254.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0958]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33256.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0458 1.3442]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33258.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0319]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33263.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0755]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33265.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2788]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33269.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33270.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33272.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0408]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33274.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33275.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3677]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33277.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33278.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0472]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33279.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1544]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33281.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2187 1.7309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33286.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0323 1.3276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33287.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.7092 1.2031 1.1231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33288.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1626]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33290.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1695 1.5059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33298.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33299.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0589 1.4962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33301.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0997]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33302.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33304.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1213]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33305.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1673 1.4021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2035 1.7085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33308.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1089]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0958]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33313.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0305]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33314.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1579]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33322.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1228]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33323.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0942]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33324.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33329.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33330.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2851 1.5643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33334.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1943]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33335.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0583]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33336.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0843]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7992]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33339.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33344.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33346.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2277]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33347.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0922]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0394]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33351.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7415]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33352.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33353.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33354.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2296]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33355.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3838 1.7811]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33358.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1083]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33360.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33362.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 16.311 25.282 851.42 818.8]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33366.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1753]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33368.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0581]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33373.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0384]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33375.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.269 1.5486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33378.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.05]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33382.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0952]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33388.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0764]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33393.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0652 1.3702]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33395.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33397.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2379]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33398.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33399.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/334.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33408.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33416.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0113]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33417.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33422.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1525]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33431.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0983]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33433.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33434.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0791]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33436.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2313 1.0662]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33437.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33442.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2885]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33443.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33445.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2122]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3482]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33449.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33450.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2889 1.6612]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33451.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0679 1.3552]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33456.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0815 1.378]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33459.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1189]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33460.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33470.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0795]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33472.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33476.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33479.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1973]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33481.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3177 1.2615 1.1225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33482.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1969]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33485.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33487.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4074]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33489.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0664]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33493.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1076]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33495.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33497.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.073]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0248 1.3077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33506.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.196 1.5365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33510.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3014 1.6636]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33511.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0422]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33516.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0463 1.2634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33517.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33518.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0859]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33519.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0957]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33524.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.252]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33526.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1321]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33530.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0626 1.2833]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33537.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0231 1.2396]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33538.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2786]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1033 1.3413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33540.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33545.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1184 1.5864]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33546.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33555.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1209]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 5.4246 3.4515 2.9254]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33561.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33564.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0749]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33570.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0734 1.3066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33571.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0902]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33572.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2009]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33574.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2291]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33576.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0644]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33579.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33584.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33585.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1098]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0105]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33590.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33591.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0709 1.3793]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33596.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.132 1.3773]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33597.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0694]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33599.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0496]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33607.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2397 1.5096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33609.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0304]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33612.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1869]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2466]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33625.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33630.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33633.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.043077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33639.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33641.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33642.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0159 1.2403]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/33648.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0263]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/4502.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5575.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1387 1.1447]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5576.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1111]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5579.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0336 1.0336 1.0297 1.0326 1.0441 1.048 1.0547 1.0614]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2139 1.1584 1.089 1.0197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5594.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.078394 -0.09369 -0.07457 -0.14436 -0.012428]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5595.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.44417 -1.0008 -0.34719 -0.80685 -0.64874 -1.4099 -1.185 -2.4825 -0.18989 -0.49226 -0.02282 -0.15811 -0.18337 -0.47922 -0.34963 -0.81174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5601.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 23.362 46.353 23.379 46.387 23.362 46.353 1.9924 3.6138 1.0939 1.5917 2.8123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5602.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.14357 -0.02991 -0.14756]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5606.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032356 -0.022245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5607.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.010085 -0.010085 -0.15361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5608.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.087025 -0.043513 -0.2943 -0.69779 -0.14676 -0.40269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5609.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5612.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0379 1.1416]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5617.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1153]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5619.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 5687.8 11375 101.25 202.3 215.78 431.36 742.27 1484.4 5276.3 10552 60.238 120.28 2.2043 4.2125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5621.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0591]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5635.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0798 1.1376 1.0277]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5639.png: ignoring corrupt image/label: negative class labels or coordinate [ -12.366 -24.884 -13.581 -27.312 -18.491 -37.134 -22.641 -45.433 -1.5707 -3.2928 -5.4309 -11.013 -4.3273 -8.8059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5642.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.039278 -0.11465 -0.019108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5644.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0277 1.0138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5649.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.025869 -0.16879 -0.025869 -0.16879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5651.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0312]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5656.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0539]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5657.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1007]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5662.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.069238 -0.069733 -0.45796]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5667.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5674.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0773 1.0773]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5692.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5700.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0414]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5701.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.15552 -0.14075 -0.68115 -0.034752 -8.3354 -17.07 -0.066898 -0.64466 -1.689]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5716.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2441 1.1191 1.1279 1.1029]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5720.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1782 1.0839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5723.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.016713 -0.096565 -0.042711 -0.015785 -0.20613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5741.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11137 -0.035576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5754.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.25629 -0.62449 -0.36456 -0.84104 -0.29684 -0.7056 -0.46634 -1.0446]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5758.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2266]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5762.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5763.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5766.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027233 -0.10675]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5767.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5770.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.1444 -0.031434 -0.19843 -0.1444 -0.031434 -0.19843]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5776.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2321 1.2294]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5779.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0412]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5784.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0131 1.0306 1.0496 1.0773 1.3673 1.3615 1.3673 1.3805]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5791.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1519 1.0966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5799.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.17401 -0.6584 -0.18228 -0.67493 -0.076217 -2.3499 -5.0101 -0.011938 -0.25895 -0.82828 -0.073462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5801.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5141 1.5275 1.5409 1.5527 1.5661 1.578 1.1441 1.159 1.1738 1.1887 1.2036 1.2184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5838.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1101]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5841.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0474 1.0867]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5847.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.394]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5848.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0295 1.0208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5854.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5861.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.31848 -0.088152]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5869.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0283 1.051 1.0963 1.1212 1.1382 1.0929 1.0725]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5872.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0143 1.0326 1.054]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5884.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1094 1.0879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5885.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.31721 -0.75257 -0.18407 -0.4863 -0.33134 -0.78082 -0.17723 -0.4726]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5886.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0479 1.0525 1.0559 1.0593]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5887.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0185]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5888.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11102 -0.13322 -0.020495 -0.15884 -0.1836 -0.48506]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5889.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1459 1.1503 1.1547 1.1591 1.1635 1.168 1.0751 1.0796 1.0829 1.0873 1.0917 1.0972]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1853 1.2069 1.0495]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5906.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.05464 -0.055074 -0.22984]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5911.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0173 1.0508]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5919.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0341]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5922.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.17895]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5924.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0335 1.0335 1.0335 1.0335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1879 1.386 1.386 1.386]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5928.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.17479 -0.47891 -0.072165 -0.27366 -0.15323 -0.4358 -0.28772 -0.70478 -0.25867 -0.64667 -0.27788 -0.6851]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5930.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5948.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0104 1.097 1.2284]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5958.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0493 1.0826 1.1518 1.1664 1.1252 1.0879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5960.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2801 1.4135]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5967.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.316 1.1013]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5970.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0618]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5977.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.82346 -1.8041 -1.3337 -2.8246 -0.24886 -0.6549 -0.67597 -1.5091 -0.24203 -0.64123 -0.49601 -1.1492 -0.059795 -0.27676 -0.22665 -0.61048]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/5984.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.072]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6006.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0312 1.0524 1.0312]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6018.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6022.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0217]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6030.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0639 1.1466]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6042.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1225 1.1379 1.1685 1.2068]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6047.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0568]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6062.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.034483 -0.079217 -0.28705 -0.027027 -0.18267 -0.023765 -0.17614 -0.020503 -0.16962 -0.021901 -0.17241 -0.1398]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6063.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3973 1.3973 1.3973 1.4041 1.4068 1.3932 1.3918 1.4068 1.4178 1.4082]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6086.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.38278 -0.90871 -0.52645 -1.1961 -0.55809 -1.2593 -0.054979 -0.4388 -1.0207 -0.58403 -1.3112 -0.61359 -1.3703 -0.04305 -0.22925]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6091.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1237 1.1275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6092.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3701 1.398]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6103.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.32732 -0.80886 -0.12059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6107.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0376]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6111.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.28486 -0.66799 -0.21949 -0.53724 -0.057052 -0.071315]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6113.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1838]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6119.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.05782 -0.24645 -0.063033 -0.25687 -0.027962 -0.18673 -0.016588 -0.16398 -0.061611 -0.25403 -0.083412]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6121.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.02107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6132.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.028668 -1.5788 -3.4207]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6155.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.055728]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6158.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.23293]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0456 1.0382 1.0371 1.0382]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6174.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0152]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6178.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0232 1.0397 1.0649 1.0426 1.061 1.0552 1.0784]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0306]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6190.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2785 1.3064 1.305 1.2851 1.317 1.1631 1.1631 1.1631 1.2944 1.2944]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6192.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.3894 4.6484 2.8629 5.5955 2.8204 5.5104 1.7023 3.2741 1.7023 3.2741 1.965 3.7996 1.655 1.2127 2.2949 1.1593 2.1881 1.0737 1.0302 1.2467]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6196.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10756 -0.36789 -0.01325 -0.017927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6197.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2175 1.4551 1.0433 1.1964]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6198.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1395 1.1016]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6211.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0824 1.0879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6213.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012411 -0.010638 -0.010638 -0.044326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6216.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1146 1.1135 1.1112 1.1179 1.1168 1.0245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6221.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1759 1.1799]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6225.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1198 1.1073]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6230.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.13047 -0.11073]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6239.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.095477 -0.03727 -0.17839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6242.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10058]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6259.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0558]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6262.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6263.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6268.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1932 1.1268]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6270.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0467 1.0498 1.0239 1.0373 1.0716 1.0529 1.0519 1.0716 1.0363 1.0311 1.0498 1.0622]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6271.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.069225 -0.24763 -0.085047 -0.27927 -0.1068 -0.32278 -0.051424]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6272.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.26858 -0.13682 -0.53716 -0.032939]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6276.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6286.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1842 1.5053 1.0791 2.0251 1.0935 2.054 1.5506 1.4098 1.4966 1.8611 1.2874 2.4417 1.2743 2.4156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6304.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1868 1.114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6311.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027251 -0.061611]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6320.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1863 1.2605 1.1667]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6327.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3162 1.1809 1.2985 1.1265]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6345.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0573 1.0371 1.0201]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6356.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1471 1.2532 1.215]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6377.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 168.76 337.42 64.478 128.85 31.659 63.214 145.82 291.53 52.021 103.94 24.265 48.425]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6400.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3682 1.3745 1.3556 1.3506 1.4048 1.4401]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6403.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12077 -0.03386]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6407.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.067965 -0.25541 -0.15108 -0.42164 -0.15974 -0.43896 -0.08658 -0.29264 -0.083983 -0.28745]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1815]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6416.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2705 1.3161 1.234 1.3024 1.3313]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6428.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6433.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0252]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6435.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6445.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1957 1.1844 1.1543]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6449.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0163 1.0623 1.1491]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6451.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 14.864 29.459 14.875 29.481 14.864 29.459 1.2828 2.2972 1.0281 1.7878]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0581 1.0666 1.1138 1.1465]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6457.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8339 3.5583 1.2157 1.4282 1.456 1.7058 1.0912]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6458.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0488 1.117]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6460.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041916 -0.023097]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6472.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0166]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6475.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0597]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6496.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0849]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6499.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0645]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1853 1.2768]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6504.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.166]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6509.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0377 1.0826 1.5319 1.2536 1.0493 1.058 1.4797 1.1739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6510.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.27916 -0.76897 -21.797 -43.805 -0.93545 -2.0815 -5.1642 -10.539 -8.4949 -17.2 -0.19705 -0.039638]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6521.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3333 1.3333 1.1852]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6522.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0745 1.2383 1.1862]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6533.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.045987]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.079]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6550.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2222 1.2234 1.2052 1.2018 1.2007]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6559.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0282 1.0261]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6563.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3102 1.3561 1.2732 1.2363 1.0728]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6579.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4014 1.2058]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6580.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0939 1.1014 1.175 1.0448 1.1174 1.0896 1.1494 1.0342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6595.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.039167 -0.071667]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6610.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4163 1.3966 1.3572 1.3502 1.3305 1.3179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1656 1.1556 1.1455 1.1844 1.1681]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6622.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409 1.0504 1.0818 1.085 1.1343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6634.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.095682 -0.40474 -0.093141 -0.064352 -0.16766 -0.12532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6638.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.090102 -0.045685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1767]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6644.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4035]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6645.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1068 1.0284]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6647.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0872 1.1101 1.0945]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6653.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.030382 -0.022569 -0.013021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0675 1.0548 1.0558 1.091 1.1018 1.1145 1.0176 1.0783]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6668.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.091988 -0.33185 -0.87933 -0.029674 -0.017804 -0.028684]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6691.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.065856 -0.094225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6696.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0656 1.2278 1.0173 1.2371]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6697.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0334]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6715.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6721.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6739.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0406 1.0713 1.1328 1.1242 1.2054 1.0406 1.0713 1.1328 1.1242 1.2054]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6743.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.071834]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6752.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0226 1.0413 1.0613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6757.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1263 1.0172]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6763.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1759 1.1759]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6764.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0764 1.0705]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6773.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0256 1.1453 1.1218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6787.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0258 1.0186]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6812.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.04038 -0.041172 -0.042755 -0.043547]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6816.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0823]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6818.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1256 1.0153]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6820.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.038]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6825.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2195 1.1337]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6827.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.021084 -0.075301 -0.01004 -0.013052]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6832.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.023742]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6840.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6844.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3985 1.4246 1.7905 1.5933 1.3134 2.5143 1.4059 2.6993 1.6508 3.1891 1.2042 2.2958]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6849.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6850.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1056 1.2011]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6857.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.050746]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6860.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.094 1.0747 1.0895]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6862.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0802]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6866.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.152 1.1333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6869.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6874.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.14154 -0.033088 -0.056066 -0.17923 -0.48529 -0.11489 -0.037224 -0.20129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6876.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.01548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6881.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0683 1.0356 1.1636 1.1721 1.1138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0847 1.0584 1.0343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6916.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3627 1.0532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6917.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1021 1.1021 1.1021 1.1021 1.1021 1.1021 1.1021 1.1021 1.1021 1.1021 1.1021 1.1021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6919.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12675 -0.12768 -0.137 -0.012116 -0.15284]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6921.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.29 1.352 1.358 1.3897 1.4426 1.429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6924.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.048356 -0.11122 -0.13927 -0.49613 -1.3037 -0.29691 -0.046422 -0.049323]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6926.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0546 1.1639 1.2409 1.4958 1.2605 1.1709 1.1709]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1093 1.1093 1.1093 1.1093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6928.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.010686]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6931.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0194 1.2003 1.0493 1.2377 1.2257]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6949.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0175 1.9226 1.309 2.5057 1.4133 2.7142 3.114 6.1156 1.1885 2.2647]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6952.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0136 1.0866 1.1148 1.0467 1.0107 1.0195]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6964.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.046 1.046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6967.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.2468 4.3484 1.3442 2.5432 2.1426 4.14 2.8884 5.6316 3.1153 6.0853 1.2063 2.2674 1.0621 1.9789 1.1189 2.0926 1.1768 2.2084]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6978.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0831]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6980.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.057432 -0.13513 -0.11149 -0.11149 -0.042793]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6983.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.096935 -0.020713 -0.15576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6992.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.019651]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/6999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0348 1.064 1.0954]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7007.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.167]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7014.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2932 1.3102 1.2487 1.301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7024.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.20118 -0.51059 -0.20549 -0.51922 -0.20902 -0.52627 -0.26823 -0.64471]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7026.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1073 1.1698 1.2034]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7031.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.30664 -0.91043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7033.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0113]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7034.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.030516]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7042.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1892 1.117 1.0447 1.0149]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7046.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1749 1.1375 1.1102 1.0546 1.0293]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7048.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.023 1.734 1.75 1.476 1.489 1.179 1.213 1.032 1.044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7051.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.078231 -0.29705 -0.099773 -0.34014 -0.013605 -0.05102 -0.031746 -0.044218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7054.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0152 1.0152 1.0141 1.0141 1.0141 1.0141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7058.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7066.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0478]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7071.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.068503 -3.5562 -7.2867 -0.18168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7075.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.021542 -0.1576 -6.9269 -14.573 -0.040816 -3.2432 -7.2052]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7081.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.153]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7092.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2307 1.2202 1.2084 1.1966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7097.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4005 1.4114 1.4332 1.1403 1.1131 1.0886]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0793 1.0167 1.114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7101.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0418 1.2657 1.5552]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7112.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.19107 -0.49628 -0.040943 -0.19603 -0.32961 -0.77337 -0.22084 -0.55583]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7115.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.023736 -0.052632 -0.029928]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7117.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.089444 -0.48333 -0.29444 -0.29 -0.033333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2557 1.2645 1.2601 1.188 1.2131 1.2044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7126.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2398 1.2398]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3629 1.3997 1.3198 1.2868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7137.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3549 1.1239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7140.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.359 1.4419 1.1329 2.1479 1.7701 1.2184 2.3188 1.2419 2.3658 1.8658 1.5603 3.0026 2.5222 4.9265 2.2966 4.4752 3.2068 6.2957]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7141.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4113 1.2886 1.2742 1.4661]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7144.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7151.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.05685 -0.47251 -1.26 -0.017707 -0.046598]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7155.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.039777 -0.1241 -0.027844]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7164.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.039254 -0.15604 -0.016683 -0.063788 -0.1001]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7172.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.0457]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7182.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1204 1.3204]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7189.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.63014 -1.3695 -1.3315 -2.7722 -2.9925 -6.0941 -0.95372 -2.0166 -2.1452 -4.3995 -1.3188 -2.7468 -3.2555 -6.6203 -5.7318 -11.573 -3.2275 -6.5641]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7195.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0421 1.0694 1.2119 1.2689 1.1053 1.031]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7203.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.052588 -0.22872 -0.029215]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7208.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1358 1.1201 1.1358 1.1257 1.1627]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7211.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0179 1.1812 1.2025 1.1935 1.2047 1.2081 1.2148]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7215.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1368]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0547]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6794 1.0241 1.9125 1.3166 1.707 3.2783 1.8628 3.59 3.6794 7.2232 9.4405 18.745 4.3564 8.5772 17.97 35.804 64.809 129.48 200.75 401.37]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7227.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0248 1.0561 1.047 1.0679 1.0183]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7228.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0266]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7234.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0898]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7236.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1287 1.0515 1.1287 1.1287 1.0515 1.1287]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7249.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1528]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7250.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7252.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0124]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7254.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.175]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7258.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7277.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0255]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7279.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.036 1.0444 1.048 1.0864 1.1092 1.0576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7280.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7287.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0661 1.0278]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7293.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.066176 -0.039216 -0.13399 -0.066176 -0.039216 -0.071895]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7295.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.139 1.0809 1.1333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7296.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0135 1.0316 1.0395]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7297.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2396 1.2786 1.2974 1.4118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7300.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1738 1.183 1.1876 1.2014 1.2532 1.252 1.2739 1.2888]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7312.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0774 1.0717]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7315.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0967 1.0204]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7323.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0554 1.0554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7325.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.13546 -0.15099 -0.051769 -0.085418 -0.022433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7326.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.024598 -0.024598 -0.11069 -0.067171 -0.2649]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7334.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.21511 -0.61886 -0.15784]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7348.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.072 1.1794 1.1296 1.0919]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7354.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1633 1.1278 1.1235 1.0967 1.1203 1.1396]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7356.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.238]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7369.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1292 1.1046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7370.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0131 1.1227]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7371.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 15.816 31.241 15.827 31.264 15.816 31.241 1.4127 2.4354 1.1429 1.8957]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7385.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1549 1.211 1.1291 1.2267]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7395.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2416 1.2672 1.1039 1.3198 1.2348 1.0864]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7396.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1028 1.1218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1522]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7408.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018957 -0.015166 -0.049289 -0.03128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7410.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.046943 -0.24017]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2715]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7414.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0352 1.0369 1.0704 1.0601]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7415.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2391]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7418.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.17721 -0.51229 -0.043931 -0.1452 -0.44825]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7424.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.056876 -0.2309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7425.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1849 1.1597 1.1389 1.1783 1.186]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7428.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3073 1.0647]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7435.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0923 1.0427]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7442.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.6942 -1.5718 -0.021626 -0.017301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7445.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1904]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7448.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 14.613 28.854 14.624 28.875 14.613 28.854 1.3109 2.2492 1.0618 1.7508]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7458.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0153 1.0933]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7459.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0236]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1221 1.1489 1.1756 1.1756 1.1756]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7473.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7478.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 18.653 36.953 18.667 36.981 18.653 36.953 1.6169 2.881 1.2974 2.2421]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7479.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0699 1.1389 1.0989]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7487.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0532 1.0848 1.0701 1.052]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7512.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.018]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7521.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0489]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7526.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 744.31 1488.5 36.97 73.773 740.96 1481.8 5.4156 10.665 826.4 1652.6 304.44 608.7 14.481 28.797]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7528.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2147]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7529.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.0328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2226 1.1248 1.5759 1.5218 1.7323 1.5278]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7542.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0116 1.0741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7543.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0714 1.1122 1.0465]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0481 1.0884]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7559.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.0929e+10 8.1858e+10 1.4883e+13 2.9766e+13 1.3395e+13 2.679e+13 1.8931e+12 3.7863e+12 5.952e+12 1.1904e+13 9.1355e+11 1.8271e+12 1.905e+11 3.8101e+11 5.4107e+10 1.0821e+11 2.8576e+11 5.7151e+11]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7570.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.053957 -0.50647]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7572.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.031591 -0.17083]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7575.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0575 1.0767 1.267]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7580.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.034615 -0.019231 -0.029808 -0.013462 -0.039423]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7582.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12171 -0.44505]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7600.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0322]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7615.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0603 1.1877 1.289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7624.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0805]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7625.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.044 1.044 1.044 1.044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7636.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012116 -0.067102 -0.088071 -0.30475 -0.054054]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7646.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0381]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7650.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2078 1.3222 1.2371 1.2789 1.364 1.2789 1.2789 1.1506 1.1506 1.1506]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7653.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7656.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.087459 -0.072607]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7666.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0153 1.0701]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7667.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7668.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1216 1.1216 1.1216 1.1216 1.1216]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7675.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0468]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7677.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7679.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0715]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7698.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1135 1.1763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7710.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.046024 -0.19367 -0.10751 -0.092047 -0.10825]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7711.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1537 1.259]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7713.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1145 1.2247]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7717.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0371 1.0596]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7725.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0661]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7730.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0304]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7734.png: ignoring corrupt image/label: negative class labels or coordinate [ -70.083 -140.31 -93.594 -187.33 -182.11 -364.36 -175.67 -351.49 -244.53 -489.2 -186.34 -372.82 -495.27 -990.68 -1022.8 -2045.8 -32.968 -66.076 -24.175 -48.49 -16.228 -32.596]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7736.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0986 1.153 1.067 1.067]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7737.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7739.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7741.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2937 1.2407 1.1418]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7744.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1314 1.0572]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7750.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.010408]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7764.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0241 1.1313]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7769.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0426 1.0775 1.0982]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7775.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0506]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7779.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0148]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7787.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.218 1.3277 1.2102 1.2232 1.2715 1.2128 1.3303 1.218 1.2258 1.2781 1.2089 1.3211 1.2232 1.2324 1.2768]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7788.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0588]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7792.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1333]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7794.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1692 1.0851]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0451 1.1776 1.0301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7799.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0279 1.0186 1.0269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7801.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3589 1.3844 1.3653 1.3589]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7804.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0975 1.0737 1.0135 1.0259]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7813.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.046 1.014 1.1359 1.2018]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7817.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3 1.2847 1.2833 1.3667 1.4306]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7819.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7820.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3153 1.0526 1.3438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7825.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.44264 -1 -0.037822 -0.19036 -0.042394]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7830.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1707 1.1631 1.1707 1.1277 1.1226 1.1163 1.1618 1.1542 1.1719]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7837.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.023324 -0.13703 -0.059767 -0.20991 -0.63557 -1.3615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0997]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7848.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2666 1.2666 1.2666 1.2666 1.2666 1.2666]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7849.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1168 1.0659 1.1272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7852.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1011]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7862.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7864.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0396 1.0653]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7865.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.203 1.2043 1.1908]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7866.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018922 -0.34289 -0.33142 -0.96789]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7876.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7878.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1262 1.1262 1.1262 1.1262 1.1262 1.1262 1.1262 1.1262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7884.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0146 1.021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7886.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0713]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7892.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7895.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7899.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.088 1.0202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7902.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0952 1.1232 1.1209 1.131 1.0952 1.1232 1.1209 1.131 1.0952 1.1232 1.1209 1.131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7907.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7908.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1538 1.0839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7910.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0797 1.1892 1.5446]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7911.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0814]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7912.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0952 1.0988 1.1014 1.1049 1.1067 1.1102]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7917.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7919.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0159 1.0127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7924.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1349 1.1298 1.1743 1.3537 1.3537]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7930.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0279]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7937.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3009 1.2929 1.2676 1.2184 1.1704]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7942.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.071 1.0293]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7943.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1194]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7958.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0631]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7962.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0402]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7964.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7983.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.80386 -1.9291 -0.27783 -0.87702 -0.20646 -1.3389 -2.9991 -0.11266 -0.54668 -0.21813 -1.3402 -3.0018 -0.1351 -0.59156 -0.010323 -0.34201]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7984.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0973 1.0808]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7987.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0225 1.2121 1.0645]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7998.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5156 1.4779 1.4883]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/7999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1299 1.1182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8003.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0465 1.0233 1.0106 1.0825 1.092 1.111 1.2146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1334 1.2915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8013.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8972 3.6363 17.494 34.83 3.7617 7.3652 14.706 29.254 6.4928 12.828 5.2692 10.38 11.082 22.006 4.0569 7.9556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1523 1.0283]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8021.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0707 1.0726 1.0726 1.0726 1.0746 1.106 1.107 1.1079 1.1079 1.1089]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8024.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1054 1.1465 1.2044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8027.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0988 1.0391 1.0575 1.0543]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8036.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 24.141 48.143 15.968 31.795 13.999 27.859 14.123 28.105 9.4478 18.756 8.5659 16.992 1.0162 1.0183 66.722 133.3 48.507 96.873 55.983 111.83 57.438 114.74 63.92 127.7 65.406 130.67]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8052.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2468]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8053.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.62019 -1.3731 -0.37596 -0.88462 -0.21731 -0.56731 -0.30961 -0.75192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8064.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.2067 -0.56004 -0.26939 -0.68544 -0.086079 -130.3 -260.74 -109.59 -219.33 -136.99 -274.13 -149.72 -299.59 -85.982 -172.11 -0.51753 -1.1817 -1.6392 -3.4251 -3.4926 -7.1318 -8.3055 -16.758 -8.2885 -16.724]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8067.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0193 1.1597 1.074 1.0504]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8069.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1295 1.4359]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8077.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0659]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8079.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0989 1.0824 1.0407]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8081.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3894 1.3916 1.3927 1.3938 1.2821 1.2931 1.2998 1.3075]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8082.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.13799 -0.078906 -0.4544 -15.514 -31.324 -0.15147 -0.091197 -0.47899 -16.432 -33.16 -0.37232 -1.0412 -0.19191 -0.1471 -0.5908 -17.519 -35.334 -1.9485 -4.1935]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8085.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8088.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.69683 -1.5652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8093.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2738 1.1069]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0357 1.0902]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2905 1.3938 1.3097 1.0948 1.1176 1.4238 1.461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8101.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0935]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8112.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0492]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0496 1.1092 1.0509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8123.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1577]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8144.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2583 1.2749 1.2276 1.2954 1.0269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8146.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.01087]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8149.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0197 1.0488]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8151.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2406 1.1162 1.0915 1.0915 1.0915 1.0915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8153.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.21299 -0.21905 -0.010823 -0.26061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8162.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1162 1.3046 2.5091 2.3137 4.5272 2.0748 4.0494 2.0356 3.971 3.9513 7.8025 4.6362 9.1721 6.2469 12.394 7.4895 14.879 8.4989 16.898 9.0073 17.914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8163.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0515 1.0492 1.0515 1.0492 1.0515 1.0492]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8166.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.188]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8174.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8175.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0327]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8177.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0496]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8198.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0315 1.0698 1.0698 1.0684]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8200.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8202.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1342 1.1121 1.0571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8203.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2989 1.2513 1.3743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8204.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0159 1.1111 1.1355]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8207.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0284 1.1858]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8208.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0709 1.0274 1.1165 1.0932 1.0811]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8209.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11346 -0.019667 -0.10893 -0.018911 -0.11649 -0.024206]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8219.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1017 1.0793 1.0793 1.0905 1.0682]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.0106 1.0106]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8223.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.084991 -0.083183 -0.030741 -0.046112 -0.057866 -0.057866]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8230.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0679]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0166]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8242.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0611]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8252.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10176 -0.066536]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8255.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.029915 -0.089744 -0.02906 -0.080342 -0.11367 -0.11709 -0.13846 -0.16667]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8257.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.021441]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8259.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1419 1.1419 1.1419 1.143 1.143 1.014 1.0108 1.0161 1.0204 1.0269 1.0323]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8267.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0708 1.1694 1.1684 1.1807]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8268.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0126 1.0288]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8272.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0255 1.0134 1.4668 1.0325 1.0134 1.4668 1.041 1.0134 1.4668]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8276.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2994 1.1642 1.1642]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8280.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.043297 -0.022065 -0.15903 -0.016653]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8284.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2518 1.2518 1.2518 1.2518 1.2518 1.2518 1.0732 1.0732 1.0732]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8292.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.010569 -0.011382]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8298.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0178 1.0168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8305.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.037 1.0336 1.0314]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8308.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.027 1.0502]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8318.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0688]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8320.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0827 1.0139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8323.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2183 1.1366 1.0634 1.0269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8330.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0725 1.0725 1.0725 1.0725 1.0326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8334.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.076754 -0.15461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8351.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0586 1.0222]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8353.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1004]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8354.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.022108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8357.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0294 1.0828]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8361.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0315 1.0522]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8369.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.016865 -0.019841 -0.032738 -0.018849 -0.06746 -0.031746]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8371.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2212 1.3082 1.3906]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8376.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.011 1.0209 1.0339 1.0857 1.1345 1.1843]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8379.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1336 1.2181 1.1078 1.1985 1.0821 1.1789]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8383.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2258 1.2258 1.2258]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8408.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171 1.0579]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8421.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.069444 -0.27137 -0.2516 -0.63568 -0.028846 -0.076923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8422.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2534 1.3059 1.3059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8426.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1188]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8433.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0403 1.2272 1.2282 1.1507 1.1794 1.1879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8435.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1031 1.4861 1.6226 1.4958]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8437.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0776 1.0796]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8443.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0434]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8444.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0491 1.0491]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2442 1.8023 1.358 2.6013 2.6956 5.2766 2.2002 4.2857 1.3779 2.6412 6.787 13.459 4.8077 9.5008]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8450.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326 1.04]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8452.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1514 1.2825 1.3361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8453.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.076239 -0.26847 -0.03087 -0.17774 -0.05753 -0.23106 -0.094481 -0.11974 -0.04724 -0.21048 -0.042095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8458.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.17808]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8464.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041056 -0.094819]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8466.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.119 1.0899 1.0609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.054 1.0294 1.054 1.0379]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8474.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138 1.0325 1.071 1.0651 1.0917]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8476.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0309 1.0229 1.0309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8477.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1498 1.2996]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8485.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.099875 -0.032459 -0.014981]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0471 1.0423 1.0399 1.035 1.029 1.2198 1.2246 1.2258 1.2307 1.2355]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8508.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.56895 -1.2576 -0.76583 -1.6513 -1.4727 -3.065 -0.87207 -1.8638 -1.4406 -3.0009 -0.73764 -1.595 -1.1873 -2.4944 -1.6232 -3.366 -1.9744 -4.0685 -2.2554 -4.6305]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8519.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013185 -0.30629 -0.023327 -0.32657 -0.093813 -0.46755 -0.1572 -0.16126 -0.19574 -0.6714 -0.26065 -0.1927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8521.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2966 1.1693 1.2966 1.1798 1.2966 1.1929]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8522.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2012 1.2484 1.0571 1.1043 1.1528 1.1043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8523.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8529.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.085 1.1199 1.1383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8545.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1659]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8550.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.079 1.1771 1.3159]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8551.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8552.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2604 1.0583]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8553.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1774 1.011]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8564.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.26208 -0.66912 -0.064601 -0.27416 -0.013655]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8568.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0124]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8569.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1493 1.2605]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8575.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.012 1.111]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8578.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0488 1.0507 1.0385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8582.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1128 1.8682 4.8289 9.3004 2.2136 4.0697 55.874 111.39 29.817 59.276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8584.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1477 1.1736 1.1932]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8586.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0483 1.0216]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8591.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1718 1.137 1.1145 1.0787 1.0235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8592.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5422 1.6032 1.6715 1.7747 1.0116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8593.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0494]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8599.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0781 1.0926]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8604.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.39729 -1.0498 -175.27 -350.79 -66.497 -133.25 -0.44751 -1.1502 -176.99 -354.23 -141.08 -282.42 -0.66063 -1.5765 -184.22 -368.7 -170.98 -342.21]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8605.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.16983]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8608.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0324 1.1105]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8609.png: ignoring corrupt image/label: negative class labels or coordinate [ -108.94 -218.1 -41.312 -82.846 -110.01 -220.24 -87.685 -175.59 -114.51 -229.23 -106.27 -212.76]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8617.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2749 1.2075 1.1523 1.2008 1.252 1.3019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1007]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8619.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.011599 -0.1309 -0.15079 -0.15659 -0.17399 -0.02237 -0.20712 -0.24026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8620.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3395 1.3395 1.3395]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0651 1.125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8624.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.34961 -0.8064 -0.11668 -0.34054 -0.55099 -1.2092 -0.13872 -0.38462 -1.0173 -2.1417 -0.60242 -1.312 -0.19533 -0.49784 -0.031979 -0.17113 -0.68885 -1.4849]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8625.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8626.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.024]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8635.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.32016 -0.87837 -0.56125 -1.3606 -1.0956 -2.4292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0101 1.0223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8663.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11358]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8666.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8683.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8694.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0257]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8696.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0699]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8705.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.1015 1.1137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8706.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0753 1.0627]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8708.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393 1.0566 1.0439 1.0531 1.0335 1.0439]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8711.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0228 1.0962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8712.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1799 1.1852 1.1799 1.1852 1.1852]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8713.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0307]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8715.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1145 1.1522 1.0866 1.1899 1.0628 1.2682]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8716.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0702 1.0702 1.0702]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8737.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2276 1.0496]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8741.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0103 1.0474 1.1061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8742.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8743.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.020158 -0.11735 -0.017279 -0.2563]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8746.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.14782 -0.15225 -1.68 -3.4989 -0.12491 -0.38877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8755.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8756.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.18 1.103 1.177]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8758.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0165]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8760.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3205 1.2548 1.3127 1.2432 1.305 1.2329]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8767.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.176 1.1686 1.1601 1.1506 1.141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8770.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0699 1.2426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8773.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8775.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0245 1.0233 1.0245 1.0256 1.028 1.028 1.0221]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8777.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013314 -0.043639 -0.25998 -0.73743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8779.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0794 1.1055 1.1146 1.0915 1.0995]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8784.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1649]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8786.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1968 1.1915 1.1875 1.1848 1.2872 1.2899 1.2939 1.2979 1.3484 1.3511 1.3551 1.3617]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8790.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2072 1.1577 1.0216 1.0361 1.033]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8796.png: ignoring corrupt image/label: negative class labels or coordinate [ -6.5496 -13.295 -0.58529 -1.3662 -0.25993 -0.71544 -0.92831 -2.0522 -1.3835 -2.9625 -3.9636 -8.1228 -0.57537 -1.3463 -0.79302 -1.7816 -0.7375 -1.6706 -2.7651 -5.7257 -8.7324 -17.66 -0.575 -1.3456 -0.96544 -2.1265\n", + " -0.80625 -1.8081 -2.1779 -4.5515]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8800.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8804.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5321 1.4763 1.3953 1.4804]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8806.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8809.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1564 1.2672 1.2463]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8815.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1651 1.1155 1.0901 1.1663 1.1178 1.0912 1.1663 1.1201 1.0924]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8830.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.27492 -0.65732]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8832.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.21691 -0.39292 -1.0395 -0.02068 -0.29504 -0.53952 -1.3327 -0.084099 -0.42188 -0.57537 -1.4044 -0.049173 -0.35202 -0.13833 -0.53033 -0.55469 -1.3631 -0.1489 -0.55147 -0.55653 -1.3667 -0.30377 -0.86121 -0.19439 -0.64246 -0.4545\n", + " -1.1627]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8835.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0281]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8837.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0434]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8841.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0686 1.1068 1.085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8843.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.011 1.017 1.023 1.0279]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8847.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.9821 9.736 4.3832 8.5383 1.2982 2.3684 5.3357 10.443 5.2376 10.247 2.5183 4.8086 11.114 21.999 12.652 25.076 6.1894 12.151 3.065 5.9019 25.08 49.932]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8850.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1024]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8852.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0741 1.0689 1.0195]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8867.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.066 1.066 1.066 1.066 1.066 1.066 1.066 1.066 1.066 1.066 1.066 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8868.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0974 1.1355 1.3531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8871.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1001]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8886.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.050887 -0.14881 -0.026985 -0.033153]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8889.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0834 1.0906]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8895.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1161 1.1673 1.2057 1.2382]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8900.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1044 1.0226 1.0113 1.0578 1.0465]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8903.png: ignoring corrupt image/label: negative class labels or coordinate [ -8.6195 -17.349 -9.3215 -18.753 -12.718 -25.545 -0.10677 -0.1251 -0.018327 -0.14661 -0.027888]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8904.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.29115 -0.28947 -0.97984 -0.12318 -0.64726 -0.35386 -0.53192 -1.4647 -0.024076 -0.44905 -0.029115 -0.45913 -0.55319 -1.5073 -0.11982 -0.64054]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8910.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0529]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8916.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0172]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8922.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1275 1.1045 1.1087 1.0721 1.0648]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8928.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032427]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8934.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1286 1.1259 1.1245 1.1272 1.1272 1.1272 1.0194 1.0221 1.0235 1.0277 1.0318 1.0346]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8940.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0526 1.0959 1.1363 1.1175]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8941.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2347 1.0363 1.0624 1.1213 1.1088]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8945.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.24579 -0.62056 -0.098131 -0.32523 -0.019626]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8950.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1658 1.0175 1.081 1.192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8952.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.04206 -0.022318 -0.076395]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8955.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2254 1.1958 1.1937 1.1926]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8957.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0524]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8972.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.084 1.058 1.026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8975.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0113]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8977.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.076233]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8980.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0129 1.0249 1.0359]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8982.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.296 1.2469 1.1977 1.1412 1.0931 1.0418]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8996.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0241]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/8999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0617]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9003.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.061 1.061 1.061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9006.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0713]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9010.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1458 1.03]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9012.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.044 1.0274]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9015.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0348 1.2014 1.2014]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9018.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.020614 -0.15279 -0.026273 -0.16411 -0.11722 -0.010105 -0.13177 -0.28537 -0.6823 -0.63298 -1.3775 -0.089329 -0.29022 -0.19402 -0.4996 -0.31285 -0.73727 -0.36378 -0.83913]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1872 1.1872]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9026.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2035 1.2012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9028.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.081707 -0.028049]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9031.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1486 1.2447]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9035.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0275 1.2608]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9039.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.017208 -0.017208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9042.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0786]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9050.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.11]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9057.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0105]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9058.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0176]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9059.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2525 1.2538 1.2538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9062.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9064.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0247]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9065.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.352 1.4094 1.3954]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5148 1.598 1.6093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9079.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0719]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9082.png: ignoring corrupt image/label: negative class labels or coordinate [ -4.5123 -9.2017 -1.3272 -2.8315 -0.40255 -0.98213]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9084.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018445 -0.17448]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9089.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2194 1.2221]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0821 1.0663 1.0461 1.0216]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0507 1.1743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9104.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0368]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9107.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1336 1.141 1.1697]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9108.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.047 1.037 1.0539 1.0769 1.0739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9110.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.081059 -0.26164 -2.4414 -4.9823 -0.73997 -1.5795 -0.62239 -1.3443 -1.4093 -2.9181 -1.0971 -2.2937]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9115.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2133 1.0643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9122.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0101 1.0729 1.0912 1.0871 1.0486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9129.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0193 1.0182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0775 1.1794]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9139.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2098]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9145.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0333 1.081 1.1219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9147.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1596 1.1378 1.116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9152.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.116 1.089 1.0496 1.1137 1.0935 1.0574 1.098 1.098 1.0642]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9156.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.037895]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9158.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0221 1.0131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9160.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1948 1.1789 1.2028]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9164.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0965 1.0907 1.107 1.1032 1.1003 1.1012 1.1012 1.1041 1.1041]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9167.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9176.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0313 1.04]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0546 1.0668 1.0601]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9193.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.074 1.0943 1.08]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9197.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0273 1.0273 1.0261]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9198.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.13237 -0.029863]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9200.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4768]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9201.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3719 1.3501 1.3861 1.3887 1.3822 1.3887 1.3719 1.3771 1.0746 1.0746 1.0811 1.0862]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9203.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0833 1.2164 1.2755 1.5645 1.0954 1.1922]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9209.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.49786 -1.298 -216.79 -433.88 -0.56002 -1.4223 -218.91 -438.13 -0.82369 -1.9496 -227.86 -456.02]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9212.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1611]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9230.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3694 1.3694 1.264]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0578]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9245.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9246.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0158 1.1555]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9249.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.0255 1.1079 1.0611]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9252.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9254.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.32517 -0.7804 -0.20452 -0.53911 -0.21348 -0.55702 -0.6475 -1.4251 -0.016494 -0.16305 -0.13761 -0.40528 -0.012253 -0.15457 -0.14515 -0.42036 -0.04901 -0.22809]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9264.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.22 1.1664 1.1185 1.0635 1.1241 1.0197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9267.png: ignoring corrupt image/label: negative class labels or coordinate [ -362.23 -724.56 -352.44 -704.98 -82.937 -165.98 -0.025792 -0.15328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9273.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1255 1.2165]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9276.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1575 1.1575 1.1575]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9277.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1289 1.0374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9282.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1878 1.1494 1.0327]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9298.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0411 1.1392 1.1899 1.0707]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3378 1.3794 1.3673 1.3472 1.3499]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9313.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0146 1.1576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9314.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0226]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9324.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.299 1.3238 1.359]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9326.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.18602]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9329.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0388 1.1191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9344.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013632 -0.058423]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9347.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2026 1.1751 1.2062 1.1978]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9352.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5229 1.4534 1.249]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9358.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0828 1.0272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1664]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9374.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3515 1.1615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9381.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1566]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9384.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9395.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0856 1.281]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9397.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9398.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.025694]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9400.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.012605 -0.32437]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9410.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0764]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9420.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0674]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9430.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1677]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9442.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0633]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9444.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0142 1.4096 1.137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9449.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0717]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9454.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2386 1.4007 1.0544]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9459.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.046396 -0.026512]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9466.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2464 1.2497 1.2464]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0734]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0431 1.0398 1.0354 1.0475 1.0541 1.0674 1.0707 1.0652 1.0619 1.0751 1.0862 1.0972]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9470.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.4186 -0.97054]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9476.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1293]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9479.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1966 1.1052 1.2519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9485.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.236 1.4201 1.2538]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9491.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0463 1.1659]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9497.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3919]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9501.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0673 1.0673 1.0673]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9509.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9514.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0804 1.0672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9515.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1105 1.1105 1.1105 1.1105 1.1105]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9538.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0654]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9546.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9548.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2215 1.2085 1.1943 1.5557 1.5544 1.5505]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9554.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0443 1.0412 1.0588 1.1629 1.1629 1.1299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9577.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1248 1.2917 1.3745 1.5006]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9578.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.035176 -0.10653 -0.035176 -0.086432 -0.036181 -0.16382]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5339]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9592.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1786]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9593.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1628 2.0972 1.7522 12.545 24.862 20.466 40.704]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9594.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0777 1.0809 1.083 1.0861]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9597.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.029023 -0.15944 -0.083027 -0.04335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9602.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2809]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9606.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0345]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9613.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1076 1.1986 1.1586 1.1048 1.1821 1.1462 1.1034 1.1628 1.1393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9622.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0332 1.1525]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9644.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.165 1.165]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 13.56 26.986 10.121 20.108 10.757 21.38 2.986 5.8373 2.2309 4.327]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9665.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1292 1.2718 1.1919]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9666.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0961]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9672.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2612]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9684.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2078 1.257]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9686.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1843 1.0115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9691.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.67473 -1.4978 -0.8414 -1.8312 -0.3914 -0.93118 -0.41398 -0.97634 -0.63387 -1.4161 -0.1414 -0.43118 -0.16183 -0.47204 -0.11452 -0.37742 -0.019892 -0.18817 -0.044624 -0.23763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9692.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0655]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9693.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.073]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9702.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0252 1.1046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9706.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1775]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9707.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.017197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9708.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171 1.0214 1.0242 1.0285 1.0313 1.0456 1.0484 1.0541 1.057 1.0598]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9709.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1476 1.1476 1.1476 1.1476 1.0299 1.0897 1.1007]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9712.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 28.502 56.891 38.546 76.979 21.706 43.3 2.9314 5.75 3.3595 6.6062 4.0176 7.9224 1.3174 2.5221 39.443 78.774]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9718.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0913]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9719.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1745 1.0961 1.0219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9721.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0143 1.0184 1.0195]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9725.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0406]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9734.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3389 1.3389 1.3389 1.3389 1.3389 1.3389 1.3389 1.3389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9738.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0566 1.0705 1.0812]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9746.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1508 1.1444 1.1358 1.2267 1.1583 1.1102 1.1668 1.1807 1.0995 1.1294 1.1786 1.231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9753.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0114 1.0114 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9754.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1996 1.0287]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9758.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9760.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2253 1.2387 1.216 1.0627 1.332 1.3227 1.328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9761.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0273 1.0763 1.1985]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9770.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0493 1.0493 1.0493]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9778.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.082912]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9788.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.034146 -0.023577 -0.017073 -0.70976 -1.5967 -0.023577 -0.058537 -0.018293 -0.21382 -5.7902 -11.758 -0.038211 -0.25366]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9792.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0452 1.0315]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9793.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0385 1.044 1.0385 1.0604 1.0385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1547]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9802.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2405 1.3112 1.3014 1.3112 1.1785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9805.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0304]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9807.png: ignoring corrupt image/label: negative class labels or coordinate [ -18.906 -38.054 -54.027 -108.3 -0.047049 -173.13 -346.5 -1.5261 -3.2934 -21.09 -42.421 -58.585 -117.41 -0.040205 -174.45 -349.15 -1.1416 -2.5244 -10.719 -21.678 -60.977 -122.2 -0.061591 -186.49 -373.22 -1.6223\n", + " -3.4859 -0.044055 -0.32934]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9808.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.58869 -1.4471 -7.3068 -14.883 -2.5231 -5.3158 -0.075113 -0.15701 -0.58371]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9821.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1438 1.0479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9824.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.036556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9837.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9840.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.1209 -0.27575 -0.7291 -0.13209 -0.025746 -0.2291 -0.033209 -0.24403 -0.19179 -0.042537 -0.16194 -0.13022 -0.43806 -0.16231 -0.50224]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9844.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1869 1.1633 1.1261]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9867.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1891 1.1552 1.1552]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9868.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9869.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.032771 -0.037736 -0.11619 -0.017378 -0.15789 -0.066038 -0.25521]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9875.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0195]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9877.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1066 1.2218 1.2032 1.4201]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9878.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0106 1.0114 1.0138 1.0146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9879.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1278]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9881.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9888.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0361 1.015]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9894.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.03125 -0.020221]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9904.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1662]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9909.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9915.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0728]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9916.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0766]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9918.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0132 1.0276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9940.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.088993]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9950.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1356 1.1255 1.128 1.1635 1.1483 1.1673]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9951.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0999 1.0804]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9953.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.628 1.2943 2.2411 4.35 3.3135 6.4947 3.6639 7.1956 5.1927 10.253 6.1438 12.155 7.7378 15.343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9955.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0408 1.1851 1.1025 1.0105 1.0554 1.1998 1.1109 1.0178 1.0701 1.2134 1.1192]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9963.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.8246 5.3607 5.5044 10.72 1.0734 1.8582 10.91 21.532 3.8551 7.4216]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9966.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0992 1.23]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9968.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.86059 -1.8516 -0.099244 -0.062382 -0.2552 -0.11011 -0.35066 -0.38516 -0.90076 -0.35113 -0.8327 -0.084594 -0.29962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9969.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.059952 -0.031175 -0.035971]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9972.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.089]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9979.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3208 1.3208 1.3634 1.3571 1.3145 1.2544]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9982.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0822]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9984.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0682 1.1196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9988.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1198 1.0169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9990.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0208 1.019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9991.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0878 1.0878 1.1058]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9993.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0696 1.2384]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9995.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1648 1.1901 1.1931 1.1941 1.1405 1.18]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/9998.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.014825 -0.14106]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset/images/val/multi_col_20742.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1moptimizer:\u001b[0m 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... \n", + "\u001b[34m\u001b[1moptimizer:\u001b[0m AdamW(lr=0.002, momentum=0.9) with parameter groups 81 weight(decay=0.0), 88 weight(decay=0.0005), 87 bias(decay=0.0)\n", + "Plotting labels to /content/drive/MyDrive/Spectra_YOLO_Project/detect/train/labels.jpg... \n", + "Image sizes 640 train, 640 val\n", + "Using 2 dataloader workers\n", + "Logging results to \u001b[1m/content/drive/MyDrive/Spectra_YOLO_Project/detect/train\u001b[0m\n", + "Starting training for 10 epochs...\n", + "Closing dataloader mosaic\n", + "\u001b[34m\u001b[1malbumentations: \u001b[0mBlur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, method='weighted_average', num_output_channels=3), CLAHE(p=0.01, clip_limit=(1.0, 4.0), tile_grid_size=(8, 8))\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 1/10 6.7G 0.7633 0.7675 0.9198 195 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 21:08\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.2s/it 5:30\n", + " all 17404 202256 0.182 0.0709 0.044 0.0303\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 2/10 7.67G 0.5612 0.4329 0.8554 171 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 20:59\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.2s/it 5:13\n", + " all 17404 202256 0.19 0.0722 0.0403 0.0276\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 3/10 6.55G 0.5014 0.3856 0.8403 158 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 20:34\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.1s/it 4:54\n", + " all 17404 202256 0.184 0.073 0.0322 0.0208\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 4/10 6.56G 0.4714 0.3621 0.8328 220 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 20:37\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.1s/it 4:58\n", + " all 17404 202256 0.177 0.0748 0.0347 0.0237\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 5/10 6.56G 0.437 0.3373 0.8261 211 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 20:27\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.1s/it 4:50\n", + " all 17404 202256 0.184 0.0749 0.0359 0.024\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 6/10 6.56G 0.4165 0.3227 0.823 241 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 20:25\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.1s/it 4:57\n", + " all 17404 202256 0.193 0.0744 0.0377 0.0257\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 7/10 6.56G 0.3949 0.3045 0.818 219 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 20:38\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.1s/it 4:52\n", + " all 17404 202256 0.186 0.0744 0.0337 0.0229\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 8/10 6.56G 0.3775 0.2904 0.8164 261 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 20:32\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.1s/it 4:55\n", + " all 17404 202256 0.187 0.0741 0.0342 0.0231\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 9/10 6.56G 0.3635 0.2792 0.8145 239 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 20:27\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.1s/it 4:56\n", + " all 17404 202256 0.198 0.0727 0.0387 0.0271\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 10/10 6.56G 0.3469 0.2654 0.8124 232 640: 100% ━━━━━━━━━━━━ 1745/1745 1.4it/s 20:40\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.1s/it 4:50\n", + " all 17404 202256 0.196 0.073 0.0385 0.0273\n", + "\n", + "10 epochs completed in 4.324 hours.\n", + "Optimizer stripped from /content/drive/MyDrive/Spectra_YOLO_Project/detect/train/weights/last.pt, 5.5MB\n", + "Optimizer stripped from /content/drive/MyDrive/Spectra_YOLO_Project/detect/train/weights/best.pt, 5.5MB\n", + "\n", + "Validating /content/drive/MyDrive/Spectra_YOLO_Project/detect/train/weights/best.pt...\n", + "Ultralytics 8.4.16 🚀 Python-3.12.12 torch-2.10.0+cu128 CUDA:0 (Tesla T4, 14913MiB)\n", + "YOLO11n summary (fused): 101 layers, 2,582,347 parameters, 0 gradients, 6.3 GFLOPs\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 272/272 1.1it/s 4:18\n", + " all 17404 202256 0.182 0.0709 0.044 0.0303\n", + "Speed: 0.1ms preprocess, 1.5ms inference, 0.0ms loss, 2.2ms postprocess per image\n", + "Results saved to \u001b[1m/content/drive/MyDrive/Spectra_YOLO_Project/detect/train\u001b[0m\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "ultralytics.utils.metrics.DetMetrics object with attributes:\n", + "\n", + "ap_class_index: array([0])\n", + "box: ultralytics.utils.metrics.Metric object\n", + "confusion_matrix: \n", + "curves: ['Precision-Recall(B)', 'F1-Confidence(B)', 'Precision-Confidence(B)', 'Recall-Confidence(B)']\n", + "curves_results: [[array([ 0, 0.001001, 0.002002, 0.003003, 0.004004, 0.005005, 0.006006, 0.007007, 0.008008, 0.009009, 0.01001, 0.011011, 0.012012, 0.013013, 0.014014, 0.015015, 0.016016, 0.017017, 0.018018, 0.019019, 0.02002, 0.021021, 0.022022, 0.023023,\n", + " 0.024024, 0.025025, 0.026026, 0.027027, 0.028028, 0.029029, 0.03003, 0.031031, 0.032032, 0.033033, 0.034034, 0.035035, 0.036036, 0.037037, 0.038038, 0.039039, 0.04004, 0.041041, 0.042042, 0.043043, 0.044044, 0.045045, 0.046046, 0.047047,\n", + " 0.048048, 0.049049, 0.05005, 0.051051, 0.052052, 0.053053, 0.054054, 0.055055, 0.056056, 0.057057, 0.058058, 0.059059, 0.06006, 0.061061, 0.062062, 0.063063, 0.064064, 0.065065, 0.066066, 0.067067, 0.068068, 0.069069, 0.07007, 0.071071,\n", + " 0.072072, 0.073073, 0.074074, 0.075075, 0.076076, 0.077077, 0.078078, 0.079079, 0.08008, 0.081081, 0.082082, 0.083083, 0.084084, 0.085085, 0.086086, 0.087087, 0.088088, 0.089089, 0.09009, 0.091091, 0.092092, 0.093093, 0.094094, 0.095095,\n", + " 0.096096, 0.097097, 0.098098, 0.099099, 0.1001, 0.1011, 0.1021, 0.1031, 0.1041, 0.10511, 0.10611, 0.10711, 0.10811, 0.10911, 0.11011, 0.11111, 0.11211, 0.11311, 0.11411, 0.11512, 0.11612, 0.11712, 0.11812, 0.11912,\n", + " 0.12012, 0.12112, 0.12212, 0.12312, 0.12412, 0.12513, 0.12613, 0.12713, 0.12813, 0.12913, 0.13013, 0.13113, 0.13213, 0.13313, 0.13413, 0.13514, 0.13614, 0.13714, 0.13814, 0.13914, 0.14014, 0.14114, 0.14214, 0.14314,\n", + " 0.14414, 0.14515, 0.14615, 0.14715, 0.14815, 0.14915, 0.15015, 0.15115, 0.15215, 0.15315, 0.15415, 0.15516, 0.15616, 0.15716, 0.15816, 0.15916, 0.16016, 0.16116, 0.16216, 0.16316, 0.16416, 0.16517, 0.16617, 0.16717,\n", + " 0.16817, 0.16917, 0.17017, 0.17117, 0.17217, 0.17317, 0.17417, 0.17518, 0.17618, 0.17718, 0.17818, 0.17918, 0.18018, 0.18118, 0.18218, 0.18318, 0.18418, 0.18519, 0.18619, 0.18719, 0.18819, 0.18919, 0.19019, 0.19119,\n", + " 0.19219, 0.19319, 0.19419, 0.1952, 0.1962, 0.1972, 0.1982, 0.1992, 0.2002, 0.2012, 0.2022, 0.2032, 0.2042, 0.20521, 0.20621, 0.20721, 0.20821, 0.20921, 0.21021, 0.21121, 0.21221, 0.21321, 0.21421, 0.21522,\n", + " 0.21622, 0.21722, 0.21822, 0.21922, 0.22022, 0.22122, 0.22222, 0.22322, 0.22422, 0.22523, 0.22623, 0.22723, 0.22823, 0.22923, 0.23023, 0.23123, 0.23223, 0.23323, 0.23423, 0.23524, 0.23624, 0.23724, 0.23824, 0.23924,\n", + " 0.24024, 0.24124, 0.24224, 0.24324, 0.24424, 0.24525, 0.24625, 0.24725, 0.24825, 0.24925, 0.25025, 0.25125, 0.25225, 0.25325, 0.25425, 0.25526, 0.25626, 0.25726, 0.25826, 0.25926, 0.26026, 0.26126, 0.26226, 0.26326,\n", + " 0.26426, 0.26527, 0.26627, 0.26727, 0.26827, 0.26927, 0.27027, 0.27127, 0.27227, 0.27327, 0.27427, 0.27528, 0.27628, 0.27728, 0.27828, 0.27928, 0.28028, 0.28128, 0.28228, 0.28328, 0.28428, 0.28529, 0.28629, 0.28729,\n", + " 0.28829, 0.28929, 0.29029, 0.29129, 0.29229, 0.29329, 0.29429, 0.2953, 0.2963, 0.2973, 0.2983, 0.2993, 0.3003, 0.3013, 0.3023, 0.3033, 0.3043, 0.30531, 0.30631, 0.30731, 0.30831, 0.30931, 0.31031, 0.31131,\n", + " 0.31231, 0.31331, 0.31431, 0.31532, 0.31632, 0.31732, 0.31832, 0.31932, 0.32032, 0.32132, 0.32232, 0.32332, 0.32432, 0.32533, 0.32633, 0.32733, 0.32833, 0.32933, 0.33033, 0.33133, 0.33233, 0.33333, 0.33433, 0.33534,\n", + " 0.33634, 0.33734, 0.33834, 0.33934, 0.34034, 0.34134, 0.34234, 0.34334, 0.34434, 0.34535, 0.34635, 0.34735, 0.34835, 0.34935, 0.35035, 0.35135, 0.35235, 0.35335, 0.35435, 0.35536, 0.35636, 0.35736, 0.35836, 0.35936,\n", + " 0.36036, 0.36136, 0.36236, 0.36336, 0.36436, 0.36537, 0.36637, 0.36737, 0.36837, 0.36937, 0.37037, 0.37137, 0.37237, 0.37337, 0.37437, 0.37538, 0.37638, 0.37738, 0.37838, 0.37938, 0.38038, 0.38138, 0.38238, 0.38338,\n", + " 0.38438, 0.38539, 0.38639, 0.38739, 0.38839, 0.38939, 0.39039, 0.39139, 0.39239, 0.39339, 0.39439, 0.3954, 0.3964, 0.3974, 0.3984, 0.3994, 0.4004, 0.4014, 0.4024, 0.4034, 0.4044, 0.40541, 0.40641, 0.40741,\n", + " 0.40841, 0.40941, 0.41041, 0.41141, 0.41241, 0.41341, 0.41441, 0.41542, 0.41642, 0.41742, 0.41842, 0.41942, 0.42042, 0.42142, 0.42242, 0.42342, 0.42442, 0.42543, 0.42643, 0.42743, 0.42843, 0.42943, 0.43043, 0.43143,\n", + " 0.43243, 0.43343, 0.43443, 0.43544, 0.43644, 0.43744, 0.43844, 0.43944, 0.44044, 0.44144, 0.44244, 0.44344, 0.44444, 0.44545, 0.44645, 0.44745, 0.44845, 0.44945, 0.45045, 0.45145, 0.45245, 0.45345, 0.45445, 0.45546,\n", + " 0.45646, 0.45746, 0.45846, 0.45946, 0.46046, 0.46146, 0.46246, 0.46346, 0.46446, 0.46547, 0.46647, 0.46747, 0.46847, 0.46947, 0.47047, 0.47147, 0.47247, 0.47347, 0.47447, 0.47548, 0.47648, 0.47748, 0.47848, 0.47948,\n", + " 0.48048, 0.48148, 0.48248, 0.48348, 0.48448, 0.48549, 0.48649, 0.48749, 0.48849, 0.48949, 0.49049, 0.49149, 0.49249, 0.49349, 0.49449, 0.4955, 0.4965, 0.4975, 0.4985, 0.4995, 0.5005, 0.5015, 0.5025, 0.5035,\n", + " 0.5045, 0.50551, 0.50651, 0.50751, 0.50851, 0.50951, 0.51051, 0.51151, 0.51251, 0.51351, 0.51451, 0.51552, 0.51652, 0.51752, 0.51852, 0.51952, 0.52052, 0.52152, 0.52252, 0.52352, 0.52452, 0.52553, 0.52653, 0.52753,\n", + " 0.52853, 0.52953, 0.53053, 0.53153, 0.53253, 0.53353, 0.53453, 0.53554, 0.53654, 0.53754, 0.53854, 0.53954, 0.54054, 0.54154, 0.54254, 0.54354, 0.54454, 0.54555, 0.54655, 0.54755, 0.54855, 0.54955, 0.55055, 0.55155,\n", + " 0.55255, 0.55355, 0.55455, 0.55556, 0.55656, 0.55756, 0.55856, 0.55956, 0.56056, 0.56156, 0.56256, 0.56356, 0.56456, 0.56557, 0.56657, 0.56757, 0.56857, 0.56957, 0.57057, 0.57157, 0.57257, 0.57357, 0.57457, 0.57558,\n", + " 0.57658, 0.57758, 0.57858, 0.57958, 0.58058, 0.58158, 0.58258, 0.58358, 0.58458, 0.58559, 0.58659, 0.58759, 0.58859, 0.58959, 0.59059, 0.59159, 0.59259, 0.59359, 0.59459, 0.5956, 0.5966, 0.5976, 0.5986, 0.5996,\n", + " 0.6006, 0.6016, 0.6026, 0.6036, 0.6046, 0.60561, 0.60661, 0.60761, 0.60861, 0.60961, 0.61061, 0.61161, 0.61261, 0.61361, 0.61461, 0.61562, 0.61662, 0.61762, 0.61862, 0.61962, 0.62062, 0.62162, 0.62262, 0.62362,\n", + " 0.62462, 0.62563, 0.62663, 0.62763, 0.62863, 0.62963, 0.63063, 0.63163, 0.63263, 0.63363, 0.63463, 0.63564, 0.63664, 0.63764, 0.63864, 0.63964, 0.64064, 0.64164, 0.64264, 0.64364, 0.64464, 0.64565, 0.64665, 0.64765,\n", + " 0.64865, 0.64965, 0.65065, 0.65165, 0.65265, 0.65365, 0.65465, 0.65566, 0.65666, 0.65766, 0.65866, 0.65966, 0.66066, 0.66166, 0.66266, 0.66366, 0.66466, 0.66567, 0.66667, 0.66767, 0.66867, 0.66967, 0.67067, 0.67167,\n", + " 0.67267, 0.67367, 0.67467, 0.67568, 0.67668, 0.67768, 0.67868, 0.67968, 0.68068, 0.68168, 0.68268, 0.68368, 0.68468, 0.68569, 0.68669, 0.68769, 0.68869, 0.68969, 0.69069, 0.69169, 0.69269, 0.69369, 0.69469, 0.6957,\n", + " 0.6967, 0.6977, 0.6987, 0.6997, 0.7007, 0.7017, 0.7027, 0.7037, 0.7047, 0.70571, 0.70671, 0.70771, 0.70871, 0.70971, 0.71071, 0.71171, 0.71271, 0.71371, 0.71471, 0.71572, 0.71672, 0.71772, 0.71872, 0.71972,\n", + " 0.72072, 0.72172, 0.72272, 0.72372, 0.72472, 0.72573, 0.72673, 0.72773, 0.72873, 0.72973, 0.73073, 0.73173, 0.73273, 0.73373, 0.73473, 0.73574, 0.73674, 0.73774, 0.73874, 0.73974, 0.74074, 0.74174, 0.74274, 0.74374,\n", + " 0.74474, 0.74575, 0.74675, 0.74775, 0.74875, 0.74975, 0.75075, 0.75175, 0.75275, 0.75375, 0.75475, 0.75576, 0.75676, 0.75776, 0.75876, 0.75976, 0.76076, 0.76176, 0.76276, 0.76376, 0.76476, 0.76577, 0.76677, 0.76777,\n", + " 0.76877, 0.76977, 0.77077, 0.77177, 0.77277, 0.77377, 0.77477, 0.77578, 0.77678, 0.77778, 0.77878, 0.77978, 0.78078, 0.78178, 0.78278, 0.78378, 0.78478, 0.78579, 0.78679, 0.78779, 0.78879, 0.78979, 0.79079, 0.79179,\n", + " 0.79279, 0.79379, 0.79479, 0.7958, 0.7968, 0.7978, 0.7988, 0.7998, 0.8008, 0.8018, 0.8028, 0.8038, 0.8048, 0.80581, 0.80681, 0.80781, 0.80881, 0.80981, 0.81081, 0.81181, 0.81281, 0.81381, 0.81481, 0.81582,\n", + " 0.81682, 0.81782, 0.81882, 0.81982, 0.82082, 0.82182, 0.82282, 0.82382, 0.82482, 0.82583, 0.82683, 0.82783, 0.82883, 0.82983, 0.83083, 0.83183, 0.83283, 0.83383, 0.83483, 0.83584, 0.83684, 0.83784, 0.83884, 0.83984,\n", + " 0.84084, 0.84184, 0.84284, 0.84384, 0.84484, 0.84585, 0.84685, 0.84785, 0.84885, 0.84985, 0.85085, 0.85185, 0.85285, 0.85385, 0.85485, 0.85586, 0.85686, 0.85786, 0.85886, 0.85986, 0.86086, 0.86186, 0.86286, 0.86386,\n", + " 0.86486, 0.86587, 0.86687, 0.86787, 0.86887, 0.86987, 0.87087, 0.87187, 0.87287, 0.87387, 0.87487, 0.87588, 0.87688, 0.87788, 0.87888, 0.87988, 0.88088, 0.88188, 0.88288, 0.88388, 0.88488, 0.88589, 0.88689, 0.88789,\n", + " 0.88889, 0.88989, 0.89089, 0.89189, 0.89289, 0.89389, 0.89489, 0.8959, 0.8969, 0.8979, 0.8989, 0.8999, 0.9009, 0.9019, 0.9029, 0.9039, 0.9049, 0.90591, 0.90691, 0.90791, 0.90891, 0.90991, 0.91091, 0.91191,\n", + " 0.91291, 0.91391, 0.91491, 0.91592, 0.91692, 0.91792, 0.91892, 0.91992, 0.92092, 0.92192, 0.92292, 0.92392, 0.92492, 0.92593, 0.92693, 0.92793, 0.92893, 0.92993, 0.93093, 0.93193, 0.93293, 0.93393, 0.93493, 0.93594,\n", + " 0.93694, 0.93794, 0.93894, 0.93994, 0.94094, 0.94194, 0.94294, 0.94394, 0.94494, 0.94595, 0.94695, 0.94795, 0.94895, 0.94995, 0.95095, 0.95195, 0.95295, 0.95395, 0.95495, 0.95596, 0.95696, 0.95796, 0.95896, 0.95996,\n", + " 0.96096, 0.96196, 0.96296, 0.96396, 0.96496, 0.96597, 0.96697, 0.96797, 0.96897, 0.96997, 0.97097, 0.97197, 0.97297, 0.97397, 0.97497, 0.97598, 0.97698, 0.97798, 0.97898, 0.97998, 0.98098, 0.98198, 0.98298, 0.98398,\n", + " 0.98498, 0.98599, 0.98699, 0.98799, 0.98899, 0.98999, 0.99099, 0.99199, 0.99299, 0.99399, 0.99499, 0.996, 0.997, 0.998, 0.999, 1]), array([[ 1, 0.99148, 0.99063, 0.98754, 0.97727, 0.96765, 0.95227, 0.94094, 0.93154, 0.92214, 0.90942, 0.89249, 0.87771, 0.86046, 0.84924, 0.83973, 0.82284, 0.80807, 0.79258, 0.77063, 0.74312, 0.72322, 0.6992,\n", + " 0.67761, 0.65658, 0.63882, 0.61952, 0.6013, 0.58467, 0.56561, 0.54857, 0.53285, 0.51944, 0.50233, 0.48962, 0.47352, 0.45931, 0.4472, 0.43689, 0.42319, 0.41153, 0.39904, 0.38868, 0.37826, 0.36731, 0.35902,\n", + " 0.34989, 0.33955, 0.33181, 0.32416, 0.31541, 0.30575, 0.29685, 0.28913, 0.28034, 0.27314, 0.26683, 0.26038, 0.25373, 0.24753, 0.24143, 0.23654, 0.23198, 0.22686, 0.22175, 0.21613, 0.21037, 0.20533, 0.19971,\n", + " 0.19346, 0.18616, 0.18059, 0.173, 0.16691, 0.16, 0.15283, 0.14626, 0.13898, 0.13281, 0.12646, 0.11963, 0.1106, 0.10106, 0.089536, 0.08022, 0.071292, 0.062779, 0.054385, 0.043466, 0.034683, 0.026215, 0.019332,\n", + " 0.015176, 0.013412, 0.012028, 0.011, 0.01022, 0.0097173, 0.0092229, 0.0088772, 0.0086261, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267,\n", + " 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085267, 0.0085254, 0.0085242, 0.0085202, 0.0085104, 0.0085049, 0.0085008, 0.0084925, 0.0084814, 0.0084761, 0.0084549, 0.0084494, 0.0084434,\n", + " 0.0084261, 0.0084116, 0.008384, 0.0083502, 0.0083264, 0.0083167, 0.008307, 0.0082973, 0.0082876, 0.0082778, 0.0082681, 0.0082584, 0.0082487, 0.008239, 0.0082293, 0.0082195, 0.0082098, 0.0082001, 0.0081904, 0.0081807, 0.008171, 0.0081612, 0.0081515,\n", + " 0.0081418, 0.0081321, 0.0081224, 0.0081127, 0.008103, 0.0080932, 0.0080835, 0.0080738, 0.0080641, 0.0080544, 0.0080447, 0.0080349, 0.0080252, 0.0080155, 0.0080058, 0.0079961, 0.0079864, 0.0079767, 0.0079669, 0.0079572, 0.0079475, 0.0079378, 0.0079281,\n", + " 0.0079184, 0.0079086, 0.0078989, 0.0078892, 0.0078795, 0.0078698, 0.0078601, 0.0078503, 0.0078406, 0.0078309, 0.0078212, 0.0078115, 0.0078018, 0.0077921, 0.0077823, 0.0077726, 0.0077629, 0.0077532, 0.0077435, 0.0077338, 0.007724, 0.0077143, 0.0077046,\n", + " 0.0076949, 0.0076852, 0.0076755, 0.0076657, 0.007656, 0.0076463, 0.0076366, 0.0076269, 0.0076172, 0.0076075, 0.0075977, 0.007588, 0.0075783, 0.0075686, 0.0075589, 0.0075492, 0.0075394, 0.0075297, 0.00752, 0.0075103, 0.0075006, 0.0074909, 0.0074811,\n", + " 0.0074714, 0.0074617, 0.007452, 0.0074423, 0.0074326, 0.0074229, 0.0074131, 0.0074034, 0.0073937, 0.007384, 0.0073743, 0.0073646, 0.0073548, 0.0073451, 0.0073354, 0.0073257, 0.007316, 0.0073063, 0.0072965, 0.0072868, 0.0072771, 0.0072674, 0.0072577,\n", + " 0.007248, 0.0072383, 0.0072285, 0.0072188, 0.0072091, 0.0071994, 0.0071897, 0.00718, 0.0071702, 0.0071605, 0.0071508, 0.0071411, 0.0071314, 0.0071217, 0.0071119, 0.0071022, 0.0070925, 0.0070828, 0.0070731, 0.0070634, 0.0070537, 0.0070439, 0.0070342,\n", + " 0.0070245, 0.0070148, 0.0070051, 0.0069954, 0.0069856, 0.0069759, 0.0069662, 0.0069565, 0.0069468, 0.0069371, 0.0069273, 0.0069176, 0.0069079, 0.0068982, 0.0068885, 0.0068788, 0.0068691, 0.0068593, 0.0068496, 0.0068399, 0.0068302, 0.0068205, 0.0068108,\n", + " 0.006801, 0.0067913, 0.0067816, 0.0067719, 0.0067622, 0.0067525, 0.0067427, 0.006733, 0.0067233, 0.0067136, 0.0067039, 0.0066942, 0.0066845, 0.0066747, 0.006665, 0.0066553, 0.0066456, 0.0066359, 0.0066262, 0.0066164, 0.0066067, 0.006597, 0.0065873,\n", + " 0.0065776, 0.0065679, 0.0065581, 0.0065484, 0.0065387, 0.006529, 0.0065193, 0.0065096, 0.0064999, 0.0064901, 0.0064804, 0.0064707, 0.006461, 0.0064513, 0.0064416, 0.0064318, 0.0064221, 0.0064124, 0.0064027, 0.006393, 0.0063833, 0.0063735, 0.0063638,\n", + " 0.0063541, 0.0063444, 0.0063347, 0.006325, 0.0063153, 0.0063055, 0.0062958, 0.0062861, 0.0062764, 0.0062667, 0.006257, 0.0062472, 0.0062375, 0.0062278, 0.0062181, 0.0062084, 0.0061987, 0.0061889, 0.0061792, 0.0061695, 0.0061598, 0.0061501, 0.0061404,\n", + " 0.0061307, 0.0061209, 0.0061112, 0.0061015, 0.0060918, 0.0060821, 0.0060724, 0.0060626, 0.0060529, 0.0060432, 0.0060335, 0.0060238, 0.0060141, 0.0060043, 0.0059946, 0.0059849, 0.0059752, 0.0059655, 0.0059558, 0.0059461, 0.0059363, 0.0059266, 0.0059169,\n", + " 0.0059072, 0.0058975, 0.0058878, 0.005878, 0.0058683, 0.0058586, 0.0058489, 0.0058392, 0.0058295, 0.0058197, 0.00581, 0.0058003, 0.0057906, 0.0057809, 0.0057712, 0.0057615, 0.0057517, 0.005742, 0.0057323, 0.0057226, 0.0057129, 0.0057032, 0.0056934,\n", + " 0.0056837, 0.005674, 0.0056643, 0.0056546, 0.0056449, 0.0056351, 0.0056254, 0.0056157, 0.005606, 0.0055963, 0.0055866, 0.0055769, 0.0055671, 0.0055574, 0.0055477, 0.005538, 0.0055283, 0.0055186, 0.0055088, 0.0054991, 0.0054894, 0.0054797, 0.00547,\n", + " 0.0054603, 0.0054505, 0.0054408, 0.0054311, 0.0054214, 0.0054117, 0.005402, 0.0053923, 0.0053825, 0.0053728, 0.0053631, 0.0053534, 0.0053437, 0.005334, 0.0053242, 0.0053145, 0.0053048, 0.0052951, 0.0052854, 0.0052757, 0.0052659, 0.0052562, 0.0052465,\n", + " 0.0052368, 0.0052271, 0.0052174, 0.0052077, 0.0051979, 0.0051882, 0.0051785, 0.0051688, 0.0051591, 0.0051494, 0.0051396, 0.0051299, 0.0051202, 0.0051105, 0.0051008, 0.0050911, 0.0050813, 0.0050716, 0.0050619, 0.0050522, 0.0050425, 0.0050328, 0.0050231,\n", + " 0.0050133, 0.0050036, 0.0049939, 0.0049842, 0.0049745, 0.0049648, 0.004955, 0.0049453, 0.0049356, 0.0049259, 0.0049162, 0.0049065, 0.0048967, 0.004887, 0.0048773, 0.0048676, 0.0048579, 0.0048482, 0.0048385, 0.0048287, 0.004819, 0.0048093, 0.0047996,\n", + " 0.0047899, 0.0047802, 0.0047704, 0.0047607, 0.004751, 0.0047413, 0.0047316, 0.0047219, 0.0047122, 0.0047024, 0.0046927, 0.004683, 0.0046733, 0.0046636, 0.0046539, 0.0046441, 0.0046344, 0.0046247, 0.004615, 0.0046053, 0.0045956, 0.0045858, 0.0045761,\n", + " 0.0045664, 0.0045567, 0.004547, 0.0045373, 0.0045276, 0.0045178, 0.0045081, 0.0044984, 0.0044887, 0.004479, 0.0044693, 0.0044595, 0.0044498, 0.0044401, 0.0044304, 0.0044207, 0.004411, 0.0044012, 0.0043915, 0.0043818, 0.0043721, 0.0043624, 0.0043527,\n", + " 0.004343, 0.0043332, 0.0043235, 0.0043138, 0.0043041, 0.0042944, 0.0042847, 0.0042749, 0.0042652, 0.0042555, 0.0042458, 0.0042361, 0.0042264, 0.0042166, 0.0042069, 0.0041972, 0.0041875, 0.0041778, 0.0041681, 0.0041584, 0.0041486, 0.0041389, 0.0041292,\n", + " 0.0041195, 0.0041098, 0.0041001, 0.0040903, 0.0040806, 0.0040709, 0.0040612, 0.0040515, 0.0040418, 0.004032, 0.0040223, 0.0040126, 0.0040029, 0.0039932, 0.0039835, 0.0039738, 0.003964, 0.0039543, 0.0039446, 0.0039349, 0.0039252, 0.0039155, 0.0039057,\n", + " 0.003896, 0.0038863, 0.0038766, 0.0038669, 0.0038572, 0.0038474, 0.0038377, 0.003828, 0.0038183, 0.0038086, 0.0037989, 0.0037892, 0.0037794, 0.0037697, 0.00376, 0.0037503, 0.0037406, 0.0037309, 0.0037211, 0.0037114, 0.0037017, 0.003692, 0.0036823,\n", + " 0.0036726, 0.0036628, 0.0036531, 0.0036434, 0.0036337, 0.003624, 0.0036143, 0.0036046, 0.0035948, 0.0035851, 0.0035754, 0.0035657, 0.003556, 0.0035463, 0.0035365, 0.0035268, 0.0035171, 0.0035074, 0.0034977, 0.003488, 0.0034782, 0.0034685, 0.0034588,\n", + " 0.0034491, 0.0034394, 0.0034297, 0.00342, 0.0034102, 0.0034005, 0.0033908, 0.0033811, 0.0033714, 0.0033617, 0.0033519, 0.0033422, 0.0033325, 0.0033228, 0.0033131, 0.0033034, 0.0032936, 0.0032839, 0.0032742, 0.0032645, 0.0032548, 0.0032451, 0.0032354,\n", + " 0.0032256, 0.0032159, 0.0032062, 0.0031965, 0.0031868, 0.0031771, 0.0031673, 0.0031576, 0.0031479, 0.0031382, 0.0031285, 0.0031188, 0.003109, 0.0030993, 0.0030896, 0.0030799, 0.0030702, 0.0030605, 0.0030508, 0.003041, 0.0030313, 0.0030216, 0.0030119,\n", + " 0.0030022, 0.0029925, 0.0029827, 0.002973, 0.0029633, 0.0029536, 0.0029439, 0.0029342, 0.0029244, 0.0029147, 0.002905, 0.0028953, 0.0028856, 0.0028759, 0.0028662, 0.0028564, 0.0028467, 0.002837, 0.0028273, 0.0028176, 0.0028079, 0.0027981, 0.0027884,\n", + " 0.0027787, 0.002769, 0.0027593, 0.0027496, 0.0027398, 0.0027301, 0.0027204, 0.0027107, 0.002701, 0.0026913, 0.0026816, 0.0026718, 0.0026621, 0.0026524, 0.0026427, 0.002633, 0.0026233, 0.0026135, 0.0026038, 0.0025941, 0.0025844, 0.0025747, 0.002565,\n", + " 0.0025552, 0.0025455, 0.0025358, 0.0025261, 0.0025164, 0.0025067, 0.002497, 0.0024872, 0.0024775, 0.0024678, 0.0024581, 0.0024484, 0.0024387, 0.0024289, 0.0024192, 0.0024095, 0.0023998, 0.0023901, 0.0023804, 0.0023706, 0.0023609, 0.0023512, 0.0023415,\n", + " 0.0023318, 0.0023221, 0.0023124, 0.0023026, 0.0022929, 0.0022832, 0.0022735, 0.0022638, 0.0022541, 0.0022443, 0.0022346, 0.0022249, 0.0022152, 0.0022055, 0.0021958, 0.002186, 0.0021763, 0.0021666, 0.0021569, 0.0021472, 0.0021375, 0.0021278, 0.002118,\n", + " 0.0021083, 0.0020986, 0.0020889, 0.0020792, 0.0020695, 0.0020597, 0.00205, 0.0020403, 0.0020306, 0.0020209, 0.0020112, 0.0020014, 0.0019917, 0.001982, 0.0019723, 0.0019626, 0.0019529, 0.0019432, 0.0019334, 0.0019237, 0.001914, 0.0019043, 0.0018946,\n", + " 0.0018849, 0.0018751, 0.0018654, 0.0018557, 0.001846, 0.0018363, 0.0018266, 0.0018168, 0.0018071, 0.0017974, 0.0017877, 0.001778, 0.0017683, 0.0017586, 0.0017488, 0.0017391, 0.0017294, 0.0017197, 0.00171, 0.0017003, 0.0016905, 0.0016808, 0.0016711,\n", + " 0.0016614, 0.0016517, 0.001642, 0.0016322, 0.0016225, 0.0016128, 0.0016031, 0.0015934, 0.0015837, 0.001574, 0.0015642, 0.0015545, 0.0015448, 0.0015351, 0.0015254, 0.0015157, 0.0015059, 0.0014962, 0.0014865, 0.0014768, 0.0014671, 0.0014574, 0.0014477,\n", + " 0.0014379, 0.0014282, 0.0014185, 0.0014088, 0.0013991, 0.0013894, 0.0013796, 0.0013699, 0.0013602, 0.0013505, 0.0013408, 0.0013311, 0.0013213, 0.0013116, 0.0013019, 0.0012922, 0.0012825, 0.0012728, 0.0012631, 0.0012533, 0.0012436, 0.0012339, 0.0012242,\n", + " 0.0012145, 0.0012048, 0.001195, 0.0011853, 0.0011756, 0.0011659, 0.0011562, 0.0011465, 0.0011367, 0.001127, 0.0011173, 0.0011076, 0.0010979, 0.0010882, 0.0010785, 0.0010687, 0.001059, 0.0010493, 0.0010396, 0.0010299, 0.0010202, 0.0010104, 0.0010007,\n", + " 0.00099101, 0.00098129, 0.00097158, 0.00096186, 0.00095215, 0.00094243, 0.00093271, 0.000923, 0.00091328, 0.00090357, 0.00089385, 0.00088414, 0.00087442, 0.0008647, 0.00085499, 0.00084527, 0.00083556, 0.00082584, 0.00081612, 0.00080641, 0.00079669, 0.00078698, 0.00077726,\n", + " 0.00076755, 0.00075783, 0.00074811, 0.0007384, 0.00072868, 0.00071897, 0.00070925, 0.00069954, 0.00068982, 0.0006801, 0.00067039, 0.00066067, 0.00065096, 0.00064124, 0.00063153, 0.00062181, 0.00061209, 0.00060238, 0.00059266, 0.00058295, 0.00057323, 0.00056351, 0.0005538,\n", + " 0.00054408, 0.00053437, 0.00052465, 0.00051494, 0.00050522, 0.0004955, 0.00048579, 0.00047607, 0.00046636, 0.00045664, 0.00044693, 0.00043721, 0.00042749, 0.00041778, 0.00040806, 0.00039835, 0.00038863, 0.00037892, 0.0003692, 0.00035948, 0.00034977, 0.00034005, 0.00033034,\n", + " 0.00032062, 0.0003109, 0.00030119, 0.00029147, 0.00028176, 0.00027204, 0.00026233, 0.00025261, 0.00024289, 0.00023318, 0.00022346, 0.00021375, 0.00020403, 0.00019432, 0.0001846, 0.00017488, 0.00016517, 0.00015545, 0.00014574, 0.00013602, 0.00012631, 0.00011659, 0.00010687,\n", + " 9.7158e-05, 8.7442e-05, 7.7726e-05, 6.801e-05, 5.8295e-05, 4.8579e-05, 3.8863e-05, 2.9147e-05, 1.9432e-05, 9.7158e-06, 0]]), 'Recall', 'Precision'], [array([ 0, 0.001001, 0.002002, 0.003003, 0.004004, 0.005005, 0.006006, 0.007007, 0.008008, 0.009009, 0.01001, 0.011011, 0.012012, 0.013013, 0.014014, 0.015015, 0.016016, 0.017017, 0.018018, 0.019019, 0.02002, 0.021021, 0.022022, 0.023023,\n", + " 0.024024, 0.025025, 0.026026, 0.027027, 0.028028, 0.029029, 0.03003, 0.031031, 0.032032, 0.033033, 0.034034, 0.035035, 0.036036, 0.037037, 0.038038, 0.039039, 0.04004, 0.041041, 0.042042, 0.043043, 0.044044, 0.045045, 0.046046, 0.047047,\n", + " 0.048048, 0.049049, 0.05005, 0.051051, 0.052052, 0.053053, 0.054054, 0.055055, 0.056056, 0.057057, 0.058058, 0.059059, 0.06006, 0.061061, 0.062062, 0.063063, 0.064064, 0.065065, 0.066066, 0.067067, 0.068068, 0.069069, 0.07007, 0.071071,\n", + " 0.072072, 0.073073, 0.074074, 0.075075, 0.076076, 0.077077, 0.078078, 0.079079, 0.08008, 0.081081, 0.082082, 0.083083, 0.084084, 0.085085, 0.086086, 0.087087, 0.088088, 0.089089, 0.09009, 0.091091, 0.092092, 0.093093, 0.094094, 0.095095,\n", + " 0.096096, 0.097097, 0.098098, 0.099099, 0.1001, 0.1011, 0.1021, 0.1031, 0.1041, 0.10511, 0.10611, 0.10711, 0.10811, 0.10911, 0.11011, 0.11111, 0.11211, 0.11311, 0.11411, 0.11512, 0.11612, 0.11712, 0.11812, 0.11912,\n", + " 0.12012, 0.12112, 0.12212, 0.12312, 0.12412, 0.12513, 0.12613, 0.12713, 0.12813, 0.12913, 0.13013, 0.13113, 0.13213, 0.13313, 0.13413, 0.13514, 0.13614, 0.13714, 0.13814, 0.13914, 0.14014, 0.14114, 0.14214, 0.14314,\n", + " 0.14414, 0.14515, 0.14615, 0.14715, 0.14815, 0.14915, 0.15015, 0.15115, 0.15215, 0.15315, 0.15415, 0.15516, 0.15616, 0.15716, 0.15816, 0.15916, 0.16016, 0.16116, 0.16216, 0.16316, 0.16416, 0.16517, 0.16617, 0.16717,\n", + " 0.16817, 0.16917, 0.17017, 0.17117, 0.17217, 0.17317, 0.17417, 0.17518, 0.17618, 0.17718, 0.17818, 0.17918, 0.18018, 0.18118, 0.18218, 0.18318, 0.18418, 0.18519, 0.18619, 0.18719, 0.18819, 0.18919, 0.19019, 0.19119,\n", + " 0.19219, 0.19319, 0.19419, 0.1952, 0.1962, 0.1972, 0.1982, 0.1992, 0.2002, 0.2012, 0.2022, 0.2032, 0.2042, 0.20521, 0.20621, 0.20721, 0.20821, 0.20921, 0.21021, 0.21121, 0.21221, 0.21321, 0.21421, 0.21522,\n", + " 0.21622, 0.21722, 0.21822, 0.21922, 0.22022, 0.22122, 0.22222, 0.22322, 0.22422, 0.22523, 0.22623, 0.22723, 0.22823, 0.22923, 0.23023, 0.23123, 0.23223, 0.23323, 0.23423, 0.23524, 0.23624, 0.23724, 0.23824, 0.23924,\n", + " 0.24024, 0.24124, 0.24224, 0.24324, 0.24424, 0.24525, 0.24625, 0.24725, 0.24825, 0.24925, 0.25025, 0.25125, 0.25225, 0.25325, 0.25425, 0.25526, 0.25626, 0.25726, 0.25826, 0.25926, 0.26026, 0.26126, 0.26226, 0.26326,\n", + " 0.26426, 0.26527, 0.26627, 0.26727, 0.26827, 0.26927, 0.27027, 0.27127, 0.27227, 0.27327, 0.27427, 0.27528, 0.27628, 0.27728, 0.27828, 0.27928, 0.28028, 0.28128, 0.28228, 0.28328, 0.28428, 0.28529, 0.28629, 0.28729,\n", + " 0.28829, 0.28929, 0.29029, 0.29129, 0.29229, 0.29329, 0.29429, 0.2953, 0.2963, 0.2973, 0.2983, 0.2993, 0.3003, 0.3013, 0.3023, 0.3033, 0.3043, 0.30531, 0.30631, 0.30731, 0.30831, 0.30931, 0.31031, 0.31131,\n", + " 0.31231, 0.31331, 0.31431, 0.31532, 0.31632, 0.31732, 0.31832, 0.31932, 0.32032, 0.32132, 0.32232, 0.32332, 0.32432, 0.32533, 0.32633, 0.32733, 0.32833, 0.32933, 0.33033, 0.33133, 0.33233, 0.33333, 0.33433, 0.33534,\n", + " 0.33634, 0.33734, 0.33834, 0.33934, 0.34034, 0.34134, 0.34234, 0.34334, 0.34434, 0.34535, 0.34635, 0.34735, 0.34835, 0.34935, 0.35035, 0.35135, 0.35235, 0.35335, 0.35435, 0.35536, 0.35636, 0.35736, 0.35836, 0.35936,\n", + " 0.36036, 0.36136, 0.36236, 0.36336, 0.36436, 0.36537, 0.36637, 0.36737, 0.36837, 0.36937, 0.37037, 0.37137, 0.37237, 0.37337, 0.37437, 0.37538, 0.37638, 0.37738, 0.37838, 0.37938, 0.38038, 0.38138, 0.38238, 0.38338,\n", + " 0.38438, 0.38539, 0.38639, 0.38739, 0.38839, 0.38939, 0.39039, 0.39139, 0.39239, 0.39339, 0.39439, 0.3954, 0.3964, 0.3974, 0.3984, 0.3994, 0.4004, 0.4014, 0.4024, 0.4034, 0.4044, 0.40541, 0.40641, 0.40741,\n", + " 0.40841, 0.40941, 0.41041, 0.41141, 0.41241, 0.41341, 0.41441, 0.41542, 0.41642, 0.41742, 0.41842, 0.41942, 0.42042, 0.42142, 0.42242, 0.42342, 0.42442, 0.42543, 0.42643, 0.42743, 0.42843, 0.42943, 0.43043, 0.43143,\n", + " 0.43243, 0.43343, 0.43443, 0.43544, 0.43644, 0.43744, 0.43844, 0.43944, 0.44044, 0.44144, 0.44244, 0.44344, 0.44444, 0.44545, 0.44645, 0.44745, 0.44845, 0.44945, 0.45045, 0.45145, 0.45245, 0.45345, 0.45445, 0.45546,\n", + " 0.45646, 0.45746, 0.45846, 0.45946, 0.46046, 0.46146, 0.46246, 0.46346, 0.46446, 0.46547, 0.46647, 0.46747, 0.46847, 0.46947, 0.47047, 0.47147, 0.47247, 0.47347, 0.47447, 0.47548, 0.47648, 0.47748, 0.47848, 0.47948,\n", + " 0.48048, 0.48148, 0.48248, 0.48348, 0.48448, 0.48549, 0.48649, 0.48749, 0.48849, 0.48949, 0.49049, 0.49149, 0.49249, 0.49349, 0.49449, 0.4955, 0.4965, 0.4975, 0.4985, 0.4995, 0.5005, 0.5015, 0.5025, 0.5035,\n", + " 0.5045, 0.50551, 0.50651, 0.50751, 0.50851, 0.50951, 0.51051, 0.51151, 0.51251, 0.51351, 0.51451, 0.51552, 0.51652, 0.51752, 0.51852, 0.51952, 0.52052, 0.52152, 0.52252, 0.52352, 0.52452, 0.52553, 0.52653, 0.52753,\n", + " 0.52853, 0.52953, 0.53053, 0.53153, 0.53253, 0.53353, 0.53453, 0.53554, 0.53654, 0.53754, 0.53854, 0.53954, 0.54054, 0.54154, 0.54254, 0.54354, 0.54454, 0.54555, 0.54655, 0.54755, 0.54855, 0.54955, 0.55055, 0.55155,\n", + " 0.55255, 0.55355, 0.55455, 0.55556, 0.55656, 0.55756, 0.55856, 0.55956, 0.56056, 0.56156, 0.56256, 0.56356, 0.56456, 0.56557, 0.56657, 0.56757, 0.56857, 0.56957, 0.57057, 0.57157, 0.57257, 0.57357, 0.57457, 0.57558,\n", + " 0.57658, 0.57758, 0.57858, 0.57958, 0.58058, 0.58158, 0.58258, 0.58358, 0.58458, 0.58559, 0.58659, 0.58759, 0.58859, 0.58959, 0.59059, 0.59159, 0.59259, 0.59359, 0.59459, 0.5956, 0.5966, 0.5976, 0.5986, 0.5996,\n", + " 0.6006, 0.6016, 0.6026, 0.6036, 0.6046, 0.60561, 0.60661, 0.60761, 0.60861, 0.60961, 0.61061, 0.61161, 0.61261, 0.61361, 0.61461, 0.61562, 0.61662, 0.61762, 0.61862, 0.61962, 0.62062, 0.62162, 0.62262, 0.62362,\n", + " 0.62462, 0.62563, 0.62663, 0.62763, 0.62863, 0.62963, 0.63063, 0.63163, 0.63263, 0.63363, 0.63463, 0.63564, 0.63664, 0.63764, 0.63864, 0.63964, 0.64064, 0.64164, 0.64264, 0.64364, 0.64464, 0.64565, 0.64665, 0.64765,\n", + " 0.64865, 0.64965, 0.65065, 0.65165, 0.65265, 0.65365, 0.65465, 0.65566, 0.65666, 0.65766, 0.65866, 0.65966, 0.66066, 0.66166, 0.66266, 0.66366, 0.66466, 0.66567, 0.66667, 0.66767, 0.66867, 0.66967, 0.67067, 0.67167,\n", + " 0.67267, 0.67367, 0.67467, 0.67568, 0.67668, 0.67768, 0.67868, 0.67968, 0.68068, 0.68168, 0.68268, 0.68368, 0.68468, 0.68569, 0.68669, 0.68769, 0.68869, 0.68969, 0.69069, 0.69169, 0.69269, 0.69369, 0.69469, 0.6957,\n", + " 0.6967, 0.6977, 0.6987, 0.6997, 0.7007, 0.7017, 0.7027, 0.7037, 0.7047, 0.70571, 0.70671, 0.70771, 0.70871, 0.70971, 0.71071, 0.71171, 0.71271, 0.71371, 0.71471, 0.71572, 0.71672, 0.71772, 0.71872, 0.71972,\n", + " 0.72072, 0.72172, 0.72272, 0.72372, 0.72472, 0.72573, 0.72673, 0.72773, 0.72873, 0.72973, 0.73073, 0.73173, 0.73273, 0.73373, 0.73473, 0.73574, 0.73674, 0.73774, 0.73874, 0.73974, 0.74074, 0.74174, 0.74274, 0.74374,\n", + " 0.74474, 0.74575, 0.74675, 0.74775, 0.74875, 0.74975, 0.75075, 0.75175, 0.75275, 0.75375, 0.75475, 0.75576, 0.75676, 0.75776, 0.75876, 0.75976, 0.76076, 0.76176, 0.76276, 0.76376, 0.76476, 0.76577, 0.76677, 0.76777,\n", + " 0.76877, 0.76977, 0.77077, 0.77177, 0.77277, 0.77377, 0.77477, 0.77578, 0.77678, 0.77778, 0.77878, 0.77978, 0.78078, 0.78178, 0.78278, 0.78378, 0.78478, 0.78579, 0.78679, 0.78779, 0.78879, 0.78979, 0.79079, 0.79179,\n", + " 0.79279, 0.79379, 0.79479, 0.7958, 0.7968, 0.7978, 0.7988, 0.7998, 0.8008, 0.8018, 0.8028, 0.8038, 0.8048, 0.80581, 0.80681, 0.80781, 0.80881, 0.80981, 0.81081, 0.81181, 0.81281, 0.81381, 0.81481, 0.81582,\n", + " 0.81682, 0.81782, 0.81882, 0.81982, 0.82082, 0.82182, 0.82282, 0.82382, 0.82482, 0.82583, 0.82683, 0.82783, 0.82883, 0.82983, 0.83083, 0.83183, 0.83283, 0.83383, 0.83483, 0.83584, 0.83684, 0.83784, 0.83884, 0.83984,\n", + " 0.84084, 0.84184, 0.84284, 0.84384, 0.84484, 0.84585, 0.84685, 0.84785, 0.84885, 0.84985, 0.85085, 0.85185, 0.85285, 0.85385, 0.85485, 0.85586, 0.85686, 0.85786, 0.85886, 0.85986, 0.86086, 0.86186, 0.86286, 0.86386,\n", + " 0.86486, 0.86587, 0.86687, 0.86787, 0.86887, 0.86987, 0.87087, 0.87187, 0.87287, 0.87387, 0.87487, 0.87588, 0.87688, 0.87788, 0.87888, 0.87988, 0.88088, 0.88188, 0.88288, 0.88388, 0.88488, 0.88589, 0.88689, 0.88789,\n", + " 0.88889, 0.88989, 0.89089, 0.89189, 0.89289, 0.89389, 0.89489, 0.8959, 0.8969, 0.8979, 0.8989, 0.8999, 0.9009, 0.9019, 0.9029, 0.9039, 0.9049, 0.90591, 0.90691, 0.90791, 0.90891, 0.90991, 0.91091, 0.91191,\n", + " 0.91291, 0.91391, 0.91491, 0.91592, 0.91692, 0.91792, 0.91892, 0.91992, 0.92092, 0.92192, 0.92292, 0.92392, 0.92492, 0.92593, 0.92693, 0.92793, 0.92893, 0.92993, 0.93093, 0.93193, 0.93293, 0.93393, 0.93493, 0.93594,\n", + " 0.93694, 0.93794, 0.93894, 0.93994, 0.94094, 0.94194, 0.94294, 0.94394, 0.94494, 0.94595, 0.94695, 0.94795, 0.94895, 0.94995, 0.95095, 0.95195, 0.95295, 0.95395, 0.95495, 0.95596, 0.95696, 0.95796, 0.95896, 0.95996,\n", + " 0.96096, 0.96196, 0.96296, 0.96396, 0.96496, 0.96597, 0.96697, 0.96797, 0.96897, 0.96997, 0.97097, 0.97197, 0.97297, 0.97397, 0.97497, 0.97598, 0.97698, 0.97798, 0.97898, 0.97998, 0.98098, 0.98198, 0.98298, 0.98398,\n", + " 0.98498, 0.98599, 0.98699, 0.98799, 0.98899, 0.98999, 0.99099, 0.99199, 0.99299, 0.99399, 0.99499, 0.996, 0.997, 0.998, 0.999, 1]), array([[ 0.015735, 0.015735, 0.015965, 0.015869, 0.015745, 0.015599, 0.015503, 0.015453, 0.015401, 0.015406, 0.015466, 0.015575, 0.015819, 0.016215, 0.016808, 0.017522, 0.018261, 0.019116, 0.020019, 0.021039, 0.022195, 0.023513, 0.025083,\n", + " 0.027022, 0.029628, 0.032755, 0.036694, 0.041025, 0.04531, 0.049265, 0.052991, 0.056415, 0.059173, 0.061818, 0.064053, 0.066031, 0.067774, 0.06923, 0.070816, 0.071942, 0.073182, 0.07435, 0.075337, 0.076394, 0.077383, 0.078331,\n", + " 0.079255, 0.080119, 0.081065, 0.081937, 0.082756, 0.083486, 0.084355, 0.085045, 0.08576, 0.086432, 0.087082, 0.087676, 0.088408, 0.089012, 0.089579, 0.090159, 0.090644, 0.091202, 0.091637, 0.092169, 0.092637, 0.093062, 0.093486,\n", + " 0.093864, 0.09422, 0.094571, 0.094836, 0.095139, 0.095431, 0.095691, 0.095876, 0.096082, 0.096333, 0.096478, 0.09665, 0.096778, 0.09691, 0.097035, 0.097115, 0.097223, 0.097317, 0.097405, 0.097507, 0.097586, 0.097703, 0.097752,\n", + " 0.097847, 0.097921, 0.097969, 0.098033, 0.09813, 0.098222, 0.098303, 0.09836, 0.098439, 0.098522, 0.098608, 0.098674, 0.098693, 0.098772, 0.098796, 0.098869, 0.09891, 0.099004, 0.099052, 0.099057, 0.099113, 0.099167, 0.099168,\n", + " 0.099216, 0.099234, 0.099284, 0.099354, 0.099409, 0.09947, 0.099508, 0.099553, 0.099625, 0.099669, 0.099728, 0.099744, 0.099802, 0.099871, 0.099923, 0.099985, 0.10001, 0.10006, 0.10008, 0.10008, 0.10011, 0.10014, 0.10021,\n", + " 0.10022, 0.10026, 0.1003, 0.10031, 0.1003, 0.10036, 0.10037, 0.10038, 0.10039, 0.10039, 0.10042, 0.10048, 0.10053, 0.10053, 0.10056, 0.10061, 0.10064, 0.10064, 0.10068, 0.1007, 0.10071, 0.10074, 0.10074,\n", + " 0.10079, 0.10081, 0.10082, 0.10087, 0.10087, 0.10087, 0.1009, 0.10092, 0.10095, 0.10096, 0.10102, 0.10108, 0.10111, 0.1011, 0.10113, 0.10113, 0.10115, 0.1012, 0.10125, 0.10126, 0.10127, 0.10126, 0.1013,\n", + " 0.10133, 0.10135, 0.10137, 0.10138, 0.1014, 0.10142, 0.10141, 0.1014, 0.10139, 0.10136, 0.10136, 0.10138, 0.10142, 0.10144, 0.10146, 0.10149, 0.1015, 0.10155, 0.10154, 0.10154, 0.10159, 0.10162, 0.10164,\n", + " 0.10166, 0.10165, 0.10164, 0.10167, 0.10167, 0.10168, 0.10169, 0.1017, 0.1017, 0.10174, 0.10176, 0.10175, 0.10178, 0.10181, 0.1018, 0.10181, 0.10181, 0.1018, 0.10183, 0.10186, 0.10187, 0.10183, 0.10182,\n", + " 0.10181, 0.1018, 0.10179, 0.10177, 0.10177, 0.10177, 0.10179, 0.1018, 0.10178, 0.10178, 0.1018, 0.10183, 0.10183, 0.10184, 0.10186, 0.10188, 0.10188, 0.10188, 0.10188, 0.10188, 0.10187, 0.10188, 0.10188,\n", + " 0.10187, 0.10186, 0.10189, 0.10192, 0.10193, 0.10193, 0.10196, 0.10196, 0.10195, 0.10198, 0.10198, 0.10198, 0.10201, 0.102, 0.10202, 0.10202, 0.10201, 0.10201, 0.10202, 0.10204, 0.10204, 0.10206, 0.10204,\n", + " 0.10207, 0.10205, 0.10207, 0.10205, 0.10204, 0.10203, 0.10202, 0.10198, 0.10199, 0.10199, 0.10194, 0.10188, 0.10186, 0.10186, 0.10187, 0.10189, 0.10184, 0.10186, 0.10182, 0.10183, 0.10183, 0.10184, 0.10184,\n", + " 0.10185, 0.10188, 0.10188, 0.10185, 0.10187, 0.10188, 0.10189, 0.10188, 0.10188, 0.10187, 0.10188, 0.10191, 0.10188, 0.10191, 0.10192, 0.10192, 0.10191, 0.10193, 0.10192, 0.10192, 0.10188, 0.10186, 0.10186,\n", + " 0.10185, 0.10184, 0.10178, 0.10178, 0.10178, 0.10177, 0.10177, 0.10178, 0.10178, 0.10177, 0.10176, 0.10178, 0.10175, 0.10173, 0.10168, 0.10168, 0.10165, 0.10165, 0.10164, 0.10164, 0.10166, 0.10166, 0.10165,\n", + " 0.10162, 0.10161, 0.10162, 0.10163, 0.10161, 0.10156, 0.10156, 0.10157, 0.10154, 0.10153, 0.10148, 0.10146, 0.10147, 0.10147, 0.10148, 0.1015, 0.10149, 0.10148, 0.10144, 0.1014, 0.10141, 0.10136, 0.10137,\n", + " 0.10138, 0.10135, 0.10133, 0.10131, 0.10131, 0.10126, 0.10124, 0.10124, 0.10121, 0.1012, 0.10116, 0.10112, 0.1011, 0.10109, 0.10107, 0.10101, 0.10098, 0.10097, 0.10098, 0.10092, 0.1009, 0.10087, 0.10082,\n", + " 0.10077, 0.10077, 0.10074, 0.10075, 0.10075, 0.10073, 0.10072, 0.10073, 0.1007, 0.10068, 0.10067, 0.10065, 0.10062, 0.10062, 0.10059, 0.10055, 0.10047, 0.10046, 0.10045, 0.10043, 0.10042, 0.10042, 0.10036,\n", + " 0.10037, 0.10036, 0.10034, 0.10035, 0.10033, 0.10033, 0.10033, 0.10026, 0.10025, 0.10023, 0.10021, 0.10016, 0.10012, 0.1001, 0.10008, 0.10006, 0.10003, 0.10001, 0.099997, 0.09996, 0.099942, 0.099901, 0.099886,\n", + " 0.099859, 0.099849, 0.099813, 0.099766, 0.099717, 0.099713, 0.099707, 0.09969, 0.09967, 0.099645, 0.099621, 0.099618, 0.09958, 0.099555, 0.099531, 0.099498, 0.09949, 0.099463, 0.099423, 0.099388, 0.099356, 0.099347, 0.099314,\n", + " 0.099303, 0.09929, 0.099261, 0.099241, 0.099215, 0.099183, 0.099127, 0.099114, 0.09904, 0.099006, 0.099002, 0.098976, 0.09897, 0.098926, 0.098887, 0.098863, 0.098796, 0.098781, 0.098738, 0.098699, 0.098658, 0.098629, 0.098615,\n", + " 0.098623, 0.098589, 0.098572, 0.098512, 0.098472, 0.098444, 0.098422, 0.09836, 0.098336, 0.098307, 0.098277, 0.098227, 0.098155, 0.098099, 0.098051, 0.098049, 0.098009, 0.097969, 0.097951, 0.097857, 0.097849, 0.097846, 0.097805,\n", + " 0.097735, 0.097681, 0.097634, 0.097598, 0.097521, 0.097501, 0.097477, 0.097445, 0.09738, 0.097328, 0.097329, 0.097275, 0.097246, 0.097185, 0.097074, 0.09703, 0.09698, 0.096914, 0.09689, 0.096835, 0.096771, 0.096726, 0.096688,\n", + " 0.096673, 0.096635, 0.096603, 0.096514, 0.096454, 0.096389, 0.096356, 0.09634, 0.096317, 0.096307, 0.096284, 0.096219, 0.096178, 0.096157, 0.096118, 0.096066, 0.09601, 0.095968, 0.095936, 0.095922, 0.095919, 0.095899, 0.095886,\n", + " 0.09584, 0.095812, 0.095783, 0.095723, 0.095711, 0.095645, 0.095608, 0.095534, 0.095463, 0.095396, 0.095368, 0.095332, 0.095323, 0.095266, 0.095248, 0.095212, 0.095159, 0.095104, 0.095056, 0.094977, 0.094958, 0.09492, 0.094881,\n", + " 0.094848, 0.094782, 0.094773, 0.094746, 0.094759, 0.094643, 0.094569, 0.094516, 0.094455, 0.094397, 0.094332, 0.094303, 0.094252, 0.094206, 0.094173, 0.094141, 0.094103, 0.094059, 0.093999, 0.09397, 0.093958, 0.093887, 0.093853,\n", + " 0.093774, 0.093735, 0.093698, 0.093645, 0.093611, 0.093553, 0.093475, 0.09345, 0.093419, 0.093313, 0.093275, 0.093232, 0.093193, 0.093091, 0.09304, 0.09298, 0.092929, 0.092871, 0.092857, 0.092826, 0.092752, 0.092716, 0.092606,\n", + " 0.092512, 0.092491, 0.092484, 0.092434, 0.092348, 0.092283, 0.092253, 0.092191, 0.092129, 0.092012, 0.091985, 0.09184, 0.091768, 0.091694, 0.091666, 0.091613, 0.091569, 0.091537, 0.09149, 0.091344, 0.091285, 0.091212, 0.091155,\n", + " 0.091125, 0.091092, 0.091011, 0.090979, 0.09091, 0.090764, 0.090714, 0.090671, 0.090593, 0.090527, 0.090426, 0.090311, 0.090251, 0.090193, 0.090143, 0.090076, 0.090022, 0.089929, 0.089883, 0.089825, 0.089821, 0.089768, 0.089723,\n", + " 0.089656, 0.089632, 0.089606, 0.089454, 0.0894, 0.089299, 0.08923, 0.089152, 0.089051, 0.089034, 0.088905, 0.088872, 0.088776, 0.088631, 0.08857, 0.088464, 0.088439, 0.088319, 0.088241, 0.088213, 0.088028, 0.088012, 0.087878,\n", + " 0.087841, 0.087786, 0.087729, 0.087618, 0.087502, 0.087505, 0.087424, 0.087362, 0.087162, 0.087079, 0.086977, 0.086944, 0.086861, 0.086793, 0.086724, 0.08659, 0.086512, 0.086414, 0.086357, 0.086219, 0.086101, 0.086036, 0.085903,\n", + " 0.085875, 0.085755, 0.085583, 0.085504, 0.085374, 0.085294, 0.085188, 0.085066, 0.084837, 0.084756, 0.084657, 0.084585, 0.084292, 0.084139, 0.084064, 0.083852, 0.083716, 0.083636, 0.083457, 0.083169, 0.083105, 0.08299, 0.082922,\n", + " 0.082741, 0.082628, 0.082599, 0.082377, 0.082153, 0.082015, 0.081925, 0.081783, 0.081614, 0.081558, 0.081398, 0.081168, 0.081082, 0.080888, 0.08066, 0.080567, 0.080433, 0.080186, 0.080091, 0.079872, 0.079503, 0.079392, 0.079122,\n", + " 0.078989, 0.078755, 0.078687, 0.078435, 0.078322, 0.078099, 0.077991, 0.077833, 0.077638, 0.077577, 0.077323, 0.0772, 0.07709, 0.076903, 0.076705, 0.076465, 0.076347, 0.076147, 0.075807, 0.075694, 0.075435, 0.075168, 0.074939,\n", + " 0.074632, 0.074526, 0.074236, 0.074002, 0.073754, 0.073678, 0.073509, 0.073306, 0.072903, 0.072783, 0.072513, 0.072334, 0.072105, 0.07198, 0.071626, 0.071333, 0.071125, 0.070892, 0.070547, 0.070339, 0.070189, 0.069818, 0.0696,\n", + " 0.069281, 0.068817, 0.068664, 0.068278, 0.068001, 0.067734, 0.067354, 0.067155, 0.06677, 0.066432, 0.066193, 0.06577, 0.065548, 0.065448, 0.065136, 0.064568, 0.064464, 0.064105, 0.063744, 0.06349, 0.063077, 0.062728, 0.062337,\n", + " 0.062111, 0.061725, 0.061379, 0.060985, 0.060781, 0.060442, 0.059922, 0.05959, 0.059196, 0.058755, 0.058565, 0.058154, 0.057461, 0.057102, 0.056699, 0.056328, 0.055925, 0.055523, 0.055374, 0.054984, 0.054521, 0.05411, 0.0537,\n", + " 0.053271, 0.052888, 0.052383, 0.051873, 0.051495, 0.051031, 0.050681, 0.0502, 0.04986, 0.048981, 0.048591, 0.048168, 0.047752, 0.047294, 0.046899, 0.046452, 0.046053, 0.045443, 0.045164, 0.044686, 0.044228, 0.043675, 0.043369,\n", + " 0.042997, 0.042747, 0.04208, 0.041658, 0.04133, 0.040922, 0.040326, 0.039566, 0.039153, 0.038885, 0.038359, 0.038087, 0.03765, 0.037357, 0.036728, 0.036476, 0.035972, 0.035469, 0.035185, 0.034672, 0.034169, 0.033797, 0.033052,\n", + " 0.032625, 0.032305, 0.031663, 0.030908, 0.030489, 0.030035, 0.029587, 0.028815, 0.028493, 0.028167, 0.027493, 0.027117, 0.026227, 0.025581, 0.025164, 0.024675, 0.024273, 0.023695, 0.023322, 0.022477, 0.021899, 0.021513, 0.020877,\n", + " 0.020086, 0.019747, 0.019167, 0.018644, 0.017927, 0.017714, 0.017203, 0.016598, 0.016005, 0.01548, 0.014915, 0.014379, 0.013902, 0.013454, 0.012946, 0.012468, 0.011968, 0.011529, 0.01108, 0.010464, 0.0097986, 0.0094752, 0.0090928,\n", + " 0.0084358, 0.0079843, 0.0074543, 0.007071, 0.0064518, 0.0060288, 0.0055664, 0.0052413, 0.00468, 0.0041676, 0.0036648, 0.0033884, 0.0031711, 0.0027861, 0.0022629, 0.0019565, 0.0017093, 0.001304, 0.0011059, 0.00092762, 0.00077892, 0.00062033, 0.00051112,\n", + " 0.00034259, 0.00029267, 0.00024002, 0.00022248, 0.00018244, 0.00013251, 9.2466e-05, 7.2196e-05, 5.0683e-05, 4.0548e-05, 2.1271e-05, 1.3518e-05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'Confidence', 'F1'], [array([ 0, 0.001001, 0.002002, 0.003003, 0.004004, 0.005005, 0.006006, 0.007007, 0.008008, 0.009009, 0.01001, 0.011011, 0.012012, 0.013013, 0.014014, 0.015015, 0.016016, 0.017017, 0.018018, 0.019019, 0.02002, 0.021021, 0.022022, 0.023023,\n", + " 0.024024, 0.025025, 0.026026, 0.027027, 0.028028, 0.029029, 0.03003, 0.031031, 0.032032, 0.033033, 0.034034, 0.035035, 0.036036, 0.037037, 0.038038, 0.039039, 0.04004, 0.041041, 0.042042, 0.043043, 0.044044, 0.045045, 0.046046, 0.047047,\n", + " 0.048048, 0.049049, 0.05005, 0.051051, 0.052052, 0.053053, 0.054054, 0.055055, 0.056056, 0.057057, 0.058058, 0.059059, 0.06006, 0.061061, 0.062062, 0.063063, 0.064064, 0.065065, 0.066066, 0.067067, 0.068068, 0.069069, 0.07007, 0.071071,\n", + " 0.072072, 0.073073, 0.074074, 0.075075, 0.076076, 0.077077, 0.078078, 0.079079, 0.08008, 0.081081, 0.082082, 0.083083, 0.084084, 0.085085, 0.086086, 0.087087, 0.088088, 0.089089, 0.09009, 0.091091, 0.092092, 0.093093, 0.094094, 0.095095,\n", + " 0.096096, 0.097097, 0.098098, 0.099099, 0.1001, 0.1011, 0.1021, 0.1031, 0.1041, 0.10511, 0.10611, 0.10711, 0.10811, 0.10911, 0.11011, 0.11111, 0.11211, 0.11311, 0.11411, 0.11512, 0.11612, 0.11712, 0.11812, 0.11912,\n", + " 0.12012, 0.12112, 0.12212, 0.12312, 0.12412, 0.12513, 0.12613, 0.12713, 0.12813, 0.12913, 0.13013, 0.13113, 0.13213, 0.13313, 0.13413, 0.13514, 0.13614, 0.13714, 0.13814, 0.13914, 0.14014, 0.14114, 0.14214, 0.14314,\n", + " 0.14414, 0.14515, 0.14615, 0.14715, 0.14815, 0.14915, 0.15015, 0.15115, 0.15215, 0.15315, 0.15415, 0.15516, 0.15616, 0.15716, 0.15816, 0.15916, 0.16016, 0.16116, 0.16216, 0.16316, 0.16416, 0.16517, 0.16617, 0.16717,\n", + " 0.16817, 0.16917, 0.17017, 0.17117, 0.17217, 0.17317, 0.17417, 0.17518, 0.17618, 0.17718, 0.17818, 0.17918, 0.18018, 0.18118, 0.18218, 0.18318, 0.18418, 0.18519, 0.18619, 0.18719, 0.18819, 0.18919, 0.19019, 0.19119,\n", + " 0.19219, 0.19319, 0.19419, 0.1952, 0.1962, 0.1972, 0.1982, 0.1992, 0.2002, 0.2012, 0.2022, 0.2032, 0.2042, 0.20521, 0.20621, 0.20721, 0.20821, 0.20921, 0.21021, 0.21121, 0.21221, 0.21321, 0.21421, 0.21522,\n", + " 0.21622, 0.21722, 0.21822, 0.21922, 0.22022, 0.22122, 0.22222, 0.22322, 0.22422, 0.22523, 0.22623, 0.22723, 0.22823, 0.22923, 0.23023, 0.23123, 0.23223, 0.23323, 0.23423, 0.23524, 0.23624, 0.23724, 0.23824, 0.23924,\n", + " 0.24024, 0.24124, 0.24224, 0.24324, 0.24424, 0.24525, 0.24625, 0.24725, 0.24825, 0.24925, 0.25025, 0.25125, 0.25225, 0.25325, 0.25425, 0.25526, 0.25626, 0.25726, 0.25826, 0.25926, 0.26026, 0.26126, 0.26226, 0.26326,\n", + " 0.26426, 0.26527, 0.26627, 0.26727, 0.26827, 0.26927, 0.27027, 0.27127, 0.27227, 0.27327, 0.27427, 0.27528, 0.27628, 0.27728, 0.27828, 0.27928, 0.28028, 0.28128, 0.28228, 0.28328, 0.28428, 0.28529, 0.28629, 0.28729,\n", + " 0.28829, 0.28929, 0.29029, 0.29129, 0.29229, 0.29329, 0.29429, 0.2953, 0.2963, 0.2973, 0.2983, 0.2993, 0.3003, 0.3013, 0.3023, 0.3033, 0.3043, 0.30531, 0.30631, 0.30731, 0.30831, 0.30931, 0.31031, 0.31131,\n", + " 0.31231, 0.31331, 0.31431, 0.31532, 0.31632, 0.31732, 0.31832, 0.31932, 0.32032, 0.32132, 0.32232, 0.32332, 0.32432, 0.32533, 0.32633, 0.32733, 0.32833, 0.32933, 0.33033, 0.33133, 0.33233, 0.33333, 0.33433, 0.33534,\n", + " 0.33634, 0.33734, 0.33834, 0.33934, 0.34034, 0.34134, 0.34234, 0.34334, 0.34434, 0.34535, 0.34635, 0.34735, 0.34835, 0.34935, 0.35035, 0.35135, 0.35235, 0.35335, 0.35435, 0.35536, 0.35636, 0.35736, 0.35836, 0.35936,\n", + " 0.36036, 0.36136, 0.36236, 0.36336, 0.36436, 0.36537, 0.36637, 0.36737, 0.36837, 0.36937, 0.37037, 0.37137, 0.37237, 0.37337, 0.37437, 0.37538, 0.37638, 0.37738, 0.37838, 0.37938, 0.38038, 0.38138, 0.38238, 0.38338,\n", + " 0.38438, 0.38539, 0.38639, 0.38739, 0.38839, 0.38939, 0.39039, 0.39139, 0.39239, 0.39339, 0.39439, 0.3954, 0.3964, 0.3974, 0.3984, 0.3994, 0.4004, 0.4014, 0.4024, 0.4034, 0.4044, 0.40541, 0.40641, 0.40741,\n", + " 0.40841, 0.40941, 0.41041, 0.41141, 0.41241, 0.41341, 0.41441, 0.41542, 0.41642, 0.41742, 0.41842, 0.41942, 0.42042, 0.42142, 0.42242, 0.42342, 0.42442, 0.42543, 0.42643, 0.42743, 0.42843, 0.42943, 0.43043, 0.43143,\n", + " 0.43243, 0.43343, 0.43443, 0.43544, 0.43644, 0.43744, 0.43844, 0.43944, 0.44044, 0.44144, 0.44244, 0.44344, 0.44444, 0.44545, 0.44645, 0.44745, 0.44845, 0.44945, 0.45045, 0.45145, 0.45245, 0.45345, 0.45445, 0.45546,\n", + " 0.45646, 0.45746, 0.45846, 0.45946, 0.46046, 0.46146, 0.46246, 0.46346, 0.46446, 0.46547, 0.46647, 0.46747, 0.46847, 0.46947, 0.47047, 0.47147, 0.47247, 0.47347, 0.47447, 0.47548, 0.47648, 0.47748, 0.47848, 0.47948,\n", + " 0.48048, 0.48148, 0.48248, 0.48348, 0.48448, 0.48549, 0.48649, 0.48749, 0.48849, 0.48949, 0.49049, 0.49149, 0.49249, 0.49349, 0.49449, 0.4955, 0.4965, 0.4975, 0.4985, 0.4995, 0.5005, 0.5015, 0.5025, 0.5035,\n", + " 0.5045, 0.50551, 0.50651, 0.50751, 0.50851, 0.50951, 0.51051, 0.51151, 0.51251, 0.51351, 0.51451, 0.51552, 0.51652, 0.51752, 0.51852, 0.51952, 0.52052, 0.52152, 0.52252, 0.52352, 0.52452, 0.52553, 0.52653, 0.52753,\n", + " 0.52853, 0.52953, 0.53053, 0.53153, 0.53253, 0.53353, 0.53453, 0.53554, 0.53654, 0.53754, 0.53854, 0.53954, 0.54054, 0.54154, 0.54254, 0.54354, 0.54454, 0.54555, 0.54655, 0.54755, 0.54855, 0.54955, 0.55055, 0.55155,\n", + " 0.55255, 0.55355, 0.55455, 0.55556, 0.55656, 0.55756, 0.55856, 0.55956, 0.56056, 0.56156, 0.56256, 0.56356, 0.56456, 0.56557, 0.56657, 0.56757, 0.56857, 0.56957, 0.57057, 0.57157, 0.57257, 0.57357, 0.57457, 0.57558,\n", + " 0.57658, 0.57758, 0.57858, 0.57958, 0.58058, 0.58158, 0.58258, 0.58358, 0.58458, 0.58559, 0.58659, 0.58759, 0.58859, 0.58959, 0.59059, 0.59159, 0.59259, 0.59359, 0.59459, 0.5956, 0.5966, 0.5976, 0.5986, 0.5996,\n", + " 0.6006, 0.6016, 0.6026, 0.6036, 0.6046, 0.60561, 0.60661, 0.60761, 0.60861, 0.60961, 0.61061, 0.61161, 0.61261, 0.61361, 0.61461, 0.61562, 0.61662, 0.61762, 0.61862, 0.61962, 0.62062, 0.62162, 0.62262, 0.62362,\n", + " 0.62462, 0.62563, 0.62663, 0.62763, 0.62863, 0.62963, 0.63063, 0.63163, 0.63263, 0.63363, 0.63463, 0.63564, 0.63664, 0.63764, 0.63864, 0.63964, 0.64064, 0.64164, 0.64264, 0.64364, 0.64464, 0.64565, 0.64665, 0.64765,\n", + " 0.64865, 0.64965, 0.65065, 0.65165, 0.65265, 0.65365, 0.65465, 0.65566, 0.65666, 0.65766, 0.65866, 0.65966, 0.66066, 0.66166, 0.66266, 0.66366, 0.66466, 0.66567, 0.66667, 0.66767, 0.66867, 0.66967, 0.67067, 0.67167,\n", + " 0.67267, 0.67367, 0.67467, 0.67568, 0.67668, 0.67768, 0.67868, 0.67968, 0.68068, 0.68168, 0.68268, 0.68368, 0.68468, 0.68569, 0.68669, 0.68769, 0.68869, 0.68969, 0.69069, 0.69169, 0.69269, 0.69369, 0.69469, 0.6957,\n", + " 0.6967, 0.6977, 0.6987, 0.6997, 0.7007, 0.7017, 0.7027, 0.7037, 0.7047, 0.70571, 0.70671, 0.70771, 0.70871, 0.70971, 0.71071, 0.71171, 0.71271, 0.71371, 0.71471, 0.71572, 0.71672, 0.71772, 0.71872, 0.71972,\n", + " 0.72072, 0.72172, 0.72272, 0.72372, 0.72472, 0.72573, 0.72673, 0.72773, 0.72873, 0.72973, 0.73073, 0.73173, 0.73273, 0.73373, 0.73473, 0.73574, 0.73674, 0.73774, 0.73874, 0.73974, 0.74074, 0.74174, 0.74274, 0.74374,\n", + " 0.74474, 0.74575, 0.74675, 0.74775, 0.74875, 0.74975, 0.75075, 0.75175, 0.75275, 0.75375, 0.75475, 0.75576, 0.75676, 0.75776, 0.75876, 0.75976, 0.76076, 0.76176, 0.76276, 0.76376, 0.76476, 0.76577, 0.76677, 0.76777,\n", + " 0.76877, 0.76977, 0.77077, 0.77177, 0.77277, 0.77377, 0.77477, 0.77578, 0.77678, 0.77778, 0.77878, 0.77978, 0.78078, 0.78178, 0.78278, 0.78378, 0.78478, 0.78579, 0.78679, 0.78779, 0.78879, 0.78979, 0.79079, 0.79179,\n", + " 0.79279, 0.79379, 0.79479, 0.7958, 0.7968, 0.7978, 0.7988, 0.7998, 0.8008, 0.8018, 0.8028, 0.8038, 0.8048, 0.80581, 0.80681, 0.80781, 0.80881, 0.80981, 0.81081, 0.81181, 0.81281, 0.81381, 0.81481, 0.81582,\n", + " 0.81682, 0.81782, 0.81882, 0.81982, 0.82082, 0.82182, 0.82282, 0.82382, 0.82482, 0.82583, 0.82683, 0.82783, 0.82883, 0.82983, 0.83083, 0.83183, 0.83283, 0.83383, 0.83483, 0.83584, 0.83684, 0.83784, 0.83884, 0.83984,\n", + " 0.84084, 0.84184, 0.84284, 0.84384, 0.84484, 0.84585, 0.84685, 0.84785, 0.84885, 0.84985, 0.85085, 0.85185, 0.85285, 0.85385, 0.85485, 0.85586, 0.85686, 0.85786, 0.85886, 0.85986, 0.86086, 0.86186, 0.86286, 0.86386,\n", + " 0.86486, 0.86587, 0.86687, 0.86787, 0.86887, 0.86987, 0.87087, 0.87187, 0.87287, 0.87387, 0.87487, 0.87588, 0.87688, 0.87788, 0.87888, 0.87988, 0.88088, 0.88188, 0.88288, 0.88388, 0.88488, 0.88589, 0.88689, 0.88789,\n", + " 0.88889, 0.88989, 0.89089, 0.89189, 0.89289, 0.89389, 0.89489, 0.8959, 0.8969, 0.8979, 0.8989, 0.8999, 0.9009, 0.9019, 0.9029, 0.9039, 0.9049, 0.90591, 0.90691, 0.90791, 0.90891, 0.90991, 0.91091, 0.91191,\n", + " 0.91291, 0.91391, 0.91491, 0.91592, 0.91692, 0.91792, 0.91892, 0.91992, 0.92092, 0.92192, 0.92292, 0.92392, 0.92492, 0.92593, 0.92693, 0.92793, 0.92893, 0.92993, 0.93093, 0.93193, 0.93293, 0.93393, 0.93493, 0.93594,\n", + " 0.93694, 0.93794, 0.93894, 0.93994, 0.94094, 0.94194, 0.94294, 0.94394, 0.94494, 0.94595, 0.94695, 0.94795, 0.94895, 0.94995, 0.95095, 0.95195, 0.95295, 0.95395, 0.95495, 0.95596, 0.95696, 0.95796, 0.95896, 0.95996,\n", + " 0.96096, 0.96196, 0.96296, 0.96396, 0.96496, 0.96597, 0.96697, 0.96797, 0.96897, 0.96997, 0.97097, 0.97197, 0.97297, 0.97397, 0.97497, 0.97598, 0.97698, 0.97798, 0.97898, 0.97998, 0.98098, 0.98198, 0.98298, 0.98398,\n", + " 0.98498, 0.98599, 0.98699, 0.98799, 0.98899, 0.98999, 0.99099, 0.99199, 0.99299, 0.99399, 0.99499, 0.996, 0.997, 0.998, 0.999, 1]), array([[ 0.0083297, 0.0083297, 0.0085105, 0.0084882, 0.0084408, 0.0083768, 0.0083374, 0.0083215, 0.008304, 0.0083172, 0.0083623, 0.0084353, 0.0085867, 0.0088287, 0.0091908, 0.0096286, 0.010086, 0.01062, 0.01119, 0.011841, 0.012589, 0.013457, 0.014511,\n", + " 0.015841, 0.017677, 0.019973, 0.023012, 0.026561, 0.030324, 0.034037, 0.037771, 0.041429, 0.044564, 0.047721, 0.050538, 0.053131, 0.055514, 0.057627, 0.059952, 0.061722, 0.063687, 0.065589, 0.067305, 0.069173, 0.070933, 0.072704,\n", + " 0.074495, 0.076173, 0.078061, 0.079872, 0.081625, 0.083248, 0.085159, 0.086817, 0.088498, 0.090162, 0.091824, 0.093332, 0.09513, 0.096708, 0.098233, 0.09985, 0.10132, 0.10296, 0.10436, 0.10595, 0.10739, 0.1088, 0.11032,\n", + " 0.11166, 0.11293, 0.11416, 0.11518, 0.11633, 0.11742, 0.11848, 0.11933, 0.12025, 0.12127, 0.12204, 0.12286, 0.12352, 0.12414, 0.12483, 0.1254, 0.12606, 0.12661, 0.12713, 0.12773, 0.12821, 0.12884, 0.12928,\n", + " 0.1298, 0.13025, 0.13069, 0.13114, 0.13167, 0.13217, 0.13265, 0.13299, 0.13344, 0.13393, 0.13437, 0.13483, 0.13511, 0.13556, 0.13592, 0.13638, 0.13671, 0.13721, 0.13763, 0.13791, 0.13834, 0.13868, 0.13901,\n", + " 0.13933, 0.13968, 0.14001, 0.14047, 0.1408, 0.14123, 0.14155, 0.14186, 0.14228, 0.14265, 0.1431, 0.14341, 0.14372, 0.14417, 0.14447, 0.1448, 0.14507, 0.14552, 0.14577, 0.14604, 0.14634, 0.14676, 0.1471,\n", + " 0.14735, 0.14765, 0.14797, 0.14821, 0.14843, 0.14876, 0.14904, 0.14945, 0.14974, 0.15002, 0.15031, 0.15062, 0.15096, 0.15121, 0.15152, 0.15184, 0.15216, 0.15241, 0.15273, 0.15305, 0.15319, 0.1535, 0.15377,\n", + " 0.15409, 0.15438, 0.15466, 0.15499, 0.15526, 0.15555, 0.15574, 0.15606, 0.15638, 0.15668, 0.15705, 0.15744, 0.15763, 0.15791, 0.15823, 0.15848, 0.15866, 0.15901, 0.15936, 0.1597, 0.15988, 0.16016, 0.16046,\n", + " 0.16066, 0.16093, 0.1612, 0.1615, 0.16166, 0.16196, 0.16221, 0.16234, 0.16262, 0.16286, 0.16299, 0.16331, 0.16367, 0.16386, 0.16415, 0.16437, 0.16468, 0.16508, 0.16523, 0.16552, 0.16578, 0.16612, 0.1663,\n", + " 0.16664, 0.16689, 0.16702, 0.16732, 0.16747, 0.16777, 0.16795, 0.16824, 0.16841, 0.1688, 0.16899, 0.16925, 0.16948, 0.16985, 0.16999, 0.17029, 0.17046, 0.17074, 0.17095, 0.17132, 0.17149, 0.17176, 0.1719,\n", + " 0.17221, 0.17234, 0.17249, 0.17276, 0.17292, 0.17323, 0.17345, 0.17376, 0.1739, 0.17407, 0.17442, 0.17464, 0.17495, 0.17511, 0.17529, 0.17565, 0.17581, 0.17601, 0.17636, 0.17654, 0.17689, 0.17708, 0.17723,\n", + " 0.17751, 0.17765, 0.1779, 0.17828, 0.17845, 0.17865, 0.17901, 0.17916, 0.1795, 0.1797, 0.17988, 0.18004, 0.18044, 0.18057, 0.18077, 0.18108, 0.18123, 0.18142, 0.18178, 0.18197, 0.18214, 0.18236, 0.18268,\n", + " 0.18292, 0.18304, 0.18324, 0.18356, 0.18373, 0.18386, 0.18417, 0.18429, 0.18448, 0.18463, 0.18488, 0.18496, 0.18511, 0.18528, 0.18561, 0.18582, 0.18591, 0.18612, 0.18644, 0.18664, 0.18682, 0.18702, 0.18721,\n", + " 0.18762, 0.18784, 0.18805, 0.18817, 0.18861, 0.18882, 0.18902, 0.18918, 0.18936, 0.18971, 0.18989, 0.19015, 0.19031, 0.19074, 0.19095, 0.19117, 0.19133, 0.19153, 0.19169, 0.19189, 0.19212, 0.19226, 0.19248,\n", + " 0.19263, 0.19282, 0.19309, 0.1933, 0.19352, 0.19366, 0.19383, 0.19405, 0.1944, 0.19462, 0.19482, 0.19508, 0.19523, 0.19538, 0.19552, 0.19592, 0.19605, 0.19626, 0.19647, 0.19668, 0.19691, 0.19732, 0.19752,\n", + " 0.19767, 0.1979, 0.19818, 0.19841, 0.19856, 0.19885, 0.19908, 0.19932, 0.19951, 0.19973, 0.19985, 0.20004, 0.20029, 0.20052, 0.20074, 0.20117, 0.20141, 0.20163, 0.20174, 0.2019, 0.20212, 0.20223, 0.20246,\n", + " 0.20268, 0.20285, 0.20322, 0.20342, 0.20365, 0.20379, 0.20395, 0.20418, 0.20431, 0.20451, 0.20467, 0.20483, 0.20523, 0.20545, 0.20563, 0.20576, 0.20592, 0.20611, 0.20631, 0.20642, 0.20659, 0.20678, 0.20715,\n", + " 0.20727, 0.2075, 0.20764, 0.20788, 0.20814, 0.20839, 0.20858, 0.20883, 0.20901, 0.20923, 0.20941, 0.2096, 0.20979, 0.21001, 0.21018, 0.21037, 0.21061, 0.21084, 0.21108, 0.2113, 0.21149, 0.21175, 0.21188,\n", + " 0.21209, 0.21237, 0.21261, 0.21289, 0.21309, 0.21332, 0.21357, 0.21371, 0.21393, 0.21441, 0.21463, 0.21479, 0.21495, 0.21515, 0.21541, 0.21563, 0.21587, 0.21607, 0.21629, 0.21644, 0.21665, 0.21682, 0.217,\n", + " 0.2172, 0.21744, 0.21765, 0.21782, 0.21797, 0.21821, 0.21849, 0.21872, 0.21893, 0.21914, 0.21937, 0.21963, 0.21983, 0.2204, 0.22063, 0.22083, 0.2211, 0.22137, 0.22155, 0.22174, 0.22196, 0.22223, 0.22243,\n", + " 0.22268, 0.22291, 0.22316, 0.22344, 0.22366, 0.22389, 0.22405, 0.22428, 0.22439, 0.22459, 0.22493, 0.22516, 0.2254, 0.22563, 0.2258, 0.22599, 0.22617, 0.22639, 0.22657, 0.2268, 0.22727, 0.22748, 0.22771,\n", + " 0.228, 0.22822, 0.22849, 0.22863, 0.22886, 0.22909, 0.22931, 0.22945, 0.2297, 0.22998, 0.23026, 0.2304, 0.23055, 0.23072, 0.23093, 0.23126, 0.23149, 0.23166, 0.23195, 0.23203, 0.23232, 0.23264, 0.23287,\n", + " 0.23312, 0.23329, 0.23353, 0.23368, 0.2338, 0.23407, 0.23436, 0.23471, 0.23489, 0.23508, 0.23538, 0.23563, 0.23594, 0.23618, 0.23649, 0.23671, 0.23693, 0.23712, 0.23743, 0.23761, 0.23773, 0.23803, 0.23834,\n", + " 0.2386, 0.23884, 0.23915, 0.23928, 0.23947, 0.23968, 0.23997, 0.24025, 0.24051, 0.24087, 0.24113, 0.24135, 0.24155, 0.24185, 0.24215, 0.24239, 0.24265, 0.24292, 0.24321, 0.24353, 0.24384, 0.24417, 0.2445,\n", + " 0.24472, 0.24511, 0.24539, 0.24563, 0.24597, 0.24655, 0.24682, 0.24692, 0.24713, 0.24726, 0.24758, 0.24788, 0.24828, 0.24855, 0.24893, 0.24924, 0.24948, 0.24979, 0.25004, 0.25028, 0.25056, 0.25093, 0.25121,\n", + " 0.25146, 0.25166, 0.25198, 0.25234, 0.2528, 0.25319, 0.25344, 0.25372, 0.25397, 0.25419, 0.25447, 0.25482, 0.25513, 0.25542, 0.25571, 0.25601, 0.25643, 0.25683, 0.25714, 0.2575, 0.25791, 0.25854, 0.25883,\n", + " 0.25904, 0.2594, 0.25971, 0.26007, 0.26037, 0.26065, 0.26086, 0.26123, 0.26168, 0.26233, 0.26268, 0.26306, 0.2634, 0.26359, 0.26395, 0.26428, 0.26459, 0.26491, 0.26535, 0.26572, 0.26606, 0.26646, 0.2671,\n", + " 0.26733, 0.26777, 0.26834, 0.26876, 0.26903, 0.2693, 0.26971, 0.27004, 0.27039, 0.2706, 0.27109, 0.27177, 0.27206, 0.27244, 0.27291, 0.27331, 0.27387, 0.27428, 0.27468, 0.27526, 0.2757, 0.27601, 0.27646,\n", + " 0.27694, 0.27743, 0.27777, 0.2782, 0.27859, 0.27924, 0.2796, 0.28011, 0.28048, 0.28094, 0.28128, 0.28162, 0.28194, 0.28245, 0.28366, 0.28408, 0.28461, 0.28486, 0.28604, 0.28657, 0.28708, 0.28774, 0.2881,\n", + " 0.28876, 0.28927, 0.28991, 0.29073, 0.29109, 0.2915, 0.29201, 0.29247, 0.29288, 0.29361, 0.29467, 0.29505, 0.29561, 0.29653, 0.29691, 0.29743, 0.29802, 0.29838, 0.29874, 0.29941, 0.30047, 0.30109, 0.30133,\n", + " 0.30199, 0.30274, 0.30329, 0.30443, 0.30502, 0.30574, 0.30642, 0.30689, 0.30806, 0.30872, 0.31002, 0.31066, 0.31134, 0.31186, 0.31254, 0.31385, 0.31429, 0.31501, 0.31566, 0.31612, 0.31751, 0.31817, 0.31876,\n", + " 0.31942, 0.32001, 0.32123, 0.32171, 0.32226, 0.32295, 0.3245, 0.32509, 0.32637, 0.32709, 0.32795, 0.3287, 0.32985, 0.33047, 0.33119, 0.33232, 0.33288, 0.33364, 0.3342, 0.33542, 0.33605, 0.33679, 0.33755,\n", + " 0.33889, 0.33968, 0.34078, 0.34233, 0.34389, 0.34468, 0.34557, 0.34655, 0.34825, 0.34901, 0.34966, 0.35144, 0.35229, 0.35286, 0.3543, 0.35514, 0.35596, 0.3579, 0.35879, 0.35942, 0.36064, 0.36153, 0.36304,\n", + " 0.36405, 0.36587, 0.36698, 0.36871, 0.3697, 0.37179, 0.3726, 0.37334, 0.37536, 0.37658, 0.37816, 0.37913, 0.37999, 0.38218, 0.38297, 0.38556, 0.38649, 0.38732, 0.38895, 0.39021, 0.39232, 0.39453, 0.39531,\n", + " 0.39763, 0.39853, 0.40106, 0.40218, 0.40457, 0.40605, 0.40892, 0.41004, 0.41181, 0.41282, 0.41538, 0.4162, 0.41902, 0.42026, 0.42264, 0.42536, 0.42647, 0.42956, 0.43176, 0.4343, 0.43564, 0.438, 0.4393,\n", + " 0.44156, 0.44395, 0.44592, 0.44828, 0.44986, 0.45321, 0.45562, 0.45683, 0.45974, 0.4625, 0.46387, 0.46706, 0.47059, 0.47258, 0.47587, 0.48044, 0.48233, 0.48569, 0.4887, 0.49002, 0.49278, 0.49686, 0.5004,\n", + " 0.50129, 0.50438, 0.50829, 0.51177, 0.51369, 0.51811, 0.52178, 0.5261, 0.5292, 0.53213, 0.53427, 0.53799, 0.54238, 0.54641, 0.55075, 0.55473, 0.55842, 0.56182, 0.56399, 0.56852, 0.57297, 0.57759, 0.58238,\n", + " 0.58673, 0.59103, 0.59585, 0.59968, 0.60475, 0.60935, 0.61384, 0.61678, 0.62129, 0.62915, 0.63298, 0.63875, 0.64396, 0.64756, 0.65116, 0.65592, 0.66017, 0.66739, 0.67269, 0.67609, 0.68011, 0.68618, 0.69063,\n", + " 0.69488, 0.69913, 0.7064, 0.71076, 0.71506, 0.7226, 0.72977, 0.73507, 0.74028, 0.74446, 0.7514, 0.75767, 0.76368, 0.76786, 0.77335, 0.77654, 0.78537, 0.78871, 0.7924, 0.79664, 0.79828, 0.80346, 0.80969,\n", + " 0.8115, 0.8147, 0.82014, 0.82986, 0.83161, 0.83684, 0.83934, 0.84208, 0.84328, 0.84607, 0.85028, 0.8528, 0.8563, 0.86057, 0.86299, 0.86769, 0.87304, 0.87777, 0.88063, 0.88778, 0.89181, 0.89403, 0.90203,\n", + " 0.90845, 0.90905, 0.91456, 0.91718, 0.92009, 0.92295, 0.92682, 0.92922, 0.93047, 0.93375, 0.93425, 0.93433, 0.94088, 0.94289, 0.94549, 0.94844, 0.95071, 0.95669, 0.95997, 0.96377, 0.96793, 0.97174, 0.97365,\n", + " 0.97497, 0.9771, 0.98439, 0.98626, 0.98644, 0.98709, 0.98948, 0.98884, 0.98751, 0.99062, 0.98934, 0.99134, 0.99075, 0.98948, 0.98707, 0.98508, 0.99425, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]), 'Confidence', 'Precision'], [array([ 0, 0.001001, 0.002002, 0.003003, 0.004004, 0.005005, 0.006006, 0.007007, 0.008008, 0.009009, 0.01001, 0.011011, 0.012012, 0.013013, 0.014014, 0.015015, 0.016016, 0.017017, 0.018018, 0.019019, 0.02002, 0.021021, 0.022022, 0.023023,\n", + " 0.024024, 0.025025, 0.026026, 0.027027, 0.028028, 0.029029, 0.03003, 0.031031, 0.032032, 0.033033, 0.034034, 0.035035, 0.036036, 0.037037, 0.038038, 0.039039, 0.04004, 0.041041, 0.042042, 0.043043, 0.044044, 0.045045, 0.046046, 0.047047,\n", + " 0.048048, 0.049049, 0.05005, 0.051051, 0.052052, 0.053053, 0.054054, 0.055055, 0.056056, 0.057057, 0.058058, 0.059059, 0.06006, 0.061061, 0.062062, 0.063063, 0.064064, 0.065065, 0.066066, 0.067067, 0.068068, 0.069069, 0.07007, 0.071071,\n", + " 0.072072, 0.073073, 0.074074, 0.075075, 0.076076, 0.077077, 0.078078, 0.079079, 0.08008, 0.081081, 0.082082, 0.083083, 0.084084, 0.085085, 0.086086, 0.087087, 0.088088, 0.089089, 0.09009, 0.091091, 0.092092, 0.093093, 0.094094, 0.095095,\n", + " 0.096096, 0.097097, 0.098098, 0.099099, 0.1001, 0.1011, 0.1021, 0.1031, 0.1041, 0.10511, 0.10611, 0.10711, 0.10811, 0.10911, 0.11011, 0.11111, 0.11211, 0.11311, 0.11411, 0.11512, 0.11612, 0.11712, 0.11812, 0.11912,\n", + " 0.12012, 0.12112, 0.12212, 0.12312, 0.12412, 0.12513, 0.12613, 0.12713, 0.12813, 0.12913, 0.13013, 0.13113, 0.13213, 0.13313, 0.13413, 0.13514, 0.13614, 0.13714, 0.13814, 0.13914, 0.14014, 0.14114, 0.14214, 0.14314,\n", + " 0.14414, 0.14515, 0.14615, 0.14715, 0.14815, 0.14915, 0.15015, 0.15115, 0.15215, 0.15315, 0.15415, 0.15516, 0.15616, 0.15716, 0.15816, 0.15916, 0.16016, 0.16116, 0.16216, 0.16316, 0.16416, 0.16517, 0.16617, 0.16717,\n", + " 0.16817, 0.16917, 0.17017, 0.17117, 0.17217, 0.17317, 0.17417, 0.17518, 0.17618, 0.17718, 0.17818, 0.17918, 0.18018, 0.18118, 0.18218, 0.18318, 0.18418, 0.18519, 0.18619, 0.18719, 0.18819, 0.18919, 0.19019, 0.19119,\n", + " 0.19219, 0.19319, 0.19419, 0.1952, 0.1962, 0.1972, 0.1982, 0.1992, 0.2002, 0.2012, 0.2022, 0.2032, 0.2042, 0.20521, 0.20621, 0.20721, 0.20821, 0.20921, 0.21021, 0.21121, 0.21221, 0.21321, 0.21421, 0.21522,\n", + " 0.21622, 0.21722, 0.21822, 0.21922, 0.22022, 0.22122, 0.22222, 0.22322, 0.22422, 0.22523, 0.22623, 0.22723, 0.22823, 0.22923, 0.23023, 0.23123, 0.23223, 0.23323, 0.23423, 0.23524, 0.23624, 0.23724, 0.23824, 0.23924,\n", + " 0.24024, 0.24124, 0.24224, 0.24324, 0.24424, 0.24525, 0.24625, 0.24725, 0.24825, 0.24925, 0.25025, 0.25125, 0.25225, 0.25325, 0.25425, 0.25526, 0.25626, 0.25726, 0.25826, 0.25926, 0.26026, 0.26126, 0.26226, 0.26326,\n", + " 0.26426, 0.26527, 0.26627, 0.26727, 0.26827, 0.26927, 0.27027, 0.27127, 0.27227, 0.27327, 0.27427, 0.27528, 0.27628, 0.27728, 0.27828, 0.27928, 0.28028, 0.28128, 0.28228, 0.28328, 0.28428, 0.28529, 0.28629, 0.28729,\n", + " 0.28829, 0.28929, 0.29029, 0.29129, 0.29229, 0.29329, 0.29429, 0.2953, 0.2963, 0.2973, 0.2983, 0.2993, 0.3003, 0.3013, 0.3023, 0.3033, 0.3043, 0.30531, 0.30631, 0.30731, 0.30831, 0.30931, 0.31031, 0.31131,\n", + " 0.31231, 0.31331, 0.31431, 0.31532, 0.31632, 0.31732, 0.31832, 0.31932, 0.32032, 0.32132, 0.32232, 0.32332, 0.32432, 0.32533, 0.32633, 0.32733, 0.32833, 0.32933, 0.33033, 0.33133, 0.33233, 0.33333, 0.33433, 0.33534,\n", + " 0.33634, 0.33734, 0.33834, 0.33934, 0.34034, 0.34134, 0.34234, 0.34334, 0.34434, 0.34535, 0.34635, 0.34735, 0.34835, 0.34935, 0.35035, 0.35135, 0.35235, 0.35335, 0.35435, 0.35536, 0.35636, 0.35736, 0.35836, 0.35936,\n", + " 0.36036, 0.36136, 0.36236, 0.36336, 0.36436, 0.36537, 0.36637, 0.36737, 0.36837, 0.36937, 0.37037, 0.37137, 0.37237, 0.37337, 0.37437, 0.37538, 0.37638, 0.37738, 0.37838, 0.37938, 0.38038, 0.38138, 0.38238, 0.38338,\n", + " 0.38438, 0.38539, 0.38639, 0.38739, 0.38839, 0.38939, 0.39039, 0.39139, 0.39239, 0.39339, 0.39439, 0.3954, 0.3964, 0.3974, 0.3984, 0.3994, 0.4004, 0.4014, 0.4024, 0.4034, 0.4044, 0.40541, 0.40641, 0.40741,\n", + " 0.40841, 0.40941, 0.41041, 0.41141, 0.41241, 0.41341, 0.41441, 0.41542, 0.41642, 0.41742, 0.41842, 0.41942, 0.42042, 0.42142, 0.42242, 0.42342, 0.42442, 0.42543, 0.42643, 0.42743, 0.42843, 0.42943, 0.43043, 0.43143,\n", + " 0.43243, 0.43343, 0.43443, 0.43544, 0.43644, 0.43744, 0.43844, 0.43944, 0.44044, 0.44144, 0.44244, 0.44344, 0.44444, 0.44545, 0.44645, 0.44745, 0.44845, 0.44945, 0.45045, 0.45145, 0.45245, 0.45345, 0.45445, 0.45546,\n", + " 0.45646, 0.45746, 0.45846, 0.45946, 0.46046, 0.46146, 0.46246, 0.46346, 0.46446, 0.46547, 0.46647, 0.46747, 0.46847, 0.46947, 0.47047, 0.47147, 0.47247, 0.47347, 0.47447, 0.47548, 0.47648, 0.47748, 0.47848, 0.47948,\n", + " 0.48048, 0.48148, 0.48248, 0.48348, 0.48448, 0.48549, 0.48649, 0.48749, 0.48849, 0.48949, 0.49049, 0.49149, 0.49249, 0.49349, 0.49449, 0.4955, 0.4965, 0.4975, 0.4985, 0.4995, 0.5005, 0.5015, 0.5025, 0.5035,\n", + " 0.5045, 0.50551, 0.50651, 0.50751, 0.50851, 0.50951, 0.51051, 0.51151, 0.51251, 0.51351, 0.51451, 0.51552, 0.51652, 0.51752, 0.51852, 0.51952, 0.52052, 0.52152, 0.52252, 0.52352, 0.52452, 0.52553, 0.52653, 0.52753,\n", + " 0.52853, 0.52953, 0.53053, 0.53153, 0.53253, 0.53353, 0.53453, 0.53554, 0.53654, 0.53754, 0.53854, 0.53954, 0.54054, 0.54154, 0.54254, 0.54354, 0.54454, 0.54555, 0.54655, 0.54755, 0.54855, 0.54955, 0.55055, 0.55155,\n", + " 0.55255, 0.55355, 0.55455, 0.55556, 0.55656, 0.55756, 0.55856, 0.55956, 0.56056, 0.56156, 0.56256, 0.56356, 0.56456, 0.56557, 0.56657, 0.56757, 0.56857, 0.56957, 0.57057, 0.57157, 0.57257, 0.57357, 0.57457, 0.57558,\n", + " 0.57658, 0.57758, 0.57858, 0.57958, 0.58058, 0.58158, 0.58258, 0.58358, 0.58458, 0.58559, 0.58659, 0.58759, 0.58859, 0.58959, 0.59059, 0.59159, 0.59259, 0.59359, 0.59459, 0.5956, 0.5966, 0.5976, 0.5986, 0.5996,\n", + " 0.6006, 0.6016, 0.6026, 0.6036, 0.6046, 0.60561, 0.60661, 0.60761, 0.60861, 0.60961, 0.61061, 0.61161, 0.61261, 0.61361, 0.61461, 0.61562, 0.61662, 0.61762, 0.61862, 0.61962, 0.62062, 0.62162, 0.62262, 0.62362,\n", + " 0.62462, 0.62563, 0.62663, 0.62763, 0.62863, 0.62963, 0.63063, 0.63163, 0.63263, 0.63363, 0.63463, 0.63564, 0.63664, 0.63764, 0.63864, 0.63964, 0.64064, 0.64164, 0.64264, 0.64364, 0.64464, 0.64565, 0.64665, 0.64765,\n", + " 0.64865, 0.64965, 0.65065, 0.65165, 0.65265, 0.65365, 0.65465, 0.65566, 0.65666, 0.65766, 0.65866, 0.65966, 0.66066, 0.66166, 0.66266, 0.66366, 0.66466, 0.66567, 0.66667, 0.66767, 0.66867, 0.66967, 0.67067, 0.67167,\n", + " 0.67267, 0.67367, 0.67467, 0.67568, 0.67668, 0.67768, 0.67868, 0.67968, 0.68068, 0.68168, 0.68268, 0.68368, 0.68468, 0.68569, 0.68669, 0.68769, 0.68869, 0.68969, 0.69069, 0.69169, 0.69269, 0.69369, 0.69469, 0.6957,\n", + " 0.6967, 0.6977, 0.6987, 0.6997, 0.7007, 0.7017, 0.7027, 0.7037, 0.7047, 0.70571, 0.70671, 0.70771, 0.70871, 0.70971, 0.71071, 0.71171, 0.71271, 0.71371, 0.71471, 0.71572, 0.71672, 0.71772, 0.71872, 0.71972,\n", + " 0.72072, 0.72172, 0.72272, 0.72372, 0.72472, 0.72573, 0.72673, 0.72773, 0.72873, 0.72973, 0.73073, 0.73173, 0.73273, 0.73373, 0.73473, 0.73574, 0.73674, 0.73774, 0.73874, 0.73974, 0.74074, 0.74174, 0.74274, 0.74374,\n", + " 0.74474, 0.74575, 0.74675, 0.74775, 0.74875, 0.74975, 0.75075, 0.75175, 0.75275, 0.75375, 0.75475, 0.75576, 0.75676, 0.75776, 0.75876, 0.75976, 0.76076, 0.76176, 0.76276, 0.76376, 0.76476, 0.76577, 0.76677, 0.76777,\n", + " 0.76877, 0.76977, 0.77077, 0.77177, 0.77277, 0.77377, 0.77477, 0.77578, 0.77678, 0.77778, 0.77878, 0.77978, 0.78078, 0.78178, 0.78278, 0.78378, 0.78478, 0.78579, 0.78679, 0.78779, 0.78879, 0.78979, 0.79079, 0.79179,\n", + " 0.79279, 0.79379, 0.79479, 0.7958, 0.7968, 0.7978, 0.7988, 0.7998, 0.8008, 0.8018, 0.8028, 0.8038, 0.8048, 0.80581, 0.80681, 0.80781, 0.80881, 0.80981, 0.81081, 0.81181, 0.81281, 0.81381, 0.81481, 0.81582,\n", + " 0.81682, 0.81782, 0.81882, 0.81982, 0.82082, 0.82182, 0.82282, 0.82382, 0.82482, 0.82583, 0.82683, 0.82783, 0.82883, 0.82983, 0.83083, 0.83183, 0.83283, 0.83383, 0.83483, 0.83584, 0.83684, 0.83784, 0.83884, 0.83984,\n", + " 0.84084, 0.84184, 0.84284, 0.84384, 0.84484, 0.84585, 0.84685, 0.84785, 0.84885, 0.84985, 0.85085, 0.85185, 0.85285, 0.85385, 0.85485, 0.85586, 0.85686, 0.85786, 0.85886, 0.85986, 0.86086, 0.86186, 0.86286, 0.86386,\n", + " 0.86486, 0.86587, 0.86687, 0.86787, 0.86887, 0.86987, 0.87087, 0.87187, 0.87287, 0.87387, 0.87487, 0.87588, 0.87688, 0.87788, 0.87888, 0.87988, 0.88088, 0.88188, 0.88288, 0.88388, 0.88488, 0.88589, 0.88689, 0.88789,\n", + " 0.88889, 0.88989, 0.89089, 0.89189, 0.89289, 0.89389, 0.89489, 0.8959, 0.8969, 0.8979, 0.8989, 0.8999, 0.9009, 0.9019, 0.9029, 0.9039, 0.9049, 0.90591, 0.90691, 0.90791, 0.90891, 0.90991, 0.91091, 0.91191,\n", + " 0.91291, 0.91391, 0.91491, 0.91592, 0.91692, 0.91792, 0.91892, 0.91992, 0.92092, 0.92192, 0.92292, 0.92392, 0.92492, 0.92593, 0.92693, 0.92793, 0.92893, 0.92993, 0.93093, 0.93193, 0.93293, 0.93393, 0.93493, 0.93594,\n", + " 0.93694, 0.93794, 0.93894, 0.93994, 0.94094, 0.94194, 0.94294, 0.94394, 0.94494, 0.94595, 0.94695, 0.94795, 0.94895, 0.94995, 0.95095, 0.95195, 0.95295, 0.95395, 0.95495, 0.95596, 0.95696, 0.95796, 0.95896, 0.95996,\n", + " 0.96096, 0.96196, 0.96296, 0.96396, 0.96496, 0.96597, 0.96697, 0.96797, 0.96897, 0.96997, 0.97097, 0.97197, 0.97297, 0.97397, 0.97497, 0.97598, 0.97698, 0.97798, 0.97898, 0.97998, 0.98098, 0.98198, 0.98298, 0.98398,\n", + " 0.98498, 0.98599, 0.98699, 0.98799, 0.98899, 0.98999, 0.99099, 0.99199, 0.99299, 0.99399, 0.99499, 0.996, 0.997, 0.998, 0.999, 1]), array([[ 0.14181, 0.14181, 0.12862, 0.12159, 0.11689, 0.11312, 0.11026, 0.10811, 0.10594, 0.10426, 0.10277, 0.10142, 0.10026, 0.099275, 0.098183, 0.097218, 0.096343, 0.095592, 0.094909, 0.094277, 0.093654, 0.09306, 0.092413,\n", + " 0.091879, 0.091463, 0.090974, 0.090514, 0.090069, 0.08958, 0.089149, 0.088754, 0.088388, 0.088032, 0.087735, 0.087434, 0.087206, 0.086984, 0.086682, 0.086489, 0.086217, 0.086005, 0.085812, 0.085545, 0.085298, 0.085125, 0.084902,\n", + " 0.084665, 0.084497, 0.084309, 0.084111, 0.083918, 0.083726, 0.083567, 0.083345, 0.083187, 0.082999, 0.082806, 0.082668, 0.082574, 0.08245, 0.082326, 0.082183, 0.082005, 0.081857, 0.081679, 0.08156, 0.081446, 0.081303, 0.08111,\n", + " 0.080962, 0.080828, 0.080719, 0.080601, 0.080477, 0.080378, 0.080255, 0.080126, 0.080003, 0.079904, 0.07977, 0.079656, 0.079553, 0.079478, 0.079365, 0.079241, 0.079122, 0.079034, 0.078945, 0.078851, 0.078771, 0.078687, 0.078589,\n", + " 0.078519, 0.07845, 0.078351, 0.078272, 0.078208, 0.078148, 0.078084, 0.07804, 0.077985, 0.077921, 0.077881, 0.077807, 0.077738, 0.077689, 0.0776, 0.07754, 0.077486, 0.077441, 0.077367, 0.077283, 0.077219, 0.077179, 0.077076,\n", + " 0.077036, 0.076952, 0.076912, 0.076858, 0.076823, 0.076769, 0.07672, 0.076685, 0.076645, 0.076591, 0.076532, 0.076463, 0.076443, 0.076398, 0.076374, 0.076354, 0.076304, 0.076245, 0.076191, 0.076126, 0.076072, 0.076003, 0.075982,\n", + " 0.075929, 0.075904, 0.075864, 0.07581, 0.075746, 0.075721, 0.075662, 0.075563, 0.075508, 0.075439, 0.075399, 0.07539, 0.07536, 0.075296, 0.075256, 0.075226, 0.075182, 0.075123, 0.075088, 0.075039, 0.07501, 0.074974, 0.07491,\n", + " 0.074885, 0.074841, 0.074786, 0.074762, 0.074702, 0.074638, 0.074623, 0.074574, 0.074534, 0.07448, 0.074455, 0.074435, 0.074421, 0.074356, 0.074312, 0.074252, 0.074238, 0.074223, 0.074193, 0.074134, 0.074109, 0.074035, 0.074015,\n", + " 0.074005, 0.073971, 0.073926, 0.073877, 0.073867, 0.073827, 0.073758, 0.073723, 0.073659, 0.07358, 0.073545, 0.073506, 0.073476, 0.073461, 0.073417, 0.073412, 0.073353, 0.073328, 0.073288, 0.073234, 0.073229, 0.073199, 0.073184,\n", + " 0.073145, 0.073086, 0.073051, 0.073021, 0.072997, 0.072947, 0.072922, 0.072873, 0.072843, 0.072809, 0.072799, 0.072739, 0.072725, 0.07269, 0.072655, 0.072606, 0.072581, 0.072522, 0.072517, 0.072473, 0.072453, 0.072369, 0.072329,\n", + " 0.07227, 0.072235, 0.072197, 0.072131, 0.072102, 0.072047, 0.072032, 0.071983, 0.071943, 0.071909, 0.071874, 0.071867, 0.07182, 0.0718, 0.071785, 0.071751, 0.071721, 0.071691, 0.071632, 0.071597, 0.071533, 0.071513, 0.071484,\n", + " 0.071429, 0.071404, 0.07139, 0.07136, 0.07134, 0.071311, 0.071276, 0.071256, 0.071192, 0.071187, 0.071157, 0.071139, 0.071103, 0.071073, 0.071058, 0.071014, 0.070979, 0.070955, 0.07091, 0.070895, 0.070871, 0.070861, 0.070787,\n", + " 0.070782, 0.070742, 0.070732, 0.070673, 0.070638, 0.070604, 0.070549, 0.070495, 0.070475, 0.070455, 0.070366, 0.070302, 0.070257, 0.070238, 0.070203, 0.070183, 0.070129, 0.070114, 0.07003, 0.070015, 0.069991, 0.069971, 0.069941,\n", + " 0.069902, 0.069897, 0.069867, 0.069822, 0.069783, 0.069763, 0.069738, 0.069714, 0.069689, 0.069635, 0.069615, 0.069605, 0.06956, 0.069526, 0.069511, 0.069481, 0.069452, 0.069442, 0.069412, 0.069387, 0.069318, 0.069279, 0.069259,\n", + " 0.069224, 0.06919, 0.069105, 0.069076, 0.069051, 0.069016, 0.068997, 0.068977, 0.068932, 0.068903, 0.068868, 0.068853, 0.068804, 0.068769, 0.068705, 0.068661, 0.068616, 0.068591, 0.068557, 0.068527, 0.068517, 0.068468, 0.068433,\n", + " 0.068389, 0.068354, 0.068325, 0.068309, 0.06827, 0.068191, 0.068166, 0.068146, 0.068097, 0.068062, 0.068003, 0.067968, 0.067949, 0.067924, 0.067904, 0.067869, 0.067835, 0.0678, 0.067756, 0.067696, 0.067682, 0.067631, 0.067607,\n", + " 0.067593, 0.067553, 0.067489, 0.067454, 0.067424, 0.06737, 0.067331, 0.067306, 0.067266, 0.067232, 0.067187, 0.067133, 0.067073, 0.067034, 0.067004, 0.066935, 0.066895, 0.066866, 0.066846, 0.066782, 0.066747, 0.066703, 0.066623,\n", + " 0.066564, 0.066544, 0.066505, 0.066485, 0.066458, 0.066421, 0.066386, 0.066371, 0.066332, 0.066292, 0.066263, 0.066228, 0.066183, 0.066159, 0.06612, 0.066065, 0.065966, 0.065941, 0.065912, 0.065871, 0.065842, 0.065813, 0.065753,\n", + " 0.065738, 0.065709, 0.065664, 0.065645, 0.065615, 0.06559, 0.065565, 0.065496, 0.065462, 0.065397, 0.065368, 0.065308, 0.065259, 0.065219, 0.06518, 0.06514, 0.065101, 0.065066, 0.065031, 0.064987, 0.064952, 0.064903, 0.064873,\n", + " 0.064834, 0.064804, 0.064755, 0.0647, 0.064646, 0.064621, 0.064591, 0.064557, 0.064522, 0.064483, 0.064443, 0.064418, 0.064369, 0.0643, 0.06426, 0.064216, 0.064186, 0.064141, 0.064092, 0.064048, 0.064003, 0.063973, 0.063929,\n", + " 0.063899, 0.06387, 0.063825, 0.063785, 0.063746, 0.063701, 0.063642, 0.063612, 0.063543, 0.063499, 0.063469, 0.06343, 0.063405, 0.06335, 0.063306, 0.063271, 0.063202, 0.063172, 0.063123, 0.063074, 0.063004, 0.062965, 0.062935,\n", + " 0.06292, 0.062876, 0.062841, 0.062782, 0.062732, 0.062692, 0.062658, 0.062598, 0.062559, 0.062515, 0.06247, 0.062419, 0.06235, 0.062292, 0.062238, 0.062213, 0.062164, 0.062119, 0.062085, 0.062003, 0.061976, 0.061951, 0.061902,\n", + " 0.061828, 0.061773, 0.061719, 0.061679, 0.06161, 0.061575, 0.061536, 0.061486, 0.061422, 0.061368, 0.061348, 0.061289, 0.061244, 0.06118, 0.061071, 0.061022, 0.060967, 0.060903, 0.060863, 0.060808, 0.06075, 0.060694, 0.060645,\n", + " 0.060616, 0.060572, 0.060526, 0.060448, 0.060389, 0.060325, 0.06028, 0.06025, 0.060216, 0.060186, 0.060151, 0.060087, 0.060043, 0.060008, 0.059959, 0.059904, 0.059845, 0.059796, 0.059753, 0.059723, 0.059702, 0.059667, 0.059637,\n", + " 0.059588, 0.059543, 0.059504, 0.059444, 0.059415, 0.059331, 0.059286, 0.059225, 0.059158, 0.059098, 0.059059, 0.059014, 0.058985, 0.058925, 0.058891, 0.058846, 0.058792, 0.058732, 0.058683, 0.058609, 0.058579, 0.05853, 0.058485,\n", + " 0.058446, 0.058386, 0.058362, 0.058322, 0.058307, 0.058199, 0.058129, 0.058075, 0.058016, 0.057961, 0.057897, 0.057857, 0.057803, 0.057754, 0.057714, 0.057674, 0.057625, 0.057572, 0.057511, 0.057472, 0.057442, 0.057358, 0.057318,\n", + " 0.057249, 0.057202, 0.05716, 0.057103, 0.057063, 0.057007, 0.05694, 0.056903, 0.056859, 0.05675, 0.056705, 0.056656, 0.056611, 0.056527, 0.056473, 0.056414, 0.056362, 0.056305, 0.056275, 0.056236, 0.056167, 0.056122, 0.056013,\n", + " 0.055934, 0.055899, 0.05587, 0.055815, 0.055741, 0.055682, 0.055642, 0.055583, 0.055524, 0.05543, 0.05539, 0.055257, 0.055192, 0.055123, 0.055084, 0.055029, 0.054975, 0.054935, 0.054886, 0.054757, 0.054698, 0.054633, 0.054574,\n", + " 0.054535, 0.054492, 0.054421, 0.054382, 0.054317, 0.054189, 0.054139, 0.05409, 0.054021, 0.053956, 0.053872, 0.053778, 0.053724, 0.053665, 0.053586, 0.053524, 0.053467, 0.053393, 0.053319, 0.053259, 0.053239, 0.053179, 0.053136,\n", + " 0.053066, 0.053032, 0.052992, 0.052859, 0.052809, 0.052725, 0.052661, 0.052592, 0.052508, 0.052473, 0.052349, 0.052315, 0.052231, 0.052102, 0.052048, 0.051959, 0.051924, 0.05183, 0.051766, 0.051727, 0.051568, 0.051539, 0.05144,\n", + " 0.051395, 0.051336, 0.051282, 0.051173, 0.051077, 0.051059, 0.050985, 0.050931, 0.050762, 0.050688, 0.050584, 0.050545, 0.050471, 0.050411, 0.050347, 0.050223, 0.050159, 0.050075, 0.050021, 0.049917, 0.049803, 0.049744, 0.04964,\n", + " 0.049605, 0.049512, 0.049368, 0.049304, 0.049205, 0.049136, 0.049029, 0.048935, 0.048755, 0.048686, 0.048602, 0.048537, 0.04832, 0.048206, 0.048142, 0.047979, 0.047879, 0.047811, 0.047682, 0.04747, 0.047415, 0.047326, 0.047267,\n", + " 0.047123, 0.047034, 0.046995, 0.046822, 0.046649, 0.046545, 0.046471, 0.046362, 0.046224, 0.046174, 0.04606, 0.045882, 0.045813, 0.04568, 0.04551, 0.045437, 0.045339, 0.045151, 0.045077, 0.044928, 0.044676, 0.044592, 0.044399,\n", + " 0.0443, 0.044127, 0.044068, 0.043885, 0.043801, 0.043632, 0.043554, 0.043445, 0.043297, 0.043242, 0.043064, 0.042975, 0.042896, 0.042753, 0.042621, 0.042441, 0.042357, 0.042224, 0.041996, 0.041912, 0.041729, 0.041541, 0.041393,\n", + " 0.04118, 0.041106, 0.040904, 0.04075, 0.040576, 0.040515, 0.040384, 0.040251, 0.039991, 0.03991, 0.039724, 0.039609, 0.039446, 0.039361, 0.039129, 0.038931, 0.038798, 0.038634, 0.038412, 0.038268, 0.038169, 0.037932, 0.037794,\n", + " 0.03759, 0.037299, 0.037195, 0.036953, 0.03678, 0.036602, 0.036365, 0.036241, 0.035999, 0.035786, 0.035639, 0.035376, 0.035228, 0.035158, 0.034961, 0.03461, 0.03454, 0.034317, 0.034095, 0.033944, 0.033695, 0.033477, 0.033239,\n", + " 0.033107, 0.032874, 0.032662, 0.032424, 0.032302, 0.032093, 0.031786, 0.031584, 0.031351, 0.031094, 0.030981, 0.030738, 0.030338, 0.030125, 0.029888, 0.02967, 0.029437, 0.029205, 0.029117, 0.028889, 0.028622, 0.028385, 0.028147,\n", + " 0.027902, 0.027683, 0.027396, 0.027109, 0.026893, 0.02663, 0.026432, 0.026165, 0.025972, 0.025482, 0.025265, 0.025028, 0.024795, 0.024543, 0.024326, 0.024078, 0.023859, 0.023522, 0.023366, 0.023107, 0.022857, 0.022556, 0.022387,\n", + " 0.022185, 0.022047, 0.021686, 0.021458, 0.02128, 0.021057, 0.020736, 0.02033, 0.020108, 0.019964, 0.019682, 0.019535, 0.019301, 0.019144, 0.018811, 0.018677, 0.018407, 0.018142, 0.017992, 0.017722, 0.017458, 0.017261, 0.01687,\n", + " 0.016647, 0.016479, 0.016143, 0.015747, 0.015529, 0.015292, 0.015059, 0.014658, 0.014492, 0.014322, 0.013972, 0.013777, 0.013317, 0.012984, 0.012768, 0.012516, 0.012308, 0.01201, 0.011818, 0.011382, 0.011085, 0.010887, 0.010561,\n", + " 0.010155, 0.0099819, 0.009685, 0.0094178, 0.0090517, 0.0089426, 0.0086821, 0.0083736, 0.0080717, 0.0078045, 0.0075175, 0.0072453, 0.0070028, 0.0067751, 0.0065177, 0.0062752, 0.0060221, 0.0057996, 0.0055724, 0.0052607, 0.0049242, 0.0047608, 0.0045677,\n", + " 0.0042362, 0.0040085, 0.0037413, 0.0035482, 0.0032365, 0.0030237, 0.002791, 0.0026276, 0.0023456, 0.0020882, 0.0018358, 0.0016971, 0.0015881, 0.001395, 0.0011327, 0.00097921, 0.00085536, 0.0006524, 0.00055327, 0.00046403, 0.00038961, 0.00031026, 0.00025563,\n", + " 0.00017133, 0.00014636, 0.00012002, 0.00011125, 9.1228e-05, 6.626e-05, 4.6235e-05, 3.6099e-05, 2.5342e-05, 2.0274e-05, 1.0636e-05, 6.7589e-06, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'Confidence', 'Recall']]\n", + "fitness: np.float64(0.030299701322224683)\n", + "keys: ['metrics/precision(B)', 'metrics/recall(B)', 'metrics/mAP50(B)', 'metrics/mAP50-95(B)']\n", + "maps: array([ 0.0303])\n", + "names: {0: 'bar'}\n", + "nt_per_class: array([202256])\n", + "nt_per_image: array([17404])\n", + "results_dict: {'metrics/precision(B)': 0.18213738179122962, 'metrics/recall(B)': 0.07087057985918835, 'metrics/mAP50(B)': 0.04402745894723169, 'metrics/mAP50-95(B)': 0.030299701322224683, 'fitness': 0.030299701322224683}\n", + "save_dir: PosixPath('/content/drive/MyDrive/Spectra_YOLO_Project/detect/train')\n", + "speed: {'preprocess': 0.13311327585642238, 'inference': 1.4693561658259213, 'loss': 0.00030924230005581244, 'postprocess': 2.2027111569176085}\n", + "stats: {'tp': [], 'conf': [], 'pred_cls': [], 'target_cls': [], 'target_img': []}\n", + "task: 'detect'" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install ultralytics" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "u9HOFZ7u2h6J", + "outputId": "2c9d9b4f-f32b-43ea-938e-88064dd0954b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting ultralytics\n", + " Downloading ultralytics-8.4.19-py3-none-any.whl.metadata (39 kB)\n", + "Requirement already satisfied: numpy>=1.23.0 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (2.0.2)\n", + "Requirement already satisfied: matplotlib>=3.3.0 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (3.10.0)\n", + "Requirement already satisfied: opencv-python>=4.6.0 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (4.13.0.92)\n", + "Requirement already satisfied: pillow>=7.1.2 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (11.3.0)\n", + "Requirement already satisfied: pyyaml>=5.3.1 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (6.0.3)\n", + "Requirement already satisfied: requests>=2.23.0 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (2.32.4)\n", + "Requirement already satisfied: scipy>=1.4.1 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (1.16.3)\n", + "Requirement already satisfied: torch>=1.8.0 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (2.10.0+cu128)\n", + "Requirement already satisfied: torchvision>=0.9.0 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (0.25.0+cu128)\n", + "Requirement already satisfied: psutil>=5.8.0 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (5.9.5)\n", + "Requirement already satisfied: polars>=0.20.0 in /usr/local/lib/python3.12/dist-packages (from ultralytics) (1.35.2)\n", + "Collecting ultralytics-thop>=2.0.18 (from ultralytics)\n", + " Downloading ultralytics_thop-2.0.18-py3-none-any.whl.metadata (14 kB)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.3.0->ultralytics) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.3.0->ultralytics) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.3.0->ultralytics) (4.61.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.3.0->ultralytics) (1.4.9)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.3.0->ultralytics) (26.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.3.0->ultralytics) (3.3.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.3.0->ultralytics) (2.9.0.post0)\n", + "Requirement already satisfied: polars-runtime-32==1.35.2 in /usr/local/lib/python3.12/dist-packages (from polars>=0.20.0->ultralytics) (1.35.2)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests>=2.23.0->ultralytics) (3.4.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests>=2.23.0->ultralytics) (3.11)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests>=2.23.0->ultralytics) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests>=2.23.0->ultralytics) (2026.1.4)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (3.24.3)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (4.15.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (75.2.0)\n", + "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (1.14.0)\n", + "Requirement already satisfied: networkx>=2.5.1 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (3.6.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (3.1.6)\n", + "Requirement already satisfied: fsspec>=0.8.5 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (2025.3.0)\n", + "Requirement already satisfied: cuda-bindings==12.9.4 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (12.9.4)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (12.8.93)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (12.8.90)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (12.8.90)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (9.10.2.21)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.8.4.1 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (12.8.4.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.3.3.83 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (11.3.3.83)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.9.90 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (10.3.9.90)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.7.3.90 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (11.7.3.90)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.5.8.93 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (12.5.8.93)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (0.7.1)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.27.5 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (2.27.5)\n", + "Requirement already satisfied: nvidia-nvshmem-cu12==3.4.5 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (3.4.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (12.8.90)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (12.8.93)\n", + "Requirement already satisfied: nvidia-cufile-cu12==1.13.1.3 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (1.13.1.3)\n", + "Requirement already satisfied: triton==3.6.0 in /usr/local/lib/python3.12/dist-packages (from torch>=1.8.0->ultralytics) (3.6.0)\n", + "Requirement already satisfied: cuda-pathfinder~=1.1 in /usr/local/lib/python3.12/dist-packages (from cuda-bindings==12.9.4->torch>=1.8.0->ultralytics) (1.3.5)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib>=3.3.0->ultralytics) (1.17.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch>=1.8.0->ultralytics) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch>=1.8.0->ultralytics) (3.0.3)\n", + "Downloading ultralytics-8.4.19-py3-none-any.whl (1.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m18.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading ultralytics_thop-2.0.18-py3-none-any.whl (28 kB)\n", + "Installing collected packages: ultralytics-thop, ultralytics\n", + "Successfully installed ultralytics-8.4.19 ultralytics-thop-2.0.18\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "g3eNMJ0-3TOq", + "outputId": "9b3f773c-3e75-488f-e4be-9509d0d78f73" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from ultralytics import YOLO\n", + "import cv2\n", + "from google.colab.patches import cv2_imshow\n", + "\n", + "# 1. Load your best weights from the 10 epochs\n", + "model = YOLO('/content/drive/MyDrive/Spectra_YOLO_Project/detect/train/weights/best.pt')\n", + "\n", + "# 2. Run it on ONE image from your val set\n", + "results = model.predict(source='/content/datasets/yolo_dataset/images/val/two_col_104136.png', conf=0.25)\n", + "\n", + "# 3. Show the result\n", + "annotated_frame = results[0].plot()\n", + "cv2_imshow(annotated_frame)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 628 + }, + "id": "jnNxAXnN2eq1", + "outputId": "69ff3063-12a1-4f09-84bd-13e337efd019" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "image 1/1 /content/datasets/yolo_dataset/images/val/two_col_104136.png: 448x640 5 bars, 17.8ms\n", + "Speed: 2.9ms preprocess, 17.8ms inference, 1.7ms postprocess per image at shape (1, 3, 448, 640)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n", + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAItAyADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3wmkz6A0hPIHqcVLQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qOfQ/lUtFAEXPofyo59D+VS0UARc+h/Kjn0P5VLRQBFz6H8qTn0P5VNmm5oAjyfQ/lRk+h/KpM0ZoAjyfQ/lS8+h/Kn5pc0AMzjsaM081CD1HoaAAn5l+oqeqx+8v+8Ks0AFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFVNR1Sw0m3WfUb2C0iZtgeaQIC3XAz34NW686+LsaTaZoUUihkfVY1ZT3BDZFdWCoRxFeNKTsmRUk4RckdP8A8Jt4W/6GDTf/AAIX/Gj/AITbwt/0MGm/+BC/414Hr/g29i1fUvsgszsmkeOxinUzLGCSMRjn7uDjrjtXPaZpV3q1w0Vsq4Rd8ssjBI4l/vMx4Ar6inw7g6kPaKq7fI4ni6iduU+nf+E28Lf9DBpv/gQv+NH/AAm3hb/oYNN/8CF/xr5s1Pw3f6XZi9lME1m0gjW4t5lkRmwTgEd+DUsnhTUoLI3d2ba1iMYki+0TKjTAqG+QHluCPx460/8AVzBWT9s9fQPrdT+U+jv+E28Lf9DBpv8A4EL/AI0f8Jt4W/6GDTf/AAIX/GvlWuh0SOCw0S+1ya3huJYpY7e2jnXdHvYEliv8WAvAPGTV1eF8PTjfnb6dOoo42Tex9E/8Jt4W/wChg03/AMCF/wAaP+E28Lf9DBpv/gQv+NfPkk0fiPw/f3M9tbQ6hpwSQSW8Qj86Nm2sGVeCQSpB+tcwMZGelKlwxQndObTWj29QljJLofVX/CbeFv8AoYNN/wDAhf8AGj/hNvC3/Qwab/4EL/jXkR0zW3MTeHdF0y50EopjmeCJg64+Yys3zBs5z0xiuOvb+30nxRez6KIHthIyxebEsqbT6BgeM9D1xXPR4fw9ZtRm727r7npo/LXqXLFSjuj6O/4Tbwt/0MGm/wDgQv8AjWtZX1pqNol1ZXMVxbvnbLE4ZTg4PI96+ebDX7mXw7qup6jaaa0CqLW2QWES75375C/wqC31x616t8JP+SdWH/XSX/0Y1cGY5RHCUXUTd1JLutr9ka0a7qSt5HcUUUV4J0hRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABQaKQ0AJQATSGlT7ooANvvRtPr+lOpodWZlDAsvUelABt96TocU+mP94fjQAZqvn5m/wB41PVUH5m/3jTQiU/fX/eH86s1WP31/wB4fzqzQMKKKKQBRRRQAUUUUAFFFFABRRRQAUUUUAFee/Fhtll4fYvsA1aI7icbeG5r0KvI/jDb/b9f8L6e8siwXMrRuFbplkXIHTOCa9TJoKWNgm7bv7kzHEO1NnHXmgapD48uNVdDBpyX7XRv9wMSxiTO4NnBP+z1zxjNVI3TXtO1yx0xQt1Pfi8it84aeIb/AJVz1K7gdvU84HFVrCx0q40m1aaPUSZIkkdUu1CbiASQDGcfmamGk6GpBEGpAjkEXicf+Qq+yhiKbim3qkradtdVf+uh5LqQTtf+vuH3mmXmkfDuSC/jNtPLqaSLbu2JNojYbivUDI71T8a3JudXtP3gdY9OtUXachR5SnH5k1afStFkYs8OpMx6k3iE/wDoqk/sfQv+ffUf/AtP/jVaUsRSjP2krt69O9vPyJdWDVk/z/yOSrpdEjbV/DeoaJBhr7z47u3iLYMu0MrqOxOGBx7HFWP7H0L/AJ99R/8AAtP/AI1QNI0MHIt9Rz/1+J/8ararjqVSNldPR7dvmKM4p7/n/kMSxuPDnhrVDqcLW13qKJBbQvw5UOGdivYfKBk9zxWWdGm0+PTb/UFT7DdOG+RwWKZ5yByOM1sPpWiyNueHU2Y92vEJ/wDRVJ/ZGh/8++o/+Bif/GqiGMirtt3bu9PK2mun4jdSHf8Ar7i3q2m+K7vX2vNLjvJLTfmxmtHxEkWcIFIOFAA6cY71h+KTBP4jkFp5TuyxiUwY2NNtAfbjjBbPTitNNN0hYygj1MKc5UXqAH8PKpv9j6F/z76j/wCBif8Axqoo4mnTkm+isrK336jlVg+v9fcVPFE0Vr9j0G1kV4dOQiV0ORJcNzI2e+DhR7LXtfwmnhT4eWKvKinzJeCwH8bV4/8A2PoX/PvqP/gWn/xqj+x9C/599R/8C0/+NVyY+FHF4ZYfmas73te71v163LpYiMJ83+f+R9Lfabf/AJ7xf99ij7Tb/wDPeL/vsV80/wBj6F/z76j/AOBaf/GqP7H0L/n31H/wLT/41Xif2HQ/5+v/AMBX/wAkdP8AaEe35/5H0t9pt/8AnvF/32KPtNv/AM94v++xXzT/AGPoX/PvqP8A4Fp/8ao/sfQv+ffUf/AtP/jVH9h0P+fr/wDAV/8AJB/aEe35/wCR9KC7t2LDzo/lOPvj0z6077Tb/wDPeL/vsV80DR9Dycwaj7f6Wn/xql/sfQv+ffUf/AtP/jVH9h0P+fr/APAV/wDJB/aEe35/5H0t9pt/+e8X/fYo+02//PeL/vsV80/2PoX/AD76j/4Fp/8AGqP7H0L/AJ99R/8AAtP/AI1R/YdD/n6//AV/8kH9oR7fn/kfS32m3/57xf8AfYo+02//AD3i/wC+xXzT/Y+hf8++o/8AgWn/AMao/sfQv+ffUf8AwLT/AONUf2HQ/wCfr/8AAV/8kH9oR7fn/kfS32m3/wCe8X/fYo+02/8Az3i/77FfNP8AY+hf8++o/wDgWn/xqj+x9C/599R/8C0/+NUf2HQ/5+v/AMBX/wAkH9oR7fn/AJH0oLu3YsPOj+U4++PTPrTvtNv/AM94v++xXzQNH0PJzBqPt/paf/GqX+x9C/599R/8C0/+NUf2HQ/5+v8A8BX/AMkH9oR7fn/kfS32m3/57xf99ij7Tb/894v++xXzT/Y+hf8APvqP/gWn/wAao/sfQv8An31H/wAC0/8AjVH9h0P+fr/8BX/yQf2hHt+f+R9Lfabf/nvF/wB9ij7Tb/8APeL/AL7FfNP9j6F/z76j/wCBaf8Axqj+x9C/599R/wDAtP8A41R/YdD/AJ+v/wABX/yQf2hHt+f+R9Lfabf/AJ7xf99ij7Tb/wDPeL/vsV80/wBj6F/z76j/AOBaf/GqP7H0L/n31H/wLT/41R/YdD/n6/8AwFf/ACQf2hHt+f8AkfSgu7cuV86PIAP3x7+/tTvtNv8A894v++xXzR/Y+h5/1Go4/wCvtP8A41S/2PoX/PvqP/gWn/xqj+w6H/P1/wDgK/8Akg/tCPb8/wDI+lvtNv8A894v++xR9pt/+e8X/fYr5p/sfQv+ffUf/AtP/jVH9j6F/wA++o/+Baf/ABqj+w6H/P1/+Ar/AOSD+0I9vz/yPpb7Tb/894v++xR9pt/+e8X/AH2K+af7H0L/AJ99R/8AAtP/AI1R/Y+hf8++o/8AgWn/AMao/sOh/wA/X/4Cv/kg/tCPb8/8j6W+02//AD3i/wC+xR9pt/8AnvF/32K+af7H0L/n31H/AMC0/wDjVH9j6F/z76j/AOBaf/GqP7Dof8/X/wCAr/5IP7Qj2/P/ACPpQ3duHC+dHkgn749vf3p32m3/AOe8X/fYr5o/sfQ8/wCo1HH/AF9p/wDGqX+x9C/599R/8C0/+NUf2HQ/5+v/AMBX/wAkH9oR7fn/AJH0t9pt/wDnvF/32KPtNv8A894v++xXzT/Y+hf8++o/+Baf/GqP7H0L/n31H/wLT/41R/YdD/n6/wDwFf8AyQf2hHt+f+R9Lfabf/nvF/32KPtNv/z3i/77FfNP9j6F/wA++o/+Baf/ABqj+x9C/wCffUf/AALT/wCNUf2HQ/5+v/wFf/JB/aEe35/5H0t9pt/+e8X/AH2KPtNv/wA94v8AvsV80/2PoX/PvqP/AIFp/wDGqP7H0L/n31H/AMC0/wDjVH9h0P8An6//AAFf/JB/aEe35/5H0obu3UqPOj+Y4++PTPrTvtNv/wA94v8AvsV80HR9DyMQaj7/AOlp/wDGqX+x9C/599R/8C0/+NUf2HQ/5+v/AMBX/wAkH9oR7fn/AJH0t9pt/wDnvF/32KPtNv8A894v++xXzT/Y+hf8++o/+Baf/GqP7H0L/n31H/wLT/41R/YdD/n6/wDwFf8AyQf2hHt+f+R9Lfabf/nvF/32KPtNv/z3i/77FfNP9j6F/wA++o/+Baf/ABqj+x9C/wCffUf/AALT/wCNUf2HQ/5+v/wFf/JB/aEe35/5H0t9pt/+e8X/AH2KPtNv/wA94v8AvsV80/2PoX/PvqP/AIFp/wDGqP7H0L/n31H/AMC0/wDjVH9h0P8An6//AAFf/JB/aEe35/5H0obu3UqPOj+Y4++PTPrTvtNv/wA94v8AvsV80HR9DyMQaj7/AOlp/wDGqX+x9C/599R/8C0/+NUf2HQ/5+v/AMBX/wAkH9oR7fn/AJH0t9pt/wDnvF/32KPtNv8A894v++xXzT/Y+hf8++o/+Baf/GqP7H0L/n31H/wLT/41R/YdD/n6/wDwFf8AyQf2hHt+f+R9Lfabf/nvF/32KPtNv/z3i/77FfNP9j6F/wA++o/+Baf/ABqj+x9C/wCffUf/AALT/wCNUf2HQ/5+v/wFf/JB/aEe35/5H0t9pt/+e8X/AH2KVJ4nbakqMfQMDXzR/Y+hf8++o/8AgWn/AMarXv8Awxa+F9d8G3mnXN3nUpI5WEjjKZZOAVA7ORS/sSg3yKq7u9vd7K/cuGN5tl/X3H0EzBBk+oHX1OKdTJThBzj5l747j3H+fXpT6+cO4KKKKACiiigAooooAKajB0Vx0YZ65/lTqZCcwRnOcqOc57fU/wAzQA+mmnU00ANNOj+4Ka3SnR/cFAEF8bhbZnt2UOoydw6iucsru7a+/dSDzJj8xYcGuqkjWWNo2ztYYOKrjTrVTGUhVWjOVK8H/wCvVJ2E0WVDBQGILY5IGM0yTqv41JUcnVfxqRiVV/jb/eP86tVU/jb/AHj/ADpiJz99f94fzqzVY/fX/eH86s0MYUUUUgCiiigAooooApWWrWmoOy23nsBn52t5EQ4ODhmUA8+hq7XLLol+PCtzaPLPJNKGC2zNGFTMhPDAA9PVjSX2gH+27eWK2nNnEsfkraCBfJYMSxO8ZAORkocnBz2oA6qqcmp2sd6LMmVp+MiOB3C56bmUEL+JFY2jaRPZ67cXVzHdGV2kzOPJ8qRWbKg4xISBgYbIGDjirGoWtw+rRzWNpcxzEostx5kfkyRg8q6lsnjIBC5z3xQBtRyxzJvikWRMkblORkHB/WgSxmVohIpkVQxTPIB6HHpwfyrjZdBuV0dNPj0dBH9qlaUxx27MwO7Yy78rjkA5G4AcCnroV80bsLHyruXTEg+0Ex7kkXIYE5J+YYGRnjr0oA7KvKfin/yOfg3/AK+f/akdd94dsP7PsZIxb3UAaTd5dx5IwcAfKIvlA49uc1wPxT/5HPwb/wBfP/tSOvWyT/fF6S/9JZhiP4f3fmea6X/yCLL/AK4J/wCgirdVNL/5BFl/1wT/ANBFW6+gpfw4+iPn6nxsKKKK0ICiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK6vxo4juPhy5DELHEcKMk8xdAOtcpXVeNQ5n+HQj27zFFt3jIzmLqPSs1/vNP8A7e/9JZ2YXaXy/M9H/wCEwsfJ1Brq2vbJrCJJ5knRd21uQBtY8npgkdeR1preN9OihnNxa3tvcRGIC1kRfMk8z7m3DFTn6jGDnFVNP8MXVu+qPd2mlx2t5AkQ023ldYHk6Fydo2k8DhSencVmn4fXbyz36yW8F4s0D2sBuJZ0VY/4Wkcbjn6cYGK+JPeOy0fWrfWYpzFHNDLbytDNBMAHjYeuCR7gg1o1h+HdIutOfUbq+eE3V/cmZ0hYsiDGFAJAJ4HJwK3KACiiigAooooAKZCcwRnOcqOc57fU/wAzT6ZCcwRnOcqOc57fU/zNAD6aadSGgBhpqyBOG6etONNxnoKYhfPj/vfoaPPj9f0NMMbf3aTy2/u0ASefH/eP5GkL72zjgU0I3pTsY4oAWqo++/8AvH+dWhVX+Jv94/zoQEx++v8AvD+dWarH76/7w/nVmhjCiiikAUUUUAFFFFABRRRQAUUUUAFFFFABXkXxguo7PxN4VuZGwkErSscZwA8Zzj8K9drO1nSdP1axdNQsoLpY1LIJow2046jPSu7LsTHDYmNWautV96aM60HODSPlcXclvYWwgvctgoYRH/q1GAvJHOf6VH/al7/z3P5D/Ct64lh0/wAE6NLb2Np9puZbgSzywLI7BSuANwIA5qxFo9lrF34aneFbX+0neO4jhG1W2Njcg7bhxxxkcCv0VTowjeUFa8lsul/8nY8Z0k35/wCZzP8Aal7/AM9z+Q/wo/tS9/57n8h/hXTeGr2DU/GNtY3Gk6f9hmkMf2f7OoKAA4+f72RgcknPOar6R9htPCGs6hJYwXF5HdQxW7TJvEe4Pk46HgdDkZxxTlOnFtOmr+72+07fh1EqSf8AXYwf7Uvf+e5/If4Uv9qXv/Pc/kP8KrzzNcSmR1jUntGgQfkABWr4ThtrjxXpkF3GkkMk4RkcZUk8DPtnFdFSFKFNzcFor7EqCbsXWl00WjBfEUxuwm4f6FiIt/dDZ3fjtrE/tS9/57n8h/hS21rJJrENpsBla4Ee0jjO7GKseJI7eLxNqkVoipbpdSKioMAAMRx7VnClSjPkavdX2X6JDcU1exY0y7gmEj6nq81sq4CpDbCR3/MgAD603U7yKFo203VZbmNwdyy24jeM+/UHPsavaW1loOgx6peafBqUl+7xwQTqNkYTGWJ+9kk4ABHTnPGG6wbPWtE/tiysYdPa1lW3ntoVGxtwJDqev8JBBz2we1YpQ9tfl929r+7a+3a+/wCPkVyR5dlckS60ExqX1vVg+BuAsIyAf+/lVpr+0ttUZLfUZbuy8sESSQeWdxxxjnp0pvhq0t1W+1i+hSW00+LIikGVlmbiNCO4zlj7Ka3PhPptjq/jGSDUbSG5h+yO/lyoGXO5ecfiayrxpUYVJyu1Fa/D66abpW+8apqdo2SuZP8Aa9l/z1P/AHyaP7Xsv+ep/wC+TX0J/wAIR4W/6AGnf+A6/wCFH/CEeFv+gBp3/gOv+FfOf21gv5Jfejb+zX3Pnv8Atey/56n/AL5NH9r2X/PU/wDfJr6E/wCEI8Lf9ADTv/Adf8KP+EI8Lf8AQA07/wAB1/wo/trBfyS+9B/Zr7nz3/a9l/z1P/fJo/tey/56n/vk19Ap4J8LF5P+JBpvDf8APBfQf57f1L/+EI8Lf9ADTv8AwHX/AAo/trBfyS+9B/Zr7nz3/a9l/wA9T/3yaP7Xsv8Anqf++TX0J/whHhb/AKAGnf8AgOv+FH/CEeFv+gBp3/gOv+FH9tYL+SX3oP7Nfc+e/wC17L/nqf8Avk0f2vZf89T/AN8mvoT/AIQjwt/0ANO/8B1/wo/4Qjwt/wBADTv/AAHX/Cj+2sF/JL70H9mvufPf9r2X/PU/98mj+17L/nqf++TX0J/whHhb/oAad/4Dr/hR/wAIR4W/6AGnf+A6/wCFH9tYL+SX3oP7Nfc+e/7Xsv8Anqf++TR/a9l/z1P/AHya+gU8E+Fi8n/Eg03hv+eC+g/z2/qX/wDCEeFv+gBp3/gOv+FH9tYL+SX3oP7Nfc+e/wC17L/nqf8Avk0f2vZf89T/AN8mvoT/AIQjwt/0ANO/8B1/wo/4Qjwt/wBADTv/AAHX/Cj+2sF/JL70H9mvufPf9r2X/PU/98mj+17L/nqf++TX0J/whHhb/oAad/4Dr/hR/wAIR4W/6AGnf+A6/wCFH9tYL+SX3oP7Nfc+e/7Xsv8Anqf++TR/a9l/z1P/AHya+hP+EI8Lf9ADTv8AwHX/AAo/4Qjwt/0ANO/8B1/wo/trBfyS+9B/Zr7nz3/a9l/z1P8A3yaP7Xsv+ep/75NfQI8E+FvOYf2Bpv3Rx5C+/wDnp+fZ/wDwhHhb/oAad/4Dr/hR/bWC/kl96D+zX3Pnv+17L/nqf++TR/a9l/z1P/fJr6E/4Qjwt/0ANO/8B1/wo/4Qjwt/0ANO/wDAdf8ACj+2sF/JL70H9mvufPf9r2X/AD1P/fJo/tey/wCep/75NfQn/CEeFv8AoAad/wCA6/4Uf8IR4W/6AGnf+A6/4Uf21gv5Jfeg/s19z57/ALXsv+ep/wC+TR/a9l/z1P8A3ya+hP8AhCPC3/QA07/wHX/Cj/hCPC3/AEANO/8AAdf8KP7awX8kvvQf2a+589/2vZf89T/3yaP7Xsv+ep/75NfQJ8E+FvOUf2Bpv3Tx5C+3+en5d3/8IR4W/wCgBp3/AIDr/hR/bWC/kl96D+zX3Pnv+17L/nqf++TR/a9l/wA9T/3ya+hP+EI8Lf8AQA07/wAB1/wo/wCEI8Lf9ADTv/Adf8KP7awX8kvvQf2a+589/wBr2X/PU/8AfJo/tey/56n/AL5NfQn/AAhHhb/oAad/4Dr/AIUf8IR4W/6AGnf+A6/4Uf21gv5Jfeg/s19z57/tey/56n/vk0f2vZf89T/3ya+hP+EI8Lf9ADTv/Adf8KP+EI8Lf9ADTv8AwHX/AAo/trBfyS+9B/Zr7nz3/a9l/wA9T/3yaP7Xsv8Anqf++TX0C/gnwsHj/wCJBpvLf88F9D/nv/UP/wCEI8Lf9ADTv/Adf8KP7awX8kvvQf2a+589/wBr2X/PU/8AfJo/tey/56n/AL5NfQn/AAhHhb/oAad/4Dr/AIUf8IR4W/6AGnf+A6/4Uf21gv5Jfeg/s19z57/tey/56n/vk0f2vZf89T/3ya+hP+EI8Lf9ADTv/Adf8KP+EI8Lf9ADTv8AwHX/AAo/trBfyS+9B/Zr7nz3/a9l/wA9T/3yaP7Xsv8Anqf++TX0J/whHhb/AKAGnf8AgOv+FH/CEeFv+gBp3/gOv+FH9tYL+SX3oP7Nfc+e/wC17L/nqf8Avk0f2vZf89T/AN8mvoF/BPhYPH/xINN5b/ngvof89/6h/wDwhHhb/oAad/4Dr/hR/bWC/kl96D+zX3Pnv+17L/nqf++TR/a9l/z1P/fJr6E/4Qjwt/0ANO/8B1/wo/4Qjwt/0ANO/wDAdf8ACj+2sF/JL70H9mvufPf9r2X/AD1P/fJo/tey/wCep/75NfQn/CEeFv8AoAad/wCA6/4Uf8IR4W/6AGnf+A6/4Uf21gv5Jfeg/s19z57/ALXsv+ep/wC+TXS614j0vXNT8Cw2E5kexMMVxuQrtbdGO45+6elev/8ACEeFv+gBp3/gOv8AhU1p4U8PWF0lza6NYQzxnKSJAoZT6g44qXnGDUlOMJXV7aq2qsa08FKF7Pc1pThBzj5l747j3H+fXpT6ZKcIOcfMvfHce4/z69KfketfLnohRRketGR60AFFGR60ZHrQAUUZHrRketABTITmCM5zlRznPb6n+Zp+R60yE5gjOc5Uc5z2+p/maAH0hpaaaAGmlT7lIadH9wUALiiorqUwWssoxlVJGa5zT7+4GoIXlZhIwDgng00ribsdRTH6ipKjk+8v40hiVV/if/eP86tVV/jf/eNNCJj99f8AeH86s1WP31/3h/OrNDGFFFFIAooooAKKKKACiiigAooooAKKKKACszxFftpfhvUr9IxI1vbPIEJwDgHvWnWD42/5EbXP+vKX/wBBNbYaKlWhF7Nr8yZu0Wz5603WL3+xoNPuNJtNRsIWdolmBDIzHkhgQR9On6VVvptYvb6K68vyDBgW6W5CLAAcgIAeOec9SeTzVrSP+QbH9T/Or1foU8R7KrLlit33/wA+vU+elWlsFv4i1S0uVvrfQ9Oj1P8AivBH8zHudu7aCe5AHU+tYaLqkel3GniEeRPKkz5xncoYDnP+0a3KKzhiuTaC6d+m3Xp0E682cv8A2Xe/88D+YpyadfxurpE6upBVlYAg+o5rpqK2/tKp2RPtGRnXdT8xrtdFsE1Rgc36piTcergbtof/AGsVmabJqWmrdBbC3n+0psYzoHK+688GteisY4nlTioKz9f8/wACvbzZnabdahZWhsrnS7e/s929Ybn/AJZtxkqVIK5wM84NN1O51C/tks4NNgsbJG3+Rb8Bm/vMSSWOOOTxWnRT+tvm5+VX+f32va/mHtpWsYjDVW0iPSxAFtkmM5C4y7kAZY55wBgfU+tW/Deoa14W1M6hp9tE0xjMREw3DBIPYj0FaFFOWMc4OEopp7+YlWkndG7/AMLU8af8+Wn/APfo/wDxdH/C1PGn/Plp/wD36P8A8XWFRXF7LC/8+Y/d/wAE1+uVu5u/8LU8af8APlp//fo//F0f8LU8af8APlp//fo//F1hUUeywv8Az5j93/BD65W7m4Pin40BJ+x2HPP+rP8A8XS/8LU8af8APlp//fo//F1hUUeywv8Az5j93/BD65W7m7/wtTxp/wA+Wn/9+j/8XR/wtTxp/wA+Wn/9+j/8XWFRR7LC/wDPmP3f8EPrlbubv/C1PGn/AD5af/36P/xdH/C1PGn/AD5af/36P/xdYVFHssL/AM+Y/d/wQ+uVu5u/8LU8af8APlp//fo//F0f8LU8af8APlp//fo//F1hUUeywv8Az5j93/BD65W7m4Pin40BJ+x2HPP+rP8A8XS/8LU8af8APlp//fo//F1hUUeywv8Az5j93/BD65W7m7/wtTxp/wA+Wn/9+j/8XR/wtTxp/wA+Wn/9+j/8XWFRR7LC/wDPmP3f8EPrlbubv/C1PGn/AD5af/36P/xdH/C1PGn/AD5af/36P/xdYVFHssL/AM+Y/d/wQ+uVu5u/8LU8af8APlp//fo//F0f8LU8af8APlp//fo//F1hUUeywv8Az5j93/BD65W7m5/wtPxpkn7HYZPH+rP/AMXS/wDC1PGn/Plp/wD36P8A8XWFRR7LC/8APmP3f8EPrlbubv8AwtTxp/z5af8A9+j/APF0f8LU8af8+Wn/APfo/wDxdYVFHssL/wA+Y/d/wQ+uVu5u/wDC1PGn/Plp/wD36P8A8XTW+Lviy1eOS6stPMW4ZXy2G4emd3FYlZeu/wDHpH/v/wBDWtHDYSpUUHRjr5f8EccXVb3PqGGQywRyFdpdQxGc4yKfUVr/AMekP/XNf5VLXwUt2e+MJ/fKM/wnjP09/wCn/wBd9NOfNX02n+nv/T/67qQBRRRQAUUUUAFFFFADHOGj56t6+x9/8f60+mOcNHz1b19j7/4/1p9ABRRRQAUUUUAFFFFADHOGj56t6+x9/wDH+tPpjnDR89W9fY+/+P8AWn0AFFFFABRRRQAUUUUAMkOFHOPmXv7j3H+fXpT6ZIcKOcfMvf3HuP8APr0p9ABRRRQAUUUUAFFFFABToTmCM5zlRznPb6n+ZptOhOYIznOVHOc9vqf5mgB9NNOppoAa3SnR/cFNPSiNhjb3FAiG+tXvLfyVm8sE/N8uc1kRaBP57bpQiryrgZz+GeK6DNGaabQWTEQMqKGbcwHLYxmmydV/Gn5qN2DMAO1IYVU/jb/eP86t1VH32/3j/OmhEx++v+8P51Zqsfvr/vD+dWaGMKKKKQBRRRQAVxOredZPr9/FveCRjBcxjnAMK7XA9icH2PtXbUUAcodVuo9Q8r7dsnWeKKLT9qfvYiFy/I3HqxyDgbfrUVxc3z6ZFez6xPAn9peWxQRoscYkZeSV+nXjpx69hRQBydnNdW2qSPHdHyZtVeFodi7SDHnJOM5yB0IHsal8SQSNqMMMe4LqkX2OQjtht2f++TJXT0UAcLb6hqC6L/aCssEjzR2ck8jhBGkakFiSrBcvuGSp6/jWh/a91FPpHnanbzrMoV47KaNmlYsQGwVyyepXbjnj06qigDE8OSSMt/HNfy3Msd3IpSVlJjG47eAARkc8/hTPG3/Ija5/15S/+gmt6vPPibq+rRvYeHNMjtj/AGxFNFIZgcgADoc8cE9jXZl9KVXEwjHo7/Jav8EZ1ZKMGzx/SP8AkGx/U/zq9XMwancWsQhQJtUnqKl/tu6/uxf98n/Gv0Crgas6kpLqz51wbZ0NFc9/bd1/di/75P8AjR/bd1/di/75P+NZ/wBn1vIXs2dDRXPf23df3Yv++T/jWppf2/UoJrqSezs7KEhXubjcF3HooAyWbAJwBUTwVSC5pWsNUpPRF2iqGqtqGlrBMJrS6tJwTFc2+SjEdV5wQwyMg+oqhDqt/cTxwQxI8sjBEVVOWJ4A60RwVSUeZNWB0pJ2N6ipP7MuWuPsSa3oz6hu2C2DPy/90PjbnPHXrWXp9zJdXE0N5qFnpzRcf6RHIcnOCPlB5HvWccPKSbT29f8AIbozRoUU6axkGk3uoWut6XdR2iqZFjjlU/McADcoGSe31qlBqEDwRtJNErlQWG7oan2MrXWvTqKVOUdy3RVf7da/8/EX/fQo+3Wv/PxF/wB9Cp9nPsyLMsUVX+3Wv/PxF/30KPt1r/z8Rf8AfQo9nPswsyxRVf7da/8APxF/30KPt1r/AM/EX/fQo9nPswsyxRVf7da/8/EX/fQo+3Wv/PxF/wB9Cj2c+zCzLFFV/t1r/wA/EX/fQo+3Wv8Az8Rf99Cj2c+zCzLFFV/t1r/z8Rf99Cj7da/8/EX/AH0KPZz7MLMsUVX+3Wv/AD8Rf99Cj7da/wDPxF/30KPZz7MLMsUVX+3Wv/PxF/30KPt1r/z8Rf8AfQo9nPswsyxRVf7da/8APxF/30KPt1r/AM/EX/fQo9nPswsyxRVf7da/8/EX/fQo+3Wv/PxF/wB9Cj2c+zCzLFFV/t1r/wA/EX/fQo+3Wv8Az8Rf99Cj2c+zCzLFFV/t1r/z8Rf99Cj7da/8/EX/AH0KPZz7MLMsVl67/wAekf8Av/0NXPt1r/z8Rf8AfQrO1m4hmtkWOVHIfOFOexrowtOSrRbRUU7n0brNxaWvh2KW9u7qCJfLIW0kKSTN2jBHPJ9CPrjNZMdlrEXhW3gv76QX5kkkjhk1FoWKYJCNKoLOVHJwR05OBXSmxtNQ06CG9tILmIKrBJ4w4Bx1wRSHRdKNmLM6XYm1DbxB9nTYG9duMZ96/O5bs+nRw893c3ngGzvbfV7p54rKRnZ74wScEAybV5kIIwMuB0zya6m+1FYvA0uoi7mQGyDrcbB5gJUYbGcZyfX8avXGk6Zci3t7jTrKaKFSIkkgRhGOPug9B9BU5sbNppJmtLcyyR+U7mJdzJ/dJxyPakByXgi5vRqOo2Ooz3P2iOKBxDJcm4XBXl1ckn5jzt7e9drVaz06x05XWxsra1VzlhBEqBj74HNWaACiiigAooooAY5w0fPVvX2Pv/j/AFp9Mc4aPnq3r7H3/wAf60+gAooooAKKKKACiiigBjnDR89W9fY+/wDj/Wn0xzho+erevsff/H+tPoAKKKKACiiigAooooAZIcKOcfMvf3HuP8+vSn0yQ4Uc4+Ze/uPcf59elPoAKKKKACiiigAooooAKdCcwRnOcqOc57fU/wAzTadCcwRnOcqOc57fU/zNAD6Q0tIaAGGo2UHrUhpUHy59aYisUX0o2L7VbxRii4yqEX0qRQAOKmxTGGGHvQIQVVH32/3j/OrQqsPvt/vH+dAEp++v+8P51Zqsfvr/ALw/nVmhjCiiikAUUUUAFFFFABRRRQAUUUUAFFFFABXnPjrb/wALD8Hb84zP0+gr0avIPibrs1n4/wBBSysZLq7sonlEW3cJd/GABk8bTXq5NTlUxNo/yy/9JaMMQ0oa91+ZwdjPpviXUBo50e1sPNDC2nty29GAJG8kneDjB6dcjFVLOO00XQrfVbiyhvrq7lkjhinyYo1TG5iARuJJwOcDGeeMaMXnRQG+0HwpqcF3cx/LcEPLHGjjkxDb3BwCScA8c81BptpqkdgdM1Twzqd3YeYZYxHC8ckLkAEq20jBAAIIPQEYr7nmVnZ2jppzK73vrf0662ffXzbff6DNYt9OutH0LUbaxSzmvZpknSNiUO0oMrk5A5PHvT/F82l6Zquo6JpmlW6xQzFTcybml3Z5wc4CjoBjtmpNWj1W9tNOsbLwrqFpaWDu0YMMju+4qSWO3rle3HNZ+r6Zr+raxeai+g6hG1zK0pQW0hC5OcdKqha8XOWi5tOb+9pfXXT1CXWy7dDn66K/+XwHowj+413ctIf9sCMD/wAdqh/wjeu/9AXUf/AV/wDCtjTLTVYLCTTdS8M6ld2DyeaqpC8ckUmMblbaeo4IIwcD0ror1YPllFp2d7XXZr9bkRi9UytBlvh5eCQfImpRGI/7RjfcPyC1m6HbXl3rllBYOI7tplMTscBCDncfYYzW1qtnq91awafYeGtStNPhYyCNoXd5JCMF2baMnAAAxgU+WDWIdTsr/SvCt7YS2oHAt5HEjDqTle/PFZRq2jK1ryu91ZaaX16+VxuOq8jVTXfB51zzYdLkjvi+U1Bi3kibP+s8ndwuecZOPTtXEapbXNnq13b3pzdRzMspznLZ5Oa6tbO3WQXcfgbV/tAO4RFpDAGHts3Yz2z7ZrJe11tNYOtapol5OqzfaJxLbuiNg5OTjhf6VGFcacm4t7dZJu/S2r/y2sOd2tfyJde/4k+h2GgLxO2L2+9fMYfIh/3UP5ua9G8OfCfw9qvhvTdQuJb8TXNukrhJVAyRk4+WvPIfCvirxZ5mt2+nSXSXcruZQ6AFsnPBPrX0R4WsZ9O8KaVZ3cfl3ENrGkiZB2sFGRkcV4ud4yWHoQjRq+/d81nrfr+J0YekpybktOhx3/Cl/DH/AD21H/v8v/xNH/Cl/DH/AD21H/v8v/xNekbR6UbR6V81/a2O/wCfsvvOv6vS/lPN/wDhS/hj/ntqP/f5f/iaP+FL+GP+e2o/9/l/+Jr0jaPSjaPSj+1sd/z9l94fV6X8p5qvwZ8MFnHnajwcf65fQf7NO/4Uv4Y/57aj/wB/l/8Aia9FQAvJ7N6+w9/8P6l+0elH9rY7/n7L7w+r0v5Tzf8A4Uv4Y/57aj/3+X/4mj/hS/hj/ntqP/f5f/ia9I2j0o2j0o/tbHf8/ZfeH1el/Keb/wDCl/DH/PbUf+/y/wDxNH/Cl/DH/PbUf+/y/wDxNekbR6UbR6Uf2tjv+fsvvD6vS/lPN/8AhS/hj/ntqP8A3+X/AOJo/wCFL+GP+e2o/wDf5f8A4mvSNo9KNo9KP7Wx3/P2X3h9Xpfynmq/BnwwWcedqPBx/rl9B/s07/hS/hj/AJ7aj/3+X/4mvRUALyezevsPf/D+pftHpR/a2O/5+y+8Pq9L+U83/wCFL+GP+e2o/wDf5f8A4mj/AIUv4Y/57aj/AN/l/wDia9I2j0o2j0o/tbHf8/ZfeH1el/Keb/8ACl/DH/PbUf8Av8v/AMTR/wAKX8Mf89tR/wC/y/8AxNekbR6UbR6Uf2tjv+fsvvD6vS/lPN/+FL+GP+e2o/8Af5f/AImj/hS/hj/ntqP/AH+X/wCJr0jaPSjaPSj+1sd/z9l94fV6X8p5qPgz4YMjL52o4AB/1y+/+z7U7/hS/hj/AJ7aj/3+X/4mvRQB5zD/AGRxn3Pv/T8+z9o9KP7Wx3/P2X3h9Xpfynm//Cl/DH/PbUf+/wAv/wATR/wpfwx/z21H/v8AL/8AE16RtHpRtHpR/a2O/wCfsvvD6vS/lPN/+FL+GP8AntqP/f5f/iakg+DnheC4imJvpRG4by5JVKtg5wRt6GvRNo9KNo9KTzbHPT2svvH9XpdiJVVECKoVVGAAMAClqTaPSjaPSvPNiAn98oz/AAnjP09/6f8A130pA85R/snjPuPf+n5d37R6UAR0VJtHpRtHpQBHRUm0elG0elAEdFSbR6UbR6UAQOcNHz1b19j7/wCP9afSuAHj929fY+/+P9Q/aPSgCOipNo9KNo9KAI6Kk2j0o2j0oAjoqTaPSjaPSgCBzho+erevsff/AB/rT6VwA8fu3r7H3/x/qH7R6UAR0VJtHpRtHpQBHRUm0elG0elAEdFSbR6UbR6UAQSHCjnHzL39x7j/AD69KfSygBB2+Ze/uPcf59elP2j0oAjoqTaPSjaPSgCOipNo9KNo9KAI6Kk2j0o2j0oAjp0JzBGc5yo5znt9T/M07aPSmwnMEZznKjnOe31P8zQA+mmnU00ANNOj+4Ka3SnR/cFADLmcW1u8xUttGcA9azY9ZYzAPbOI5GAiOMZ9cnpVzUbX7XZsgUM45TJxzWYbbULoR200aeVAy5PI3D61SsJ3N6o5PvL+NPRQiKijCqMCmSfeX8akYVWH33/3j/OrNVh99v8AeP8AOmIkP31/3h/OrNVj99f94fzqzQxhRRRSAKKKKACiiigAoqjq95Jp+mS3MSqzoUADjI5YD+tN1DUlsJ4VfJRo5ZGCpkkIueDkY/I59qANCisH/hKrcBmawv1VUSViyIMRscB/vdM9vve1WJPEEEd5JA1rdeXFOsElxtXy1dgNv8WcHcBwOO+KANaisePxHbOpkNtcpC0cksMrBdswTk7fmz05G4DNNXxLbeU7y2t3CREssaSIu6VWO1duGPJJAwcdRmgDarynXv8Akv2hf9ew/lLXpdjqC3vnIYJbeaFgskMu3cuRkH5SQQQexrzTXv8Akv2hf9ew/lLXrZR8dX/BP8jCvsvVHmul/wDIIsv+uCf+girdVNL/AOQRZf8AXBP/AEEVbr6Cl/Dj6I+fqfGwooorQgKKKKACiiigAqvff8eM/wDuH+VWKr33/HjP/uH+VXT+Neo1ueifA7/kG6p9Yv5yV6zXk3wO/wCQbqn1i/nJWlrWvXFr4j1ia7iuZbHTzboI4tSe2Kq/VgiY8w5Pc44xXy2d/wDIwq+v6H0GD/gr5/mz0eiuKu3udJ8WxXWoSXE9jqVzHFZrFfyr5Dbf4ouFYE9eT9K7WvLOkKKKKAGIcvJz0b19h7/4f1L6Yhy8nPRvX2Hv/h/UvoAKKKKACiiigAooooAYhy8nPRvX2Hv/AIf1L6Yhy8nPRvX2Hv8A4f1L6ACiiigAooooAKKKKAGA/v2Gf4Rxn3Pv/T8+z6YD+/YZ/hHGfc+/9Pz7PoAKKKKACiiigAooooAYT+/UZ/hPGfce/wDT8u76YT+/UZ/hPGfce/8AT8u76ACiiigAooooAKKKKAGOcPHz1b19j7/4/wBQ+mOcPHz1b19j7/4/1D6ACiiigAooooAKKKKAGOcPHz1b19j7/wCP9Q+mOcPHz1b19j7/AOP9Q+gAooooAKKKKACiiigBkpwg5x8y98dx7j/Pr0p9MlOEHOPmXvjuPcf59elPoAKKKKACiiigAooooAKZCcwRnOcqOc57fU/zNPpkJzBGc5yo5znt9T/M0APppp1IaAGGljPyUhqM5BypxTEWKKrbpP7/AOgpN0n98/kKLDLVRycsoqINJ/f/AEFOUdycmgQ+qw++3+8f51YFVh99v94/zoQEp++v+8P51Zqsfvr/ALw/nVmhjCiiikAUUUUAFFFFAFbULFNRsZLSR5I1fHzR43DBBGMgjqPSqcmiLOF+1X13cMqSIGfy1IDrtP3UA7cVq0UAZcug2s0cqNJMBJbx25wR91CSD0681Amgs+oXc9zdSG3luVnW3QrsbaqgFsruzlc4BxwK26KAMR/Dsa28qRXMz4hljtopSvlw7xjjC59uScCiDw5H9kMd3dXE8xhSISMVBiCnI2YUdGAOSCeBmtuigCpY6etl5zmeW4mmYNJNLt3NgYA+UAAADsK8j8d6vFoPxk0rU54pZY4LVSY4gCzZ8xRjPua9nrxn4veH70+ItK1q2uIh57x2catwUkBLKSemP8K9rIfZvFOFR6Si196OfE35Lrozze21SOytYbWaGUSwosbgjGCBg/yqX+3bf/nlL+n+NQXWmXd14qn0+4vLd7+S5aN5SWCNKTyM7e7cdMfhVcaNdC0vbmXZDHZyCGTzDyZDn5ABnJ4Ptx1r7eGEwqil5Lr32PGdK7bL/wDbtv8A88pf0/xo/t23/wCeUv6f41n/ANkzHQjq6ywtAtwLdkBO8MVLDgjGMDsak1fRLjRWtkupYGkuIEuFSNiSqMMrnjGfaqWFwrly9f8AIXstLlz+3bf/AJ5S/p/jUttqf2y4S3tbS5mmc4WONNzH6AVzdatl/aVjo1zqVncCGCSQWkhQ4kORuwDjIHHODzTqYKjGOm/mwVOLNW/uZ9LlWO/067tnYZUSx7dw9s9aqf27b/8APKX9P8aq27anqWkXcAud9nZL9paOVs7ckL8mRkcsMgYz+FZVFPA0mmpbrswdOPQ6ODVRdTCG3tLiaUgkJGm4nAyeB7DNRtqH2+3uIre2ndliZ2wudqgck+wqzpem6/o+sR2VjcRW1/d2jM6kAtHGVL7Wyp2kqM4HPIziuYBZScEjIwamnhaMpNw6Wa19f8tBuklueqfDLXrjw3o15cPoWqXltPtKzWsIZRsL55JHr+lepaHd6L4x02119dMiZySI3uYEMsZViODzjkZGDXz/AKdI+ieELrUC7LcakWs7QZ+7GOZnH14TPu1e0/CT/knVh/10l/8ARjV8zn+DpqE8Slq5Wv8AJ3/y9Uz0sJNpqHS1zrBpWnLfm/Gn2ovDybgQr5nTH3sZ6cVcoor5M7wooooAYhy8nPRvX2Hv/h/UvpiHLyc9G9fYe/8Ah/UvoAKKKKACiiigAooooAYhy8nPRvX2Hv8A4f1L6Yhy8nPRvX2Hv/h/UvoAKKKKACiiigAooooAYD+/YZ/hHGfc+/8AT8+z6YD+/YZ/hHGfc+/9Pz7PoAKKKKACiiigAooooAYT+/UZ/hPGfce/9Py7vphP79Rn+E8Z9x7/ANPy7voAKKKKACiiigAooooAY5w8fPVvX2Pv/j/UPpjnDx89W9fY+/8Aj/UPoAKKKKACiiigAooooAY5w8fPVvX2Pv8A4/1D6Y5w8fPVvX2Pv/j/AFD6ACiiigAooooAKKKKAGSnCDnHzL3x3HuP8+vSn0yU4Qc4+Ze+O49x/n16U+gAooooAKKKKACiiigApkJzBGc5yo5znt9T/M0+mQnMEZznKjnOe31P8zQA+kNLTTQA00KoIyaDTo/uCgBvlr6frR5a+n61Jiqt5fQ2IQy7vmPAUZoAn8tfSmkbT7U9WDoGU5BGQabJ95fxoAQVW/ib/eP86s1VH32/3j/OmhEx++v+8P51Zqsfvr/vD+dWaGMKKKKQBRRRQAUUUUAFFFFABRRRQAUUUUAFeafGC/tbWz0FZpBuTUUnMYPzFFB3ED8RXpdeTfFmKOfxb4QhlRXjknKujDIYGSMEGvVyWKljYc2yu/uTMMQ/3bscHeDw+fEU/iEawtxbm5a5WyELrM7btwQ/wgZ/iz07Z4qhbavbatBqVhqk32X7bdfbIrkKWWKX5shgOdpDYyM4wOOtb/wdVZ/Ga+YiNnTASNoxnEfP19697+y2/wDzwi/74FfQYzN4YSUabi5XjFp3St1XS3+Zy06DqLmvY+adQl0qw8INo9tqQvrx75bh3ijZY1UIy4BYAk8jsOtZ/iXUYNT1KGe3ZmRbSCIlhj5ljVW/UGvqb7Lb/wDPCL/vgUfZbf8A54Rf98CuanxLCEub2Tb1+0utv7vkW8G2rX/D/gnyDW7ot7Zvpt7o2ozm2gumSWO42FxFKmQNwHOCGI45HFfUP2W3/wCeEX/fAo+y2/8Azwi/74FaVOKY1I8rpP8A8C7fISwTTvzfgfMlxNYaLoV3p1lfx391flBNJEjLHFGh3BQWALEnB9Bis+4i0+1s7G5sdQeW9PzTRGIqImHTBPBr6r+y2/8Azwi/74FH2W3/AOeEX/fAqIcTRj/y7eru/eWultfd/IbwbfX+vvPnXQPiFrFvrEcup6tcPahJAw2gkkowXtn72K5a9v7rVr77Rf3JklfCtK46D8K+sI7W3Kn9xEfmb+Eep+v+fTpT/stv/wA8Iv8AvgUqfEdCnNzhQs2raNf/ACIPCSas5f1958s+JNTg1C/jisdw06ziW2tQwwSi9WI9WYlj9a93+Erbfh3Ycf8ALSX/ANGNXX/Zbf8A54Rf98CpFVUUKoAA6ACuHMc5ji8NHDxp8tne979/JdzSlh3Tm5t3JN/tRv8AamUV4J1D9/tRv9qZRQAI/wA8n+969OB7/wCH9S/f7VChy0nPRvX2Hv8A4f1p9AD9/tRv9qZRQA/f7Ub/AGplFAD9/tRv9qZRQAI/zyf73r04Hv8A4f1L9/tUKHLSc9G9fYe/+H9afQA/f7Ub/amUUAP3+1G/2plFAD9/tRv9qZRQAB/3zD/ZHGfr7/0/Ps/f7VCD++YZ/hHGfr7/ANP/AKz6AH7/AGo3+1MooAfv9qN/tTKKAH7/AGo3+1MooAC/75R/snjP09/6fl3fv9qhJ/fKM/wnjP09/wCn/wBd9AD9/tRv9qZRQA/f7Ub/AGplFAD9/tRv9qZRQAO/zx/73r14Pv8A4/1D9/tULnDR89W9fY+/+P8AWn0AP3+1G/2plFAD9/tRv9qZRQA/f7Ub/amUUADv88f+969eD7/4/wBQ/f7VC5w0fPVvX2Pv/j/Wn0AP3+1G/wBqZRQA/f7Ub/amUUAP3+1G/wBqZRQASvhB2+Ze/uPcf59elP3+1QyHCjnHzL39x7j/AD69KfQA/f7Ub/amUUAP3+1G/wBqZRQA/f7Ub/amUUAP3+1JCcwRnOcqOc57fU/zNNp0JzBGc5yo5znt9T/M0APppp1NNADT0p0f3BTT0p0f3BQBW1GCe4tdlvJsfOTzjIrInVbJVF/a+fIx4k80nNdFTHjjkAEiK4ByAwzTTE0LGytEjKMKQCB6CmydV/GpKjk6r+NIYlVP42/3j/OrdVP42/3j/OmhE5++v+8P51Zqsfvr/vD+dWaGMKKKKQBRRRQBhjxVp50a51PbP5VvKYnj2jfuzjgZ75z16VpHU7BblLZr23W4c4WFpVDk4BxjOc4I/Ouel8IyyWcg+0oJHgZPKwdhk+YK+evCsR09PSnf2Xe3WpajELeFLaS6gka4dmDkIqH5Rtw3IIzkYyaAOjF3bNtxcRHcWC4cclfvAfTBz6VXOt6SASdTsgFKgn7QvG7kd+/asq30XUI7yDe1r9mgkuHUh2Lv5m7GRjAxnpk/XtUY8MzLYrCv2ZXXS2swRkDzDyT06dff2oA3f7SsftbWgvLc3SjJgEq78Yz93OelQwa3p00No7XUMD3aB4YppFV2B6YGefwrKbRdUbWobp5IpYoZdybrmQbUMe0qI9u3IJJ3dT7VWn8O6s1nZWyzQvHbwxKE+0yRqJEbJOFUhwcAfN064oA6VdQsnuvsq3lu1xz+6Eql+OvGc8UxNW02VpVj1C0doQTKFmUlAOpbnjHvWWNBnDh90KMb+S6dkJztZGUduSMisvT7XVLhzFbxi1a1082sVwY5EDNkYPzop7HoGx6mgDrrW8tb6HzrS5huIs43xOHXPpkV5f8AFP8A5HPwb/18/wDtSOu+0HTrrTheC5VAJpRKuLl5mHygEFnAJ+719/avPvizLHB4t8ITSuqRxzlndjgKBJGSTXrZIr42PpL/ANJZhif4f3fmcp8F/wDkc0/7Bg/lHXtOt6/DoUTSz2V7NCieZJLBGuyMZA5LMMnJ6DJ9q8M+E+p2OleK1n1C7htYf7P8vfM4UbsJxk9+D+Vek+Ktb0XWoBDa6x4cY7MR3Fxc7ZrZ9wO9GUHsOny8gcnpXRnOHrSrQcYN+5Ho+xnhpRUHd9TstS1a10rSJdTuS4t40DYVfmbPQAHucio9L1uDVJrm3EFxbXNsVEsFwqhgGGVPykgg/XtXP3fifw9d6ZNp11qmiXsBgVMzahsMz8Z3AKdvrkEnNUPDWo+HNHvtRvrjxBpYmvGQLEl+0wjRRgDfIdzH8B7V5P1Wv/I/uZ088e56DRWF/wAJr4Y/6D+nf+BC/wCNH/Ca+GP+g/p3/gQv+NH1Wv8AyP7mHPHubtFYX/Ca+GP+g/p3/gQv+NH/AAmvhj/oP6d/4EL/AI0fVa/8j+5hzx7m1Gcqec/M3f3Puf8APp0p9YCeNPDIU51/Ts5PW4X1+v8An2p3/Ca+GP8AoP6d/wCBC/40fVa/8j+5hzx7m7RWF/wmvhj/AKD+nf8AgQv+Na1ne2uo2qXVlcRXFu+dskThlODg8j3qJ0KtNXnFpeaBSi9mT0UUVkUFFFFADEOWk56N6+w9/wDD+tPpiHLSc9G9fYe/+H9afQAUUUUAFFFFABRRRQAxDlpOejevsPf/AA/rT6Yhy0nPRvX2Hv8A4f1p9ABRRRQAUUUUAFFFFADAf3zDP8I4z9ff+n/1n0wH98wz/COM/X3/AKf/AFn0AFFFFABRRRQAUUUUAMJ/fKM/wnjP09/6f/XfTCf3yjP8J4z9Pf8Ap/8AXfQAUUUUAFFFFABRRRQAxzho+erevsff/H+tPpjnDR89W9fY+/8Aj/Wn0AFFFFABRRRQAUUUUAMc4aPnq3r7H3/x/rT6Y5w0fPVvX2Pv/j/Wn0AFFFFABRRRQAUUUUAMkOFHOPmXv7j3H+fXpT6ZIcKOcfMvf3HuP8+vSn0AFFFFABRRRQAUUUUAFOhOYIznOVHOc9vqf5mm06E5gjOc5Uc5z2+p/maAH0006kNADDTNzJnAyKeaQKWpiG+e39z9aTz2/ufrTvK9/wBKPK/2v0oAQTt/c/WjJY7j+VOEXv8ApQRg4oAKqj77/wC8f51aqr/E3+8f50ICY/fX/eH86s1WP31/3h/OrNDGFFFFIAooooAKKKKACiiigAooooAKKKKACvIvjZp9zNJoV3FGkiCVoAhPLO2CBj0O0969drz34sNssvD7F9gGrRHcTjbw3Nepk1R08dCS8/yZjiFemzxi68L6w95dh7S3iuUJkayjmTzAOpCxhi2AO3pWbpmlXerXDRWyrhF3yyyMEjiX+8zHgCuuvNA1SHx5caq6GDTkv2ujf7gYljEmdwbOCf8AZ654xmqkbpr2na5Y6YoW6nvxeRW+cNPEN/yrnqV3A7ep5wOK+9hi5OF009Fqtlfe+vz39Ty3BXMbU/Dd/pdmL2UwTWbSCNbi3mWRGbBOAR34NSyeFNSgsjd3ZtrWIxiSL7RMqNMCob5AeW4I/HjrWpeaZeaR8O5IL+M208uppItu7Yk2iNhuK9QMjvVPxrcm51e0/eB1j061RdpyFHlKcfmTV0q9WpJRi01d627W8/MUoxSuc3XQ6JHBYaJfa5Nbw3EsUsdvbRzruj3sCSxX+LAXgHjJrnq6XRI21fw3qGiQYa+8+O7t4i2DLtDK6jsThgcexxXRinanrtdX9L6/8HyJhuOkmj8R+H7+5ntraHUNOCSCS3iEfnRs21gyrwSCVIP1rmK6pLG48OeGtUOpwtbXeookFtC/DlQ4Z2K9h8oGT3PFY9xo91p1nY6hdRI1tc/MiiQZYDqDjkVnh6kI8yi9L+79yvb53/Ec09LnT+CtEsUaK81eFJpL2OZbG2cZBCoxaZh6Ajavqcn+Guf8L6ZDqmuJFco8lvFG88qIcF1RS238SAPxrr9B8Wabqviq3muNBt4ZVt3jWUXThURYmAVVzgDAx+PrWJ4Z1u0tfFE01tDHpcdzaS20TeazLDIy/K248j5sc9BnNcXPiP3rcWpOKe6svi2s3/w+vY0tD3dev+RNrX9swaXN/avhuyhtHAWNoIERrVuoG5ckfR+tetfCb/knlj/10l/9GNXkmj6TqXh24vL7WYmtbD7NLDKJGBFyWQhUUZ+bJIORkDGe1et/CYE/Dux4/wCWkv8A6MavIz1x+pcsbNcy1W2z83r316nRhr+0u+x21FLtPpRtPpXxZ6AlFLtPpRtPpQBGhy0nPRvX2Hv/AIf1p9NQEvJ7N69OB7/4f1p+0+lACUUu0+lG0+lACUUu0+lG0+lACUUu0+lG0+lAEaHLSc9G9fYe/wDh/Wn01AS8ns3r04Hv/h/Wn7T6UAJRS7T6UbT6UAJRS7T6UbT6UAJRS7T6UbT6UARg/vmGf4Rxn6+/9P8A6z6aAfOYf7I4z9ff+n/1n7T6UAJRS7T6UbT6UAJRS7T6UbT6UAJRS7T6UbT6UARk/vlGf4Txn6e/9P8A676aQfOUf7J4z9Pf+n/137T6UAJRS7T6UbT6UAJRS7T6UbT6UAJRS7T6UbT6UARucNHz1b19j7/4/wBafTXBDx+7evXg+/8Aj/Wn7T6UAJRS7T6UbT6UAJRS7T6UbT6UAJRS7T6UbT6UARucNHz1b19j7/4/1p9NcEPH7t69eD7/AOP9aftPpQAlFLtPpRtPpQAlFLtPpRtPpQAlFLtPpRtPpQBHIcKOcfMvf3HuP8+vSn02UEIO3zL3x3HuP8+vSn7T6UAJRS7T6UbT6UAJRS7T6UbT6UAJRS7T6UbT6UAJToTmCM5zlRznPb6n+ZpNp9KWE5gjOc5Uc5z2+p/maAH0hpaaaAGmnR/cFNNOj+4KAEkljhG6SREB4yxxTDdW6qrNPEFboS4waq6tYyXsUYjdFKEk7jgVk/2fJPpsUyvGFjD53HGeT0qkkJs6UEMAQQQeQRTJOq/jUWnjGn2+f+eYqWTqv41IxKqj7z/7x/nVqqv8b/7xpoRMfvr/ALw/nVmqx++v+8P51ZoYwooopAFFFFABRRRQAUUVU/tXTvtv2L7fa/as48jzl356425zQBbooooAKKKKACvI/jDb/b9f8L6e8siwXMrRuFbplkXIHTOCa9cryn4p/wDI5+Df+vn/ANqR162RtrGxa7S/9JZhif4b+X5nnnw903T9f8U2el6jDLNZ3Ftv8vzyu1/LDluMdwRj374r2IfCXwepBGnzAjkEXMnH615L8JP+SgaT/wBep/8ARFfRs08VtC808qRRINzu7BVUepJ6V35zjsTTq0+So1eEW7NrV31MMLTjKL5l1ONf4TeEJGLPYTMx6k3UhP8AOm/8Kk8Hf9A6X/wJk/xrtYZoriFJoZEkicBldGBVh6gjrUcV5az3E1vFcwyTw482NHBaPPTcOo/GvI/tPG/8/Zfezq9jT/lRx3/CpPB3/QOl/wDAmT/GlHwk8HA5Gny5/wCvmT/Gu3oo/tPG/wDP2X3sPY0/5UcS/wAJ/CEjbnsZ2Y92upCf503/AIVJ4O/6B8v/AIEyf413FFH9p43/AJ+y+9h7Gn/KjhY/hN4OZSTp8n3iOLl+xx/ep3/CpPB3/QOl/wDAmT/Gu1iOUPOfmbvnufc/59OlPo/tPG/8/Zfew9jT/lRxLfCbwgwUNYTEKMAG6k4/Wun0bRrHQdMi07TojFbRElVLFjkkk8nnqav0VlWxmIrR5as3JebbHGnCLukFFFFcxYUUUUAMQ5eTno3r7D3/AMP6l9MQ5eTno3r7D3/w/qX0AFFFFABRRRQAUUUUAMQ5eTno3r7D3/w/qX0xDl5OejevsPf/AA/qX0AFFFFABRRRQAUUUUAMB/fsM/wjjPuff+n59n0wH9+wz/COM+59/wCn59n0AFFFFABRRRQAUUUUAMJ/fqM/wnjPuPf+n5d30wn9+oz/AAnjPuPf+n5d30AFFFFABRRRQAUUUUAMc4ePnq3r7H3/AMf6h9Mc4ePnq3r7H3/x/qH0AFFFFABRRRQAUUUUAMc4ePnq3r7H3/x/qH0xzh4+erevsff/AB/qH0AFFFFABRRRQAUUUUAMlOEHOPmXvjuPcf59elPpkpwg5x8y98dx7j/Pr0p9ABRRRQAUUUUAFFFFABTITmCM5zlRznPb6n+Zp9MhOYIznOVHOc9vqf5mgB9NNOppoAa3SnR/cFNNNWQJw3T1oEOnt4rmPy5l3LnOMkUySyt5UjR4lKx/dXoBTvPj/vfoaPPj9f0NMZKAAMAYFRydV/Gk8+P+8fyNIX3tnHApALVT+Nv94/zq3VUfff8A3j/OmhEx++v+8P51Zqsfvr/vD+dWaGMKKKKQBRRRQAUUUUAIwJRgpwSOD6Vzuk3smn2djpn9m3X2lW8ub9y4QHBJk8zBU5Pv/FXR0UAcLbS6sYr9guooZIY5FiKXBMbCTLqGcnJ2/wB3AbsKtXST392LqaHUhbR6kjRgLKrCPysZCryBu9uMnOOa7CigDkNmq/2hqTy3V2suycRQpbzFGXb+7KvuMYPToA2cinGHU7a2uEjfUJA9rbu7Mzu+4sfN2ejbey+2BmutqOaCK5haGeJJYnGGR1DKw9waAMbw5L5kmpqj3bQJcBYhdM5dR5akj5/mHJPX1rhvin/yOfg3/r5/9qR16hbWtvZwiG1gigiByEiQKo/AV5T8YZ/sOv8AhfUHikaC2mZ3Kr6MjYz0zhTxXrZGm8bFLtL/ANJZhif4b+X5nFfCT/koGk/9ep/9EV7P4503VNU0p4bSKGazWJ3lh8xlkkcD5AAFO4A844yQOa8Z+EgP/CwdMGD8kDoT7iEj+lfSFb5/Fxr04y3UI/qZ4P4Jev8AkczokmoW/hGwsEt/I1X7EBEs0chiUgYG9tmFP+yefrWV4L0nUtK8Ua0Luz2RyJEWuDI7iV8EkqxRd2SST0weOa7uivCOsKKKKACiiigBkRyh5z8zd89z7n/Pp0p9MiOUPOfmbvnufc/59OlPoAKKKKACiiigAooooAYhy8nPRvX2Hv8A4f1L6Yhy8nPRvX2Hv/h/UvoAKKKKACiiigAooooAYhy8nPRvX2Hv/h/UvpiHLyc9G9fYe/8Ah/UvoAKKKKACiiigAooooAYD+/YZ/hHGfc+/9Pz7PpgP79hn+EcZ9z7/ANPz7PoAKKKKACiiigAooooAYT+/UZ/hPGfce/8AT8u76YT+/UZ/hPGfce/9Py7voAKKKKACiiigAooooAY5w8fPVvX2Pv8A4/1D6Y5w8fPVvX2Pv/j/AFD6ACiiigAooooAKKKKAGOcPHz1b19j7/4/1D6Y5w8fPVvX2Pv/AI/1D6ACiiigAooooAKKKKAGSnCDnHzL3x3HuP8APr0p9MlOEHOPmXvjuPcf59elPoAKKKKACiiigAooooAKZCcwRnOcqOc57fU/zNPpkJzBGc5yo5znt9T/ADNAD6Q0tIaAGGm4z0FONKn3KYiIxt/dpPLb+7VjFFFxkARvSnYxxUtMfqKBCCqv8Tf7x/nVqqv8T/7x/nQgJj99f94fzqzVY/fX/eH86s0MYUUUUgCiiigAooooAKKKKACiiigAooooAKa8aSLtdFYejDNOooA5XwJpOmxeDfDt5Hp9ol0dNt2M6wqHJMS5O7GcnJz9a6qub8DSpL4A8OtG6uo023UlTkZEagj6ggj8K36qUpN+8JJLYloqKipGS0VFRQBLRUVFADojlDzn5m757n3P+fTpT6rxnKnnPzN39z7n/Pp0p9AEtFRUUAS0VFRQBLRUVFADkOXk56N6+w9/8P6l9V0OWk56N6+w9/8AD+tPoAloqKigCWioqKAJaKiooAchy8nPRvX2Hv8A4f1L6roctJz0b19h7/4f1p9AEtFRUUAS0VFRQBLRUVFADgf37DP8I4z7n3/p+fZ9Vwf3zDP8I4z9ff8Ap/8AWfQBLRUVFAEtFRUUAS0VFRQA4n9+oz/CeM+49/6fl3fVcn98oz/CeM/T3/p/9d9AEtFRUUAS0VFRQBLRUVFADnOHj56t6+x9/wDH+ofVdzho+erevsff/H+tPoAloqKigCWioqKAJaKiooAc5w8fPVvX2Pv/AI/1D6rucNHz1b19j7/4/wBafQBLRUVFAEtFRUUAS0VFRQA6U4Qc4+Ze+O49x/n16U+q8hwo5x8y9/ce4/z69KfQBLRUVFAEtFRUUAS0VFRQBLTITmCM5zlRznPb6n+ZptOhOYIznOVHOc9vqf5mgB9NNOppoAaadH9wU1ulOj+4KAK9/PHDAA8mwuwUEEjvzz24qtLLBEUkt70Eqw3J5pk3j0wT/KrF/YrexqD95DkDOAfY1TbR43XaLWKPP8QnYkfgRVKwmaqOsiB1OVIyDTZPvL+NLDEsEKRKSVQYGetJJ1X8akYlVf43/wB41aqp/G3+8f500InP31/3h/OrNVj99f8AeH86s0MYUUUUgCiqGuO8eg37xu0brbuVdDgqdp5B7GsBdXu7K7FtdNJNcWNpNIwyQLhQFKP9eoPoQaAOuormZtb1O1jeNzZTzskEkbxxsqASSbCCNxPuDn8Kg1S81eJdYje9hKwW8LIIojEQ7E5IbcSBx7/4gHW0VzNzrmp2yzW3lQzXYu0t0aKPC/Mm/wC6zjJ7feGf0qzDqOrS31rayw29u5tTPcK6ljkNjC7WwM9epx70AbtFYGi6vf3s1qt4ttturT7QohVgUwQMEknOc56DHv1pQi6hq2pLd3lxD9kKiKOK4aIIhUHeQpG7Jz97I+X60Ab1Fc4mu3Ta8lrFsmsWd4fN8rbh1TcRu3/N/wB8Ae9VV8S6jBp0V5cR2swnsnuUjgRlMZXb94ljkHd7Y9+tAHW0VnaPcajcWrtqNuIZA/yEBRvXA5wHfHOR97tWjQBxfwt/5JnoX/XA/wDoTV19ch8Lf+SZ6F/1wP8A6E1XdDv76fxNr9hc3TzwWjxeQHRAUDKSRlVGfx9K0q/HL1ZFP4EdFRXFePPFk2jQNZ6ZdwQXyKs0jSFSQhYAKqt95jyenAB9RXYW0yXFrFNHIsiSIGDoQQwI6gisyyWiiigAooooAZGcqec/M3f3Puf8+nSn0yM5U85+Zu/ufc/59OlPoAKKKKACiiigAooooAYhy0nPRvX2Hv8A4f1p9MQ5aTno3r7D3/w/rT6ACiiigAooooAKKKKAGIctJz0b19h7/wCH9afTEOWk56N6+w9/8P60+gAooooAKKKKACiiigBgP75hn+EcZ+vv/T/6z6YD++YZ/hHGfr7/ANP/AKz6ACiiigAooooAKKKKAGE/vlGf4Txn6e/9P/rvphP75Rn+E8Z+nv8A0/8ArvoAKKKKACiiigAooooAY5w0fPVvX2Pv/j/Wn0xzho+erevsff8Ax/rT6ACiiigAooooAKKKKAGOcNHz1b19j7/4/wBafTHOGj56t6+x9/8AH+tPoAKKKKACiiigAooooAZIcKOcfMvf3HuP8+vSn0yQ4Uc4+Ze/uPcf59elPoAKKKKACiiigAooooAKdCcwRnOcqOc57fU/zNNp0JzBGc5yo5znt9T/ADNAD6aadSGgBhpYyMbe4oNMZQeopiJqKreWvpR5a+lIZZqNyGYAdqjEa+lPC4FMAqr/ABv/ALxq3VT+J/8AeP8AOhCJj99f94fzqzVY/fX/AHh/OrNDGFFFFIBskaSxtHIiujDDKwyCPQimmCFplmMUZlVSiuVG4KeoB9OBUlFAFSHS9PtomjgsLWKNmDsqQqoLDkEgDqKfLYWc8plmtIJJCmwu8YJK5zjJ7Z7VYooAglsrSdJUmtYZEmIMqvGCHx03Z69B1ohsrW2CiC2hiCJsUJGF2rnOBjtnnFT0UARR2tvEUMcESGNNiFUA2r6D0HA4qK602xvnR7uyt7h4/uNLErlfpkcVaooAqPpWnvcm5axtjcEgmbyV35HQ7sZzUem6Lp+lW4itbaJSUCPJ5ah5AP7xAGav0UAV7SxtLCMx2drBboxyVhjCAn1wKsUUUAcX8Lf+SZ6F/wBcD/6E1dJFpdnBd3l1FCUnvMee6yMC2BgY5449MVifDu0+xfDvw/Fv37rKOXOMffG/H4bsfhXTVdRpzbRMFaKTKVzpNle6UdMuo5J7RgAVkmdmODkZYncefergAVQo4AGBS0VBQUUUUAFFFFADIzlTzn5m7+59z/n06U+mRnKnnPzN39z7n/Pp0p9ABRRRQAUUUUAFFFFADEOWk56N6+w9/wDD+tPpiHLSc9G9fYe/+H9afQAUUUUAFFFFABRRRQAxDlpOejevsPf/AA/rT6Yhy0nPRvX2Hv8A4f1p9ABRRRQAUUUUAFFFFADAf3zDP8I4z9ff+n/1n0wH98wz/COM/X3/AKf/AFn0AFFFFABRRRQAUUUUAMJ/fKM/wnjP09/6f/XfTCf3yjP8J4z9Pf8Ap/8AXfQAUUUUAFFFFABRRRQAxzho+erevsff/H+tPpjnDR89W9fY+/8Aj/Wn0AFFFFABRRRQAUUUUAMc4aPnq3r7H3/x/rT6Y5w0fPVvX2Pv/j/Wn0AFFFFABRRRQAUUUUAMkOFHOPmXv7j3H+fXpT6ZIcKOcfMvf3HuP8+vSn0AFFFFABRRRQAUUUUAFOhOYIznOVHOc9vqf5mm06E5gjOc5Uc5z2+p/maAH0UUUANIpMU+kxQA3FJinYoxQAmKKdijFADcVU/ib/eP86uGqf8AG/8AvH+dNCJT99f94fzqzVY/fX/eH86s0MYUUUUgCiiigAooooAKKKKACiiigAooooAKKKKAMDwSo/4QHw5/2C7b/wBFLW7sFYfgj/kQfDn/AGC7b/0Utb1ADdgo2CnUUAN2CjYKdRQA3YKNgp1FAEUSgoec/M3f3Puf8+nSn7BSRHKHnPzN3z3Puf8APp0p9ADdgo2CnUUAN2CjYKdRQA3YKNgp1FAESKC8nPRvX2Hv/h/Uv2CkQ5eTno3r7D3/AMP6l9ADdgo2CnUUAN2CjYKdRQA3YKNgp1FAESKC8nPRvX2Hv/h/Uv2CkQ5eTno3r7D3/wAP6l9ADdgo2CnUUAN2CjYKdRQA3YKNgp1FAEQUecwz/COM+59/6fn2fsFID+/YZ/hHGfc+/wDT8+z6AG7BRsFOooAbsFGwU6igBuwUbBTqKAIio85Rn+E8Z9x7/wBPy7v2CkJ/fqM/wnjPuPf+n5d30AN2CjYKdRQA3YKNgp1FADdgo2CnUUAROoDx89W9fY+/+P8AUP2Ckc4ePnq3r7H3/wAf6h9ADdgo2CnUUAN2CjYKdRQA3YKNgp1FAETqA8fPVvX2Pv8A4/1D9gpHOHj56t6+x9/8f6h9ADdgo2CnUUAN2CjYKdRQA3YKNgp1FAEUqgIOcfMvf3HuP8+vSn7BSSnCDnHzL3x3HuP8+vSn0AN2CjYKdRQA3YKNgp1FADdgo2CnUUAN2CkhOYIznOVHOc9vqf5mn0yE5gjOc5Uc5z2+p/maAH0UUUAFFFFABRRRQAUUUUANNU/43/3j/Orhqn/G/wDvH+dNCJT99f8AeH86s1WP31/3h/OrNDGFFFFIAqG7laCznmUAtHGzAHpkDNTVHPEs8EkLEhZFKkjrgjFAGFY69ONGbUr4iRNqEqlsbXZuH96ZwrDkcg/nVmDxHa3MlgkEMztexmRBujG1QcHOWGcf7O6m/wDCPZt4IW1W+YW7K0DEQ5jKggYxHg8HvmlHhyH7Na2rXl09tbyCRYmEeCQ24ZOzcMexHFAETeKYbeG7lvLSW3WG5NshaWMea3XglgBxzyQPcnip7fxDbXb2q20FxN9oh84FAuEUHadx3Y4Ppn2zTpNChdpmW6uY2knFyhQr+6kxglcr3HUNkVYi01UuVuZLiaaZYDAXfaNwJzkhQBn6UAV9M12DU5I0jt7mHzYfOiaZVAdcgHGCSMEjrjPbIpDd6jeX11FYtaxRWriNjNGzmRtoYgYYbQARz83XpxzNZ6Pb2T2rRvKTbW5t03EcrkHJ468CkuNIEt3JcwXt3aPMAJhAy4kwMAncpwccZXB/SgCM69bprK6VLGy3DKSCJI2Bwu7oG3ge5UVBH4qs2txcTW91bQNA1xHJMqgSKMZxhiQeR1xntTx4dhS++1R3d0pExnEWUK7yu08lS3I9/pioLDwwkenRQahcS3LLb+QFLAJEDjOwhQew5OTxQBoaRrFtrNvJNbZAjfYwLo2DgHqjMp4PY1oVXs7aS1iKS3k90c8PMEBHt8qrVigDmPDF9Fpvww0W+nz5Vvo9vI+OuBCp4qTQ/FEup6hHZXmnfY5ZrRbyDbN5geMnGD8owRxxz9aj8MWMWpfDDRbGfPlXGj28b464MKjijS/C15p1yLt9VjuLuGzWztma2ISNAcksofLE8dxQA+68WJH4gm0mAaeJIdiu15fCAszchUXaxY4x6cnFdJXIar4HOp3V7J/aCRR6h5Ju1FtuYtGeqMW+TPod2K65VCqFHQDHNAC0UUUAFFFFADIjlDzn5m757n3P+fTpT6ZEcoec/M3fPc+5/wA+nSn0AFFFFABRRRQAUUUUAMQ5eTno3r7D3/w/qX0xDl5OejevsPf/AA/qX0AFFFFABRRRQAUUUUAMQ5eTno3r7D3/AMP6l9MQ5eTno3r7D3/w/qX0AFFFFABRRRQAUUUUAMB/fsM/wjjPuff+n59n0wH9+wz/AAjjPuff+n59n0AFFFFABRRRQAUUUUAMJ/fqM/wnjPuPf+n5d30wn9+oz/CeM+49/wCn5d30AFFFFABRRRQAUUUUAMc4ePnq3r7H3/x/qH0xzh4+erevsff/AB/qH0AFFFFABRRRQAUUUUAMc4ePnq3r7H3/AMf6h9Mc4ePnq3r7H3/x/qH0AFFFFABRRRQAUUUUAMlOEHOPmXvjuPcf59elPpkpwg5x8y98dx7j/Pr0p9ABRRRQAUUUUAFFFFABTITmCM5zlRznPb6n+Zp9MhOYIznOVHOc9vqf5mgB9FFFABRRRQAUUUUAFFFFADTVP+N/94/zq4ap/wAb/wC8f500IlP31/3h/OrNVj99f94fzqzQxhRRRSAKKKKACiiigAooooAKKKKACiiigAooooAwfBH/ACIPhz/sF23/AKKWt6sDwSw/4QHw5/2C7b/0Utbu8UAOopu8UbxQA6im7xRvFADqKbvFG8UAJEcoec/M3fPc+5/z6dKfUUTgoec/M38z7n/Pp0p+8UAOopu8UbxQA6im7xRvFADqKbvFG8UAIhy8nPRvX2Hv/h/UvqJHG+Tn+L+g9/8AD+pfvFADqKbvFG8UAOopu8UbxQA6im7xRvFACIcvJz0b19h7/wCH9S+okcb5Of4v6D3/AMP6l+8UAOopu8UbxQA6im7xRvFADqKbvFG8UAID+/YZ/hHGfc+/9Pz7PqIOPOYZ/hHH4n3/AKfn2fvFADqKbvFG8UAOopu8UbxQA6im7xRvFACE/v1Gf4Txn3Hv/T8u76iLjzlGf4Tx+I9/6fl3fvFADqKbvFG8UAOopu8UbxQA6im7xRvFACOcPHz1b19j7/4/1D6idxvj5/i/off/AB/qH7xQA6im7xRvFADqKbvFG8UAOopu8UbxQAjnDx89W9fY+/8Aj/UPqJ3G+Pn+L+h9/wDH+ofvFADqKbvFG8UAOopu8UbxQA6im7xRvFACSnCDnHzL3x3HuP8APr0p9RSuAg5x8y/zHuP8+vSn7xQA6im7xRvFADqKbvFG8UAOopu8UbxQA6mQnMEZznKjnOe31P8AM0u8UkJzBGc5yo5znt9T/M0APooooAKKKKACiiigAooooAaap/xv/vH+dXDVP+N/94/zpoRKfvr/ALw/nVmqx++v+8P51ZoYwooopAFFFVbjUrS1aZZ5ghhh8+TIPCc8+/Q0AWqKggvbe5kCQybmMay8A/cbO0/jg1PQAUUyOWOXf5civsba2052n0PvT6ACiiqNzq9laXBgleQyABnEULybAehYqDtH1x0NAF6ikBDKGUggjII70tABRRRQBzvgn/kQvDv/AGDLb/0Utbtcjo2rxaF8KtE1CWNpRHpdqFjU4LsY1AGe3JrW0fW5NRvb6xurMWl5ZlN6LL5isrDKsG2j34xQBsUUUUAFFFFABRRRQAyM5U85+Zu/ufc/59OlPpkZyp5z8zd/c+5/z6dKfQAUUUUAFFFFABRRRQAxDlpOejevsPf/AA/rT6Yhy0nPRvX2Hv8A4f1p9ABRRRQAUUUUAFFFFADEOWk56N6+w9/8P60+mIctJz0b19h7/wCH9afQAUUUUAFFFFABRRRQAwH98wz/AAjjP19/6f8A1n0wH98wz/COM/X3/p/9Z9ABRRRQAUUUUAFFFFADCf3yjP8ACeM/T3/p/wDXfTCf3yjP8J4z9Pf+n/130AFFFFABRRRQAUUUUAMc4aPnq3r7H3/x/rT6Y5w0fPVvX2Pv/j/Wn0AFFFFABRRRQAUUUUAMc4aPnq3r7H3/AMf60+mOcNHz1b19j7/4/wBafQAUUUUAFFFFABRRRQAyQ4Uc4+Ze/uPcf59elPpkhwo5x8y9/ce4/wA+vSn0AFFFFABRRRQAUUUUAFOhOYIznOVHOc9vqf5mm06E5gjOc5Uc5z2+p/maAH0UUUAFFFFABRRRQAUUUUANNU/43/3j/Orhqn/G/wDvH+dNCJT99f8AeH86s1WP31/3h/OrNDGFFFFIArD1zS5769sXgUNGWMN1lsfuiQx+vKgfjW5RQBxi+H9S/sKSGZXeT7SoaJDGzSW6fKoG/Kk/xYbj6VOdImjbSWtrC5eS2+UfbFt3SNS2TnacqwHIKew+nWUUAcddeH5zHfRQ2GxJL8Tv5Kw5uIiPugPkEgnOHAHpV2y0PF7ZSS2srQ29mY4/tRjZ0ffkcKduQOhHArpKKAOb0HRZdMnsn+zCL/QSlywYEtJlcZOecDOOwHFWgL7TdRvni0+S8iunEiPFIilCFC7W3EccZBGep49dqigDkm03UP8AhKRqL2G0CVg0kIhCmMpgEtxIxz1B49BVDS9IurvRoXsLQ2Lvp7RvcFk/0lm27ehJwADyw4zwK7yigDH8O2H9n2MkYt7qANJu8u48kYOAPlEXygce3Oa2KKKAOM0bSItd+FWiafLI0Qk0u1KyKMlGEakHHfkVraPokmnXt9fXd4Lu8vCm91i8tVVRhVC7j785qLwT/wAiF4d/7Blt/wCilrdoAKKKKACiiigAooooAZGcqec/M3f3Puf8+nSn0yM5U85+Zu/ufc/59OlPoAKKKKACiiigAooooAYhy0nPRvX2Hv8A4f1p9MQ5aTno3r7D3/w/rT6ACiiigAooooAKKKKAGIctJz0b19h7/wCH9afTEOWk56N6+w9/8P60+gAooooAKKKKACiiigBgP75hn+EcZ+vv/T/6z6YD++YZ/hHGfr7/ANP/AKz6ACiiigAooooAKKKKAGE/vlGf4Txn6e/9P/rvphP75Rn+E8Z+nv8A0/8ArvoAKKKKACiiigAooooAY5w0fPVvX2Pv/j/Wn0xzho+erevsff8Ax/rT6ACiiigAooooAKKKKAGOcNHz1b19j7/4/wBafTHOGj56t6+x9/8AH+tPoAKKKKACiiigAooooAZIcKOcfMvf3HuP8+vSn0yQ4Uc4+Ze/uPcf59elPoAKKKKACiiigAooooAKdCcwRnOcqOc57fU/zNNp0JzBGc5yo5znt9T/ADNAD6KKKACiiigAooooAKKKKAGmqf8AG/8AvH+dXDVP+N/94/zpoRKfvr/vD+dWarH76/7w/nVmhjCiiikAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBzvgn/kQvDv8A2DLb/wBFLW7WN4I/5EHw5/2C7b/0Utb1AEVFS0UARUVLRQBFRUtFAFePlT3+Zv5n3P8An06U+nRHKHnPzN3z3Puf8+nSn0ARUVLRQBFRUtFAEVFS0UAV05aT2b+g9/8AD+tPpyHLyc9G9fYe/wDh/UvoAioqWigCKipaKAIqKlooArpy0ns39B7/AOH9afTkOXk56N6+w9/8P6l9AEVFS0UARUVLRQBFRUtFAFcf65h/sjj8/f8Ap/8AWfTgf37DP8I4z7n3/p+fZ9AEVFS0UARUVLRQBFRUtFAFc/65R/snj8vf+n/1304n9+oz/CeM+49/6fl3fQBFRUtFAEVFS0UARUVLRQBXfho/dv6H3/x/rT6c5w8fPVvX2Pv/AI/1D6AIqKlooAioqWigCKipaKAK78NH7t/Q+/8Aj/Wn05zh4+erevsff/H+ofQBFRUtFAEVFS0UARUVLRQBXk4UdvmX+Y9x/n16U+nSnCDnHzL3x3HuP8+vSn0ARUVLRQBFRUtFAEVFS0UARU6E5gjOc5Uc5z2+p/mafTITmCM5zlRznPb6n+ZoAfRRRQAUUUUAFFFFABRRRQA01T/jf/eP86uGqf8AG/8AvH+dNCJT99f94fzqzVY/fX/eH86s0MYUUUUgCisXxR5v9kx/Z9nnfaoNm/O3d5i4zjtWVFqDWFkjQlhfNK0N9HIoL+e6/Ixx/DkALjjBHpQB19FcdJrd+unu0920LRypZmUmOJfNBbe7MyMFUjHY88VTuNQ0vWtP0221WXTvtc0ZNxdTmMGNFYghScYYkY4xjk8cUAd7RXK3WtGynntILqNAJLVbSNQDmJioYjjleoz29aZaakdOMHmTrDbSXd4HLAYZg5Kge/XAHJoA62isXTL3VrrS7Cdbe1nEsKPJLLOY2yevyiMj9RXP6h51jb6xcpve1url4Zl6+W/Gxx7H7p/A0Ad1RXIx61cT+Jns1vykDtNCInkj8xHUcELsBXODjLNkdqzZNfurTQtP8nV3e5+zmWR55YgGIIBTmMlmHPy5Bx1NAHoFFY+hust1q0iMGVrsMGU5BBiTkVsUAc14VvbbTvhroN5dzLDbxaTbM7t0A8pa19M1ix1dZWspmcwtskV42jZDjPKsARx7VyUGk3OtfBzRbO02m4/syzkRGOA5VEbbn3xitbw9p98uuavq17afYxd+UkcDOrNhFxuJUkck9M9qAOlooooAKKKKACiiigBkRyh5z8zd89z7n/Pp0p9MiOUPOfmbvnufc/59OlPoAKKKKACiiigAooooAYhy8nPRvX2Hv/h/UvpiHLyc9G9fYe/+H9S+gAooooAKKKKACiiigBiHLyc9G9fYe/8Ah/UvpiHLyc9G9fYe/wDh/UvoAKKKKACiiigAooooAYD+/YZ/hHGfc+/9Pz7PpgP79hn+EcZ9z7/0/Ps+gAooooAKKKKACiiigBhP79Rn+E8Z9x7/ANPy7vphP79Rn+E8Z9x7/wBPy7voAKKKKACiiigAooooAY5w8fPVvX2Pv/j/AFD6Y5w8fPVvX2Pv/j/UPoAKKKKACiiigAooooAY5w8fPVvX2Pv/AI/1D6Y5w8fPVvX2Pv8A4/1D6ACiiigAooooAKKKKAGSnCDnHzL3x3HuP8+vSn0yU4Qc4+Ze+O49x/n16U+gAooooAKKKKACiiigApkJzBGc5yo5znt9T/M0+mQnMEZznKjnOe31P8zQA+iiigAooooAKKKKACiiigBpqn/G/wDvH+dXDVP+N/8AeP8AOmhEp++v+8P51Zqsfvr/ALw/nVmhjCiiikAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBg+CP+RB8Of9gu2/8ARS1vVg+CP+RB8Of9gu2/9FLW9QAUUUUAFFFFABRRRQAyI5Q85+Zu+e59z/n06U+mRHKHnPzN3z3Puf8APp0p9ABRRRQAUUUUAFFFFADEOXk56N6+w9/8P6l9MQ5eTno3r7D3/wAP6l9ABRRRQAUUUUAFFFFADEOXk56N6+w9/wDD+pfTEOXk56N6+w9/8P6l9ABRRRQAUUUUAFFFFADAf37DP8I4z7n3/p+fZ9MB/fsM/wAI4z7n3/p+fZ9ABRRRQAUUUUAFFFFADCf36jP8J4z7j3/p+Xd9MJ/fqM/wnjPuPf8Ap+Xd9ABRRRQAUUUUAFFFFADHOHj56t6+x9/8f6h9Mc4ePnq3r7H3/wAf6h9ABRRRQAUUUUAFFFFADHOHj56t6+x9/wDH+ofTHOHj56t6+x9/8f6h9ABRRRQAUUUUAFFFFADJThBzj5l747j3H+fXpT6ZKcIOcfMvfHce4/z69KfQAUUUUAFFFFABRRRQAUyE5gjOc5Uc5z2+p/mafTITmCM5zlRznPb6n+ZoAfRRRQAUUUUAFFFFABRRRQA01T/jf/eP86uGqf8AG/8AvH+dNCJT99f94fzqzVY/fX/eH86s0MYUUUUgCiiigAooooAKKKKACiiigAooooAKKKgvLqKxtJLmYkRxjJwMk+gHuTxQA+CCG1t47e3iSKGJQkccahVRQMAADgADtUlU7HUFvTKhglt5oWAkhm27lyMg/KSCCPQ+tXKACiiigAooooAKKKpX2o/Y5oIUtLi6lmDFUhKDAXGSS7KO4oAu0VmXmtw2UxjeCdxGivO6BSIFY4BbJ9j93PTNafUZFABRRRQAUUUUAFFFU4dQSW/urMxSxvbqrln27WVs4IwSex64oAuUVkw+IbSRXkkjmgiEJnjklUYljHVlwSfTggHkcVZsdSW9eSJree2mjCsYp9u7a3RhtJGOD37UAXaKKKACiiigAooqp9vX+1f7PMMquYjKsh27GAIBA5znkdRQBboqhbap9puJ0FncJDCzo1w5TYSpwcANu/Sm2Gsw38wjWCeEvH5sJlCgSpnG5cE+3BweRxQBo0UUUAFFFFABRRVC81RbK4RJbW4MLMqG4VV2KzHAB53HnHQHrQBforN/tqD7d9m8mby/N8j7RhfL8zGdnXOe2cYzxnNFprUF3dLCsMyJJu8iZwuybacHbg5/MDI5FAGlRRRQAUUUUAFFFUdR1MaanmPa3EsSqXkkiC4jUdSckZ+gyeOlAF6iqB1TOo/Y4bO4mwiO8qFAiBs4J3MD2PQGmLrUDXwtxDMIzKYFuCF8syAZKdc54POMZGM0AaVFFFABRRRQAUUVVv702MHmi1nuMAkrDt4AGSSWIH65oAtUVkz6/bQhGWC4lTylnlZFGIY26MwJB7HgAng8U+TW7eO88jypmjWRYnuFC+WjsAVU855yOQCORzQBp0UUUAFFFFABRRUF1cNbRb0t5rhicCOLbk/ixAH4kUAT0VlnXENtZSwWd1cNeKWjjTYGAAyc7mA/Imlu9bhs5TG9vcNsRZJ2QKRArHALfN7H7uemaANOijqMiigAooooAKKKbJIkMTyyMFRAWZieAB3oAdRWTF4gt59PguoLe5ka4kaKKDaqyMVJzwxAH3SeSPz4ofxBb+RDJDb3Nw8iM5hjVd6Kpw24EgcHjAJOemaANaio4Jo7iCOeJg8cihlYdwelSUAFFFFABRVPVNTt9IsJLy53lE/hQZZj6Af56VHNqnl3kVtFZXNw8kYlJjMYCLnGTuYfpmgDQorNl1qCK9NuYZjGsixSXAC+XG7dFPOe45AI5HNaVABRRRQAUUUUAFFFFABRRRQA01T/AI3/AN4/zq4ap/xv/vH+dNCJT99f94fzqzVY/fX/AHh/OrNDGFFFFIAooooAKKKKACiiigAooooAKKKKACqeqWTahp0tujhHO1kYjgMpDDPtkCrlFAGfp1rdJc3V3eCJJpyo8uFy6oqjj5iASSST0rQoooAKKKKACiiigArK13TpNStliitLOZ8MFmuHIaAkcOmFJyOvVeg5rVooAwbzR713uUt5YXjvYEhuJJWIdNuQWUAEMSCeCRgjvW6BtUAdhilooAKKKKACiiigArPXT3Oq3ty7L5VxBHEAD8wI3Z/9CFaFFAHNr4fvLi0FpdywpFBaNawvESxfOPnYEDHCjgE9TzWlp9peC8mvL4QJK8aRLHA5dQq5OSSo5JY8Y4x3rSooAKKKKACiiigAqi9nI2uRXoZfKS3eIjPOSyn8uKvUUAYY0eSTV5rg29raQvHIkht3Je53YwXG0DI57t16+r9M029guLd7xoNlpbfZ4vKYkyAkZZsgbeFXgZ781s0UAFFFFABRRRQAVkXdpqE+sxSmG1nsYtpjR52Qq/dyoQhiO3Ix9eRr0UAYQ0i7F15O6H7B9sN3v3HzM53bNuMY3c5z04x3pdP0m8tp7OOZofstiHELIxLybuBuBAC4BPQnJ9K3KKACiiigAooooAKyNXtNQu54EhitZ7JQTLDNO0e9s8ZwjZUenfvWvRQBjX+mTXep2s8dtZxGJkZrwOfOAByUA2/dPT73QnimR6ReJdpCWh+wpdtdhwx8wk5OzbjGNxPOenatyigAooooAKKKKACs7WLSS9tBFHaWd1znZdMVCnHDAhW5H0H1FaNFAHOy6LqKxPFFPDMbq1jtrmaZmDLtyC6jB3EhjwSOQOakfRrsXEsETQ/Yp7iO4d2Y+YpXb8oXGDkoOcjGTxW9RQAUUUUAFFFFABVPU7d7qzMS2lpdgkbobo4Rh9drfXof61cooA5+40a6l0K3spLeyvLhFYedcOw8knoUO1iSM4HIPA5outGvj58UE0Ukd5BHBcSysQ67QQWUAHcSCeCRg+tdBRQAgG1QB2GKWiigAooooAKqalYDUrX7O1xNAN6vui25ODnB3Agj2xVuigDnbXQ7+xtrZ0uEubq3uZZVEzbVZXLZG5U4PIPQ85HToqaPqFmIri2a2ku2jlSYSOyoC778qQpJwc8YGR3FdDRQBXsbUWVhb2oYsIY1j3HvgYzViiigAooooAxte0N9XgcxXk0MwheNFG3yyWGMtlSR6ZGDjNR6jo9xdR2kSRWzSxKg+3ytieLBBJQKnfHqo56Vu0UAYc2kXbXc8cbQ/Yri5S5kcsfMUrtyoXGDkoOcjGTxW5RRQAUUUUAFFFFABRRRQAUUUUANNU/43/3j/Orhqn/G/wDvH+dNCJT99f8AeH86s1WP31/3h/OrNDGFFFFIAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigApkzFIJGU4IUkflT6QgEEEZB6g0Ac1Yalq0VtBPPG9wt15SRCd40O8gksCg4TgdeatSeIjAGlltB9nDyRhkly5dASflwMD5Tzn04FbHkQ7I08pNsZBQbRhccDHpTPsNp9oe4+yw+e42tJ5Y3MPQnqaAMaDVbpL+d7mJRu+zqsSTl1XeSM5Kjn8O3Wp4Nclu7hYLW0jZyZcmSbau1H25BCnJPpj8avJpWnRwyQpYWqxSY3osKhWx0yMc0raZp7xJE1jbNHGdyIYlIU+oGOKAMtdauF3PcxIsaXUsX7h8kqiseQV/2R0Iz7dCv/CQTLH89inmukUkaJPkMsjbRklRg+3P1rXWztVmaZbaESs28uEG4tjGc+uCRTItPsoFZYbO3jVmDsEiUAsOQTgdaAKyajJLpN3cvF5UsHmqyo+4ZTPQlfbuPwquutyi6WL7IDEHijaUy/NmRQRhdvPXnkf0rW8iIRvH5SbJCS67Rhs9cjvmk+y2+c+RFnIb7g6jofw7UAZWqX93HcXVrGsQiFi83mCQiRSMjjj6VHBrdwqR28lov2pjEiAz/ACtuUnLNt4OFPQHnvWxLa287q81vFI6gqGdASAeCOexpJLK0mR0ktYXRwAytGCGA6Z9cUAZR8RBbZ5WtgDHDLIw8zjdG20qDjkE9/wBKlbW2jnnjmgjhVIvNjMkjfvBgdMIRjJxwSfarsmm2M0cccllbukQxGrRKQg9hjigabYhpWFlbhpRtkPlLlx6HjkUAZcfiC4mii8uwXznkkQo8rIF2DJPKBv8Ax2obvWp7q3H2aHy0Bt2kkMxVhvYHAAHIxweRW3Dp1lbgCCzt4gM42RKvUYPQenFI2m2DyRyPZWzPGAqMYlJQDoAccUAV9U1KWweJIbZZ2dJHO6XYFCAE9j61QbxNKkQLaed8nlGJVkZ8hwxG7ahIOF6AGt54YpSDJEjkAqCyg4B6j8aiexs5Imje1gaNlVSrRgggdBj0HagDJ/t27U3Er2SrFFaJceW7lZQxzlSCvqP85wHyaxcQTOklsDMfJVIvOGwM5YDLbcjpz19B76X9nWOFH2O3wqeWv7peE/ujjp7U+W0tplkWW3ikEgCuHQHcB0B9cUAU9Rvbyz06OZYbfzzKiMjSnYNzAcNtz39P8DCNbf7Tta1UQfaDbbxLlvMC5+7t+775z7VomztTafZTbQ/ZsY8nYNmPTHSkFjaLcfaBawCfbt8wRjdjGMZ64xQBl2+u3U9u8g04eYbdLiONZixZSSOcLxjGeM/nxWpY3QvbKK4GzDrn5CSAfTkA/mBQ9hZyR+XJaQNHtCbWjBG0HIGMdB6VNHFHDGscSKkajCqowAPYUAOooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAGmqf8b/AO8f51cNU/43/wB4/wA6aESn76/7w/nVmqx++v8AvD+dWaGMKKKKQBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUANNU/43/3j/Orhqn/ABv/ALx/nTQiU/fX/eH86s1WP31/3h/OrNDGFFFFIAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoopGYKpZjgAZJoAWisEeIbg3zRrp5a3UbmdWcuq4zkgR7Acc7d+7BHGeKvajqLWi2q28Uc011J5cQkl8tM4LcsAewOMA5NPlYro0KKoR6rbx3ENle3FpBqEq7hbrPuJ5/hJCk/l60h13SBbzz/ANp2ZigIErLMrBCTgA4PFFmF0aFFUf7XsPLeY3UC2yIr/aDMnlkMSBzn26ng9s0ket6VLcQ28epWjyzruiVZlJkGcfLzz0P5GizC6L9FVrXUbG+aRbS8t7hozhxDKr7D74PHSq0moXcGoRRTWca2s0hijlE+XzgnJTbgDg/xE9OPQsFzSorHt9ZnmkjLWQENwrtaskuWk284YFQFyORyffFPi1S6VrqK7sAtxCiyLHbS+aHDEgDJVcHIPUY7564LMLo1aKrafdm+063umj8syxhym7dtz2z3rkPEHxKtPDV9NZ3ljLLKshEfksMFMA5JOMHk8DPTrSGdxRXKeGvH+l+KtSNlYQXSukJldplUAcgY4Jyea6ugBpqn/G/+8f51cNU/43/3j/OmhEp++v8AvD+dWarH76/7w/nVmhjCiiikAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU11DoyN0YYNOooA59NN1iK8kSOaJbSQbXYS8ngDf5ZjzuwAP9ZjvjtWlqEEr2ItoLK0vI2wrxXcpVCv/fDZ7dRV6incVjCttM1K0+z+U8BPkyRuWkY+Tlty7Mg7wvTB28AfSqlvoOohLp5WjE0tt5Q33ks4Zwc7iXA2g+ijj3rqKKfMw5UYdzpt7cNPcPb27TSpEBGt5JGEZS2SJFTP8Q7c85pYbPWI2t5HmgkmMLxSyO/KEnKkYQB8dOi5rbopcwWMHRdJvbO/e6uyuWhER/0yW4LHOd3zgbc/3QMD+UyQaqdZaee3s5LcHZEwuWDRoep2eXgse/ze3rnYoo5gsYMGm6nEYEP2Ux2Kv9mPmMTKSCq7xt+XAPOCc+1WdIg1CFJRfwWyySfM80Vw0hkb3BRcADgDnitWii4WKmmWr2Wl21tIVLxRhWK9Mj0rmr/wBpevaxc3+rxTSHeRFGsu1Su1eeOc5B712FFIZy3hnwFpHhW/nvLCS6eWVNmJnBCrnOBgD0HXNdTRRQA01T/jf/eP86uGqf8AG/8AvH+dNCJT99f94fzqzVY/fX/eH86s0MYVz3iPxVHod1Z2MVs91e3TYSNAflXOCxwCT9AOxroa5DxX4YuNR1nTtas086azI32/m+WZADkYbGAc+vatsMqbqWqbf1YwxLqKnenv/Vy14c8Xw67qF5p0kBgu7VjlTnDqDjIBAI+hFa76kF1dLHy8qyZaXd91zkhce4DH8B61zvhnwxcWniLUNevIVtpbrIS2EokKZILEsAB1HatKXQGl8288xxqJm85CLiQRZU/KCudv3QATt9a1qxoKo1F6W/H/ACMqUq7ppyWt/wAP8y7PrVnFfQ2UdxBLcvKI3hWYb4wQTkr17D86RtbsjqEdnBcQTylmWVY5lLRYUnkdumOcVSj0q/Wa3hZLT7NBdNcCYSMZG3buCu3APz9dxzjoM8JbaTqCNZRSpZrDZK6JIkjF5AylckbQFPQnk5qOSlbf8fX/AIGhfPVvt+Hp/wAHUvf29p3Mf2qH7SIRN9nMyb9uM/3sdO+cd84qw+o2Ud1HaSXlvHdSAFIGlUO30XOTWS2j362b2qfZmSXT1tndpGBV1DDIG05B3eox70650m+ke4t41tWtrmZJnmd28yMrt4C7cN93g7hjPTjlclO+/wDX9dB89S239f11NT+09P8Atgs/t1t9qOcQ+au84zn5c57H8qim1iyRbtIbq3mubaNpHt0mUuNo7jqPyqBNJdYXX91ua/8AtWfbfn0644rN/sHUprmSS4lRmMcyCQ3crh94IB8sjbHjjhc/X1IwpPdhKdVbI3J77yba2m8vd50kaY3Y27iBn8M0o1XTmuWtlv7UzqCxiEy7gB1OM54qO5spJrS0iVkDQyxO2ScEKQTj8qgt9JeGC1TEW6K7kuGI7hi/Tjr8w/WoShy67lN1ObQZY+JLG6tZryW7sIbNZTEkv2tTkgn73ACk4yBk8GtF7+yjEZe7gUS7fLLSAb93THPOe1ZaaZfWiWktuttNPAZgY5ZGRSHbdkMFJBGAOnc0/S9GksrmGaXyGZIGT5B91mcuQv8As84/CrnGlq1/X9fqTCVXRNf1/X5Ft9a0qNpFfU7NTGoZwZ1G0HGCeeByPzp0uradBHA82oWsaT8ws8ygSf7uTz1HSqdro7wLpgIhzaySO+O+4N046/NzWdd+H9Sms/siSxmExyKALqWERszMd2EH7zggYbAGO+aFCk3a/wDWonOqle39aG1JrWnpPPbLdQvdQgF4FlUOOnYkeo/OpjqFkL0WRvLcXZGRAZV8wjGfu5z0rNudNvpDdQoLcwzpH87SMGVlwMbduCMDrn8Ka+lXpmNuFtTaNdi6M5dvNBDBtu3bjqMbt3TtS5Kdt/6/rpuVz1L7f1/XXY049TsJbv7JHfWz3PJ8lZVL8dflzmrVZNvpLwwWqYi3RXclwxHcMX6cdfmH61rVnNRT900g5Ne8FFFFQWFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAGVb6ndXU85htYPskEjxu7XBEoZevybCOv+10OfapdM1iy1SFDBc27T+WryQJMGaPI6EDkflVWfTry61VblrWzt9mR9oimZpZUwQEYbBgZOcZOCPxpP7DY6faWu6OPyrJ7ZmQdCyqMj24PpXQ407djnUql+5oQapp90GNvf2swRgjGOZW2seADg9T6VMLq3JIE8RIfyz844f8Au/X2rEk0m/vDJJcR2dvLHb+VAIJGYFgwZWJKjABUYAB6nmpbTRZ4L62meWMxgebOqk/NPgjcOOmGP5Ck4U7bjU6l9jSn1GxtrmO2nvLeKeXHlxSSqrP24BOTRHqNjNdSWsV7bvcRAmSJZVLpj1GciqN7ZX76tHcWeyFDsEs32lssoPKmIoVP1yD7+te30i9V7SCVbVbazLlJkdjJJlSvK7QF+9k/MckUKEOW9wc581rG19qt9qt58W1kMineMFR1Ye3I5qvJrGmQxNLLqNmkav5Zdp1AD/3c56+1ZMekanJbxQXAs0WCyktUMcrMXLKoDHKjb93pz1q5LYXVtJZz2MNrI0EBg8mWQxqAdvKkK2Pu4xj+VHs4J2uHtJtXsXjqFkLtLQ3lv9pddyw+au9h6hc5I4rG8Q+Kk0W+s9Phtnur26PyxqCdi/3iACT34A7Gj+wp/wC2XuHiWaCSdZyTqEybGGOPKA2PggYJx+lUfFHhi4vde0/XbJBPNaYD23m+WZACSMNjA5POe1a0oUfaJSelvxM6s63s24rW/wCBc8NeLodfu7yxaAwXdqxDKc4dQcZGQCOexHFdJXH+FvC8+n65qGt3kS28t2TsthJ5hjBOWywABOfSuwrPEqmqlqWxeGdR071dxpqn/G/+8f51cNU/43/3j/OsEbkp++v+8P51ZqufvL/vCrFIYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQA01TP3m/3j/OrtU8fM3+8aaETMD1HUc077RH/FkH6UEUwgUAO+0w/wB4/wDfJo+1Q/3z/wB8moyopNoosBL9qh/vn/vk0fa4f75/75NQ7RRtFFgJvtcP98/98mj7XD/fP/fJqHaKNoosBN9rh/vn/vk0fa4f75/75NQ7RRtFFgJvtcP98/8AfJo+1w/3z/3yah2ijaKLATfa4f75/wC+TR9rh/vn/vk1DtFG0UWAm+1w/wB8/wDfJo+1w/3z/wB8modoo2iiwE32uH++f++TR9rh/vn/AL5NQ7RRtFFgJvtcP98/98mj7XD/AHz/AN8modoo2iiwE32uH++f++TR9rh/vn/vk1DtFG0UWAm+1w/3z/3yaPtcP98/98modoo2iiwE32uH++f++TR9rh/vn/vk1DtFG0UWAm+1w/3z/wB8mj7XD/fP/fJqHaKNoosBN9rh/vn/AL5NH2uH++f++TUO0UbRRYCb7XD/AHz/AN8mj7XD/fP/AHyah2ijaKLATfa4f75/75NH2uH++f8Avk1DtFG0UWAm+1w/3z/3yaPtcP8AfP8A3yah2ijaKLATfa4f75/75NH2uH++f++TUO0UbRRYCb7XD/fP/fJo+1w/3z/3yah2ijaKLATfa4f75/75NH2uH++f++TUO0UbRRYCb7XD/fP/AHyaPtcP98/98modoo2iiwE32uH++f8Avk0fa4f75/75NQ7RRtFFgJvtcP8AfP8A3yaPtcP98/8AfJqHaKNoosBN9rh/vn/vk0fa4f75/wC+TUO0UbRRYCb7XD/fP/fJo+1w/wB8/wDfJqHaKNoosBN9rh/vn/vk0fa4f75/75NQ7RRtFFgJvtcP98/98mj7XD/fP/fJqHaKNoosBN9rh/vn/vk0fa4f75/75NQ7RRtFFgJvtcP98/8AfJo+1w/3z/3yah2ijaKLATfa4f75/wC+TR9rh/vn/vk1DtFG0UWAm+1w/wB8/wDfJo+1w/3z/wB8modoo2iiwE32uH++f++TR9rh/vn/AL5NQ7RRtFFgJvtcP98/98mj7XD/AHz/AN8modoo2iiwE32uH++f++TR9rh/vn/vk1DtFG0UWAm+1w/3z/3yaPtcP98/98modoo2iiwE32uH++f++TR9rh/vn/vk1DtFG0UWAm+1w/3z/wB8mj7XD/fP/fJqHaKNoosBN9rh/vn/AL5NH2uH++f++TUO0UbRRYCb7XD/AHz/AN8mj7XD/fP/AHyah2ijaKLATfa4f75/75NH2uH++f8Avk1DtFG0UWAm+1w/3z/3yaPtcP8AfP8A3yah2ijaKLATfa4f75/75NH2uH++f++TUO0UbRRYCb7XD/fP/fJo+1w/3z/3yah2ijaKLATfa4f75/75NH2uH++f++TUO0UbRRYCb7XD/fP/AHyaPtcP98/98modoo2iiwE32uH++f8Avk0fa4f75/75NQ7RRtFFgJvtcP8AfP8A3yaPtUP98/8AfJqHaKNoosBN9qh/vn/vk0faYf7x/wC+TUW0UoUUWAkNxH/Dkn6VEAep6nmnYFOxQB//2Q==\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install easyocr" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JXQqrsdR7UYM", + "outputId": "8b1e5b73-9e4d-4cb3-ce1f-2d7b507a9010" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting easyocr\n", + " Downloading easyocr-1.7.2-py3-none-any.whl.metadata (10 kB)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.12/dist-packages (from easyocr) (2.10.0+cu128)\n", + "Requirement already satisfied: torchvision>=0.5 in /usr/local/lib/python3.12/dist-packages (from easyocr) (0.25.0+cu128)\n", + "Requirement already satisfied: opencv-python-headless in /usr/local/lib/python3.12/dist-packages (from easyocr) (4.13.0.92)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.12/dist-packages (from easyocr) (1.16.3)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from easyocr) (2.0.2)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.12/dist-packages (from easyocr) (11.3.0)\n", + "Requirement already satisfied: scikit-image in /usr/local/lib/python3.12/dist-packages (from easyocr) (0.25.2)\n", + "Collecting python-bidi (from easyocr)\n", + " Downloading python_bidi-0.6.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (4.9 kB)\n", + "Requirement already satisfied: PyYAML in /usr/local/lib/python3.12/dist-packages (from easyocr) (6.0.3)\n", + "Requirement already satisfied: Shapely in /usr/local/lib/python3.12/dist-packages (from easyocr) (2.1.2)\n", + "Collecting pyclipper (from easyocr)\n", + " Downloading pyclipper-1.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (8.6 kB)\n", + "Collecting ninja (from easyocr)\n", + " Downloading ninja-1.13.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (5.1 kB)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.24.3)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (4.15.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (75.2.0)\n", + "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (1.14.0)\n", + "Requirement already satisfied: networkx>=2.5.1 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.6.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.1.6)\n", + "Requirement already satisfied: fsspec>=0.8.5 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (2025.3.0)\n", + "Requirement already satisfied: cuda-bindings==12.9.4 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.9.4)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.93)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.90)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.90)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (9.10.2.21)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.8.4.1 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.4.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.3.3.83 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (11.3.3.83)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.9.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (10.3.9.90)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.7.3.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (11.7.3.90)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.5.8.93 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.5.8.93)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (0.7.1)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.27.5 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (2.27.5)\n", + "Requirement already satisfied: nvidia-nvshmem-cu12==3.4.5 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.4.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.90)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.93)\n", + "Requirement already satisfied: nvidia-cufile-cu12==1.13.1.3 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (1.13.1.3)\n", + "Requirement already satisfied: triton==3.6.0 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.6.0)\n", + "Requirement already satisfied: cuda-pathfinder~=1.1 in /usr/local/lib/python3.12/dist-packages (from cuda-bindings==12.9.4->torch->easyocr) (1.3.5)\n", + "Requirement already satisfied: imageio!=2.35.0,>=2.33 in /usr/local/lib/python3.12/dist-packages (from scikit-image->easyocr) (2.37.2)\n", + "Requirement already satisfied: tifffile>=2022.8.12 in /usr/local/lib/python3.12/dist-packages (from scikit-image->easyocr) (2026.2.20)\n", + "Requirement already satisfied: packaging>=21 in /usr/local/lib/python3.12/dist-packages (from scikit-image->easyocr) (26.0)\n", + "Requirement already satisfied: lazy-loader>=0.4 in /usr/local/lib/python3.12/dist-packages (from scikit-image->easyocr) (0.4)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch->easyocr) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch->easyocr) (3.0.3)\n", + "Downloading easyocr-1.7.2-py3-none-any.whl (2.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.9/2.9 MB\u001b[0m \u001b[31m31.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading ninja-1.13.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (180 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m180.7/180.7 kB\u001b[0m \u001b[31m17.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pyclipper-1.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (978 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m978.2/978.2 kB\u001b[0m \u001b[31m60.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading python_bidi-0.6.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (300 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m300.6/300.6 kB\u001b[0m \u001b[31m19.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: python-bidi, pyclipper, ninja, easyocr\n", + "Successfully installed easyocr-1.7.2 ninja-1.13.0 pyclipper-1.4.0 python-bidi-0.6.7\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import cv2\n", + "import easyocr\n", + "import numpy as np\n", + "import pandas as pd\n", + "import re\n", + "\n", + "IMAGE_PATH = '/content/datasets/yolo_dataset/images/val/two_col_104136.png'\n", + "reader = easyocr.Reader(['en'], gpu=True)\n", + "img = cv2.imread(IMAGE_PATH)\n", + "\n", + "results = model.predict(source=IMAGE_PATH, conf=0.25)\n", + "boxes = results[0].boxes.xyxy.cpu().tolist()\n", + "boxes = sorted(boxes, key=lambda b: b[0])\n", + "\n", + "# --- MODULE A: ROBUST MEDIAN Y-AXIS SCALE ---\n", + "left_bar_x = int(boxes[0][0])\n", + "bottom_of_chart = max([int(b[3]) for b in boxes])\n", + "y_axis_crop = img[0:bottom_of_chart, 0:left_bar_x]\n", + "\n", + "print(\"Reading Y-Axis...\")\n", + "y_ocr_results = reader.readtext(y_axis_crop)\n", + "\n", + "y_numbers = []\n", + "for (bbox, text, prob) in y_ocr_results:\n", + " clean_text = re.sub(r'[^\\d.]', '', text)\n", + " if clean_text:\n", + " y_center = (bbox[0][1] + bbox[2][1]) / 2\n", + " y_numbers.append({'value': float(clean_text), 'y_pixel': y_center})\n", + "\n", + "pixels_per_unit = 0\n", + "\n", + "if len(y_numbers) >= 2:\n", + " y_numbers = sorted(y_numbers, key=lambda x: x['y_pixel'])\n", + " scales = []\n", + " for i in range(len(y_numbers)-1):\n", + " for j in range(i+1, len(y_numbers)):\n", + " val_diff = abs(y_numbers[i]['value'] - y_numbers[j]['value'])\n", + " pix_diff = abs(y_numbers[i]['y_pixel'] - y_numbers[j]['y_pixel'])\n", + " if val_diff > 0:\n", + " scales.append(pix_diff / val_diff)\n", + "\n", + " if scales:\n", + " pixels_per_unit = np.median(scales)\n", + " print(f\"Robust Scale Found: 1 unit = {pixels_per_unit:.2f} pixels.\")\n", + "\n", + "# --- MODULE B: LABELS, RAYCASTING & MATH ---\n", + "# --- MODULE: ABSOLUTE PREDICTION WITHOUT TOP-TEXT ---\n", + "print(\"Predicting Absolute Values via Y-Axis Scale...\")\n", + "final_data = []\n", + "\n", + "# pixels_per_unit was calculated in Module A from the Y-Axis labels\n", + "for box in boxes:\n", + " x1, y1, x2, y2 = map(int, box)\n", + " cx = (x1 + x2) // 2\n", + "\n", + " # 1. RAYCASTING: Find the real top of the bar visually\n", + " sample_y = int(y2 - 5)\n", + " bar_color = img[sample_y, cx].astype(int)\n", + " true_y1 = y1\n", + "\n", + " for y_search in range(sample_y, 0, -1):\n", + " color_diff = np.sum(np.abs(img[y_search, cx].astype(int) - bar_color))\n", + " if color_diff > 60: # Threshold for background color change\n", + " true_y1 = y_search\n", + " break\n", + "\n", + " # 2. CALCULATION: Units = (Bottom_Pixel - Top_Pixel) / Scale\n", + " full_pixel_height = y2 - true_y1\n", + "\n", + " if pixels_per_unit > 0:\n", + " predicted_absolute_value = full_pixel_height / pixels_per_unit\n", + " else:\n", + " predicted_absolute_value = 0 # Fallback if Y-axis scale failed\n", + "\n", + " # 3. CATEGORY OCR (X-Axis)\n", + " label_crop = img[y2:min(img.shape[0], y2+35), max(0, cx-25):min(img.shape[1], cx+25)]\n", + " label_results = reader.readtext(label_crop, detail=0, allowlist='0123456789')\n", + " category = label_results[0] if label_results else \"Unknown\"\n", + "\n", + " final_data.append({\n", + " \"Year\": category,\n", + " \"Predicted_Value\": round(predicted_absolute_value, 2),\n", + " \"Measured_Pixels\": full_pixel_height\n", + " })\n", + "\n", + "df = pd.DataFrame(final_data)\n", + "print(df.to_string(index=False))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CvSZfojl7YzQ", + "outputId": "264fcda0-f6db-4af8-cd0a-a4086abd2b30" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "image 1/1 /content/datasets/yolo_dataset/images/val/two_col_104136.png: 448x640 5 bars, 13.0ms\n", + "Speed: 2.0ms preprocess, 13.0ms inference, 1.7ms postprocess per image at shape (1, 3, 448, 640)\n", + "Reading Y-Axis...\n", + "Predicting Absolute Values via Y-Axis Scale...\n", + " Year Predicted_Value Measured_Pixels\n", + "Unknown 0 28\n", + "Unknown 0 202\n", + "Unknown 0 160\n", + "Unknown 0 28\n", + "Unknown 0 27\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!unzip -q /content/drive/MyDrive/Spectra/yolo_dataset_bar.zip -d /content/datasets/" + ], + "metadata": { + "id": "sddjBz6-Q93P" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import yaml\n", + "\n", + "# Path to the local Colab directory where you just unzipped the data\n", + "config = {\n", + " 'train': '/content/datasets/yolo_dataset_bar/images/train',\n", + " 'val': '/content/datasets/yolo_dataset_bar/images/val',\n", + " 'nc': 1,\n", + " 'names': ['bar']\n", + "}\n", + "\n", + "with open('/content/charts.yaml', 'w') as f:\n", + " yaml.dump(config, f)" + ], + "metadata": { + "id": "TJbKvptmRW9e" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import cv2\n", + "import os\n", + "from google.colab.patches import cv2_imshow\n", + "\n", + "# View a random training image to verify labels\n", + "img_list = os.listdir('/content/datasets/yolo_dataset_bar/images/train')\n", + "sample_img_path = f'/content/datasets/yolo_dataset_bar/images/train/{img_list[77]}'\n", + "img = cv2.imread(sample_img_path)\n", + "\n", + "print(f\"Verifying: {sample_img_path}\")\n", + "cv2_imshow(img)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 435 + }, + "id": "te7RvBL2Ra_R", + "outputId": "62746e7f-b9c9-4618-fb65-692aef05fc84" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Verifying: /content/datasets/yolo_dataset_bar/images/train/40148.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n", + "image/jpeg": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "import cv2\n", + "import os\n", + "import random\n", + "from google.colab.patches import cv2_imshow\n", + "\n", + "def verify_yolo_labels(img_dir, label_dir):\n", + " # Get list of images\n", + " images = [f for f in os.listdir(img_dir) if f.endswith(('.png', '.jpg', '.jpeg'))]\n", + " sample_img = random.choice(images)\n", + " sample_label = sample_img.rsplit('.', 1)[0] + '.txt'\n", + "\n", + " img_path = os.path.join(img_dir, sample_img)\n", + " label_path = os.path.join(label_dir, sample_label)\n", + "\n", + " if not os.path.exists(label_path):\n", + " print(f\"No label found for {sample_img}\")\n", + " return\n", + "\n", + " img = cv2.imread(img_path)\n", + " h, w, _ = img.shape\n", + "\n", + " with open(label_path, 'r') as f:\n", + " for line in f.readlines():\n", + " parts = line.split()\n", + " # YOLO format: class cx cy nw nh\n", + " cx, cy, nw, nh = map(float, parts[1:])\n", + "\n", + " # Convert normalized back to pixel coordinates\n", + " x1 = int((cx - nw/2) * w)\n", + " y1 = int((cy - nh/2) * h)\n", + " x2 = int((cx + nw/2) * w)\n", + " y2 = int((cy + nh/2) * h)\n", + "\n", + " # Draw the box (Green)\n", + " cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)\n", + "\n", + " print(f\"Verifying Labels for: {sample_img}\")\n", + " cv2_imshow(img)\n", + "\n", + "# RUN IT\n", + "verify_yolo_labels('/content/datasets/yolo_dataset_bar/images/train',\n", + " '/content/datasets/yolo_dataset_bar/labels/train')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 435 + }, + "id": "ByNj5NA1SouQ", + "outputId": "0385d884-5f2d-4b3a-eebf-3cbf2948b5f7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Verifying Labels for: 30430.png\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n", + "image/jpeg": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "import os\n", + "from google.colab import drive\n", + "\n", + "# 1. Mount Drive\n", + "drive.mount('/content/drive')\n", + "\n", + "# 2. Updated path for the new Clean Bar Project\n", + "# Saving to a subfolder called 'Clean_Bar_Run' so you don't overwrite old trials\n", + "drive_path = \"/content/drive/MyDrive/Spectra_YOLO_Project/Clean_Bar_Run\"\n", + "os.makedirs(drive_path, exist_ok=True)\n", + "\n", + "# 3. Create the Symlink\n", + "# Now, any weights saved by YOLO will physically exist on your Google Drive\n", + "!rm -rf /content/runs\n", + "!ln -s /content/drive/MyDrive/Spectra_YOLO_Project/Clean_Bar_Run /content/runs\n", + "\n", + "print(f\"✅ Savepoint active! Weights will be at: {drive_path}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OTGA7gVhUtlr", + "outputId": "3af658b7-7984-4c8d-ccaf-461f9fddd3ed" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n", + "✅ Savepoint active! Weights will be at: /content/drive/MyDrive/Spectra_YOLO_Project/Clean_Bar_Run\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from ultralytics import YOLO\n", + "\n", + "# Check if GPU is actually connected\n", + "if not torch.cuda.is_available():\n", + " print(\"❌ ERROR: GPU not found! Go to Runtime > Change runtime type > T4 GPU\")\n", + "else:\n", + " print(f\"✅ GPU Found: {torch.cuda.get_device_name(0)}\")\n", + "\n", + " # Load fresh model\n", + " model = YOLO(\"yolo11n.pt\")\n", + "\n", + " # Start Training with Hyperparameter Safety Nets\n", + " model.train(\n", + " data=\"/content/charts.yaml\",\n", + " epochs=30,\n", + " imgsz=640,\n", + " batch=32,\n", + " device=0,\n", + " overlap_mask=False,\n", + "\n", + " # --- THE STABILITY FIXES ---\n", + " optimizer='AdamW', # A much more stable optimizer than the default\n", + " lr0=0.001, # Lower maximum learning rate (prevents the explosion)\n", + " warmup_epochs=2, # Shorten the warmup period\n", + " )" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nez8K2fIRbzm", + "outputId": "e6b076e3-bab9-4ea6-8aea-9778f9ad8512" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "✅ GPU Found: Tesla T4\n", + "Ultralytics 8.4.19 🚀 Python-3.12.12 torch-2.10.0+cu128 CUDA:0 (Tesla T4, 14913MiB)\n", + "\u001b[34m\u001b[1mengine/trainer: \u001b[0magnostic_nms=False, amp=True, angle=1.0, augment=False, auto_augment=randaugment, batch=32, bgr=0.0, box=7.5, cache=False, cfg=None, classes=None, close_mosaic=10, cls=0.5, compile=False, conf=None, copy_paste=0.0, copy_paste_mode=flip, cos_lr=False, cutmix=0.0, data=/content/charts.yaml, degrees=0.0, deterministic=True, device=0, dfl=1.5, dnn=False, dropout=0.0, dynamic=False, embed=None, end2end=None, epochs=30, erasing=0.4, exist_ok=False, fliplr=0.5, flipud=0.0, format=torchscript, fraction=1.0, freeze=None, half=False, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, imgsz=640, int8=False, iou=0.7, keras=False, kobj=1.0, line_width=None, lr0=0.001, lrf=0.01, mask_ratio=4, max_det=300, mixup=0.0, mode=train, model=yolo11n.pt, momentum=0.937, mosaic=1.0, multi_scale=0.0, name=train2, nbs=64, nms=False, opset=None, optimize=False, optimizer=AdamW, overlap_mask=False, patience=100, perspective=0.0, plots=True, pose=12.0, pretrained=True, profile=False, project=None, rect=False, resume=False, retina_masks=False, rle=1.0, save=True, save_conf=False, save_crop=False, save_dir=/content/drive/MyDrive/Spectra_YOLO_Project/Clean_Bar_Run/detect/train2, save_frames=False, save_json=False, save_period=-1, save_txt=False, scale=0.5, seed=0, shear=0.0, show=False, show_boxes=True, show_conf=True, show_labels=True, simplify=True, single_cls=False, source=None, split=val, stream_buffer=False, task=detect, time=None, tracker=botsort.yaml, translate=0.1, val=True, verbose=True, vid_stride=1, visualize=False, warmup_bias_lr=0.1, warmup_epochs=2, warmup_momentum=0.8, weight_decay=0.0005, workers=8, workspace=None\n", + "Overriding model.yaml nc=80 with nc=1\n", + "\n", + " from n params module arguments \n", + " 0 -1 1 464 ultralytics.nn.modules.conv.Conv [3, 16, 3, 2] \n", + " 1 -1 1 4672 ultralytics.nn.modules.conv.Conv [16, 32, 3, 2] \n", + " 2 -1 1 6640 ultralytics.nn.modules.block.C3k2 [32, 64, 1, False, 0.25] \n", + " 3 -1 1 36992 ultralytics.nn.modules.conv.Conv [64, 64, 3, 2] \n", + " 4 -1 1 26080 ultralytics.nn.modules.block.C3k2 [64, 128, 1, False, 0.25] \n", + " 5 -1 1 147712 ultralytics.nn.modules.conv.Conv [128, 128, 3, 2] \n", + " 6 -1 1 87040 ultralytics.nn.modules.block.C3k2 [128, 128, 1, True] \n", + " 7 -1 1 295424 ultralytics.nn.modules.conv.Conv [128, 256, 3, 2] \n", + " 8 -1 1 346112 ultralytics.nn.modules.block.C3k2 [256, 256, 1, True] \n", + " 9 -1 1 164608 ultralytics.nn.modules.block.SPPF [256, 256, 5] \n", + " 10 -1 1 249728 ultralytics.nn.modules.block.C2PSA [256, 256, 1] \n", + " 11 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] \n", + " 12 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1] \n", + " 13 -1 1 111296 ultralytics.nn.modules.block.C3k2 [384, 128, 1, False] \n", + " 14 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest'] \n", + " 15 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1] \n", + " 16 -1 1 32096 ultralytics.nn.modules.block.C3k2 [256, 64, 1, False] \n", + " 17 -1 1 36992 ultralytics.nn.modules.conv.Conv [64, 64, 3, 2] \n", + " 18 [-1, 13] 1 0 ultralytics.nn.modules.conv.Concat [1] \n", + " 19 -1 1 86720 ultralytics.nn.modules.block.C3k2 [192, 128, 1, False] \n", + " 20 -1 1 147712 ultralytics.nn.modules.conv.Conv [128, 128, 3, 2] \n", + " 21 [-1, 10] 1 0 ultralytics.nn.modules.conv.Concat [1] \n", + " 22 -1 1 378880 ultralytics.nn.modules.block.C3k2 [384, 256, 1, True] \n", + " 23 [16, 19, 22] 1 430867 ultralytics.nn.modules.head.Detect [1, 16, None, [64, 128, 256]] \n", + "YOLO11n summary: 182 layers, 2,590,035 parameters, 2,590,019 gradients, 6.4 GFLOPs\n", + "\n", + "Transferred 448/499 items from pretrained weights\n", + "Freezing layer 'model.23.dfl.conv.weight'\n", + "\u001b[34m\u001b[1mAMP: \u001b[0mrunning Automatic Mixed Precision (AMP) checks...\n", + "\u001b[34m\u001b[1mAMP: \u001b[0mchecks passed ✅\n", + "\u001b[34m\u001b[1mtrain: \u001b[0mFast image access ✅ (ping: 0.0±0.0 ms, read: 517.2±166.4 MB/s, size: 13.9 KB)\n", + "\u001b[K\u001b[34m\u001b[1mtrain: \u001b[0mScanning /content/datasets/yolo_dataset_bar/labels/train.cache... 40000 images, 0 backgrounds, 0 corrupt: 100% ━━━━━━━━━━━━ 40000/40000 10.5Git/s 0.0s\n", + "\u001b[34m\u001b[1malbumentations: \u001b[0mBlur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, method='weighted_average', num_output_channels=3), CLAHE(p=0.01, clip_limit=(1.0, 4.0), tile_grid_size=(8, 8))\n", + "\u001b[34m\u001b[1mval: \u001b[0mFast image access ✅ (ping: 0.0±0.0 ms, read: 454.1±310.4 MB/s, size: 19.9 KB)\n", + "\u001b[K\u001b[34m\u001b[1mval: \u001b[0mScanning /content/datasets/yolo_dataset_bar/labels/val.cache... 11008 images, 0 backgrounds, 1215 corrupt: 100% ━━━━━━━━━━━━ 11008/11008 363.6Mit/s 0.0s\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/14984.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.065552 -0.24322]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/14986.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.12]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/14987.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0297]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/14989.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0351]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/14992.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0228 1.0774 1.0695 1.0934]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/14993.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0609 1.0699 1.186 1.0879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15000.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0706]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15001.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0689 1.0918 1.1486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15012.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0873 1.1182 1.1337 1.137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15016.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 13.645 27.189 3.3201 6.5394 1.8867 3.6726 3.4139 6.7271]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15017.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15021.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15025.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1014]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15037.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10735 -0.3183 -0.27485 -0.6533 -0.091061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15038.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15039.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1571 1.0251 1.0478 1.136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15048.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0669 1.1388 1.0793 1.0434]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15049.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.1786 -4.6215 -1.1264 -2.5172 -5.9167 -12.098 -6.0427 -12.35 -1.3391 -2.9425]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15050.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8109 3.507 1.0167 1.9184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15051.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1963]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15052.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15054.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0356]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15056.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0613 1.9949 1.3337 1.2709 1.0741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15061.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1283 1.2933 1.3302]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15063.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0125 1.5983 1.4529]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15073.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0675 1.0675 1.0675]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15075.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15076.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0201 1.4368]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15078.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1313]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15084.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0707 1.0543 1.0223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15086.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1305 1.1635 1.2047 1.239 1.2747 1.3104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15088.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0372 1.046 1.0361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15089.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15094.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0416 1.0478]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.176]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15105.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.152]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15109.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1584 1.1011 1.0461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15112.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1519 1.2902 1.1867 1.1755 1.1496 1.0292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15115.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1252 1.1239 1.1239 1.1227 1.1227]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15117.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1551 1.4164 1.0796 1.0281]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15122.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0703 1.0814]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15126.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2301 1.2301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15127.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0756 1.0342 1.0218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15129.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1038 1.1483 1.2172 1.1515]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1445 1.1635 1.1265 1.0437]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15134.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0807 1.0705 1.1841 1.325 1.1852 1.292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15135.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0745]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15136.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0315]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15139.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0137]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15140.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.08898 -0.27918]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15141.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0242 1.0526 1.08 1.1095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15143.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.046778 -0.22245 -0.11642]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15151.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0988]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15153.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.7122 -6.1143 -0.67247 -5.821 -12.332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.226 1.6753 1.2504]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15162.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15164.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.3949 -3.0054 -24.712 -49.639 -6.875 -13.966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15166.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0359 1.0666 1.0772]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15172.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0201]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15173.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15175.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1679 1.1767 1.157 1.1603]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15177.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4813]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15181.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.084007 -0.27942]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15183.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.020219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15187.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1227]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15193.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.7538 -1.6255]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15197.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0312 1.0451]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15203.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0968]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15206.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0733]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15207.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.0611 -4.2233 -0.38712 -0.87531 -1.4654 -3.0318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15208.png: ignoring corrupt image/label: negative class labels or coordinate [-8.8483e+06 -1.7697e+07 -47.269 -94.853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15210.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15215.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0895]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15216.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0716]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15223.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.01035]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7642 2.4984 4.8137 4.9448 9.7065]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15236.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.078 1.0223 1.029 1.0424]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15242.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0317 1.0559]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15243.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2716]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15246.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0734]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15250.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3028]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15253.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0762 1.0722 1.0722 1.0722 1.0762 1.0722]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15260.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0717]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15262.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0596]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15264.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1793 1.1739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15269.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15271.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0902 1.1216 1.1353 1.0559 1.0382 1.1059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15275.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0149]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15279.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.039036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15283.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0972 1.2625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15285.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2255]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15287.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2138 1.0976]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2946 1.3527 1.3598 1.1756 1.1785 1.2096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15293.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0146 1.0146 1.0146 1.0146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15297.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0572 1.0514 1.0368 1.0194 1.0116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15301.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1715 1.3417]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15304.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2258]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.027 1.2892]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15310.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1395]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15313.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4235 1.4248 1.4248 1.1817]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15315.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.078313 -0.27155 -0.11909 -0.35311 -0.10612 -0.32715 -0.081094 -0.27711]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15318.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15323.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1464]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15328.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138 1.0502]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15337.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1571 1.1482 1.1561 1.1561 1.1571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15343.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1593]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15352.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1204 1.2062 1.1761]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15354.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0227 1.1196 1.2267 1.3438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0369]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15364.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2841 1.1534 1.2466 1.2477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15365.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0591 1.0519 1.0436 1.0363 1.028 1.0207]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15370.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0131 1.0219]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15373.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1932 11.338 22.536 18.707 37.273 12.991 25.842 18.089 36.038 19.329 38.519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15376.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2288 1.2232 1.1907 1.2274]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.101]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15384.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.081]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15390.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2325 1.2325 1.2325 1.2325 1.2325 1.1792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15391.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.042208 -0.19944 -0.021336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15399.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.3474 -2.8098 -0.75093 -1.6169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15400.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1935 1.2573 1.2438 1.2774]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15404.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2419 1.2174 1.1839 1.1472 1.1148 1.0736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1578]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15407.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15410.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1334 1.1376 1.1334 1.0893 1.0767 1.0798]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0392]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15412.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1853]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203 1.0947]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15421.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.1002 -4.3093 -1.1252 -2.3594 -0.18322 -0.47539]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15423.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.146 1.146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15425.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0533 1.0533 1.0533 1.0533]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15430.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15432.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1687]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15434.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.014 1.0168 1.0187 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15436.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0805]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15440.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15441.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2624]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1075]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15448.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0153 1.0728 1.0613]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0352]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15462.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0842 1.0414 1.0709 1.1285]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15466.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2315 1.2336 1.0581]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15470.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12831 -0.38289 -0.093686 -0.013238 -0.15275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15481.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15499.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2038 1.2038 1.3174 1.2421 1.2791 1.2038]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15511.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15513.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1002]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15517.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 149.11 297.6 38.271 75.931 244.5 488.38 1.2396]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15519.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.8927 9.6667 2.4555 4.7921 1.5891 3.0594 3.3372 6.5556 1.6691 3.2193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15520.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1126 1.1572]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15525.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15531.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1792 1.634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0983]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15535.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1285]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15538.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15553.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15556.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2346]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1788]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15572.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15574.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15578.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292 1.0282 1.0379]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15581.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15585.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15614.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0184]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15615.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0376 1.0859 1.0387 1.015]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0241 1.0809]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15621.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4462 1.4717 1.4334 1.2224]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15622.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0195]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15624.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1287 1.1611 1.1611]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15625.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.085 1.0307]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15629.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0929 1.0826 1.1732 1.1365 1.1273 1.1594]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15635.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15636.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2855 2.4686 2.1698 4.2372 1.1525 2.2025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15641.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.2798]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15644.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.147 1.125 1.076 1.096 1.124]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15649.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1558]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15654.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.272 1.2734 1.283 1.2706 1.2692 1.2761]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15656.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15657.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214 1.108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15659.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0249 1.0411]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15660.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4479 1.4521 1.4438 1.4411]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15663.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15666.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0661]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15667.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1389 1.0179 1.0158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15676.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.050915 -0.035402 -0.27128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15685.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1289 1.0767 1.1133 1.1411]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15689.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3644 1.3671 1.3671 1.3685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15698.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2382]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15706.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1183]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15708.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1767 1.1652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15710.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1005]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15711.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2988 1.0168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15716.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2102]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15717.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0399 1.1197 1.0875]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15720.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0206 1.0172 1.0378 1.0458]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15721.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3677 1.1615 1.1569 1.1477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15723.png: ignoring corrupt image/label: negative class labels or coordinate [ -2.2484 -4.5949 -0.43987 -0.97785 -0.045095 -0.18829 -0.013449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15724.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0124]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15728.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0381 1.0901 1.1443 1.2009 1.2806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15729.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15730.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0675 1.0675 1.0675]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15733.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0312 1.1158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15735.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0115 1.0115 1.0115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15736.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15739.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0265 1.9289 1.2673 1.3534]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15746.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0465 1.3297]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0763]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15772.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.077189 -0.29724 -0.13825]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15775.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.028203 -0.15633 -0.028203 -0.15633]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15777.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15778.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15785.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2329 1.1096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15788.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0274 1.2577 1.2029 1.2434]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15792.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0126 1.0485]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15793.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203 1.0203 1.0284]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15796.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 7.0278 13.918 9.5774 19.017 3.5434 6.9488]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15801.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.098832 -0.30907 -0.1177 -0.34681 -0.061995]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15804.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3689]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15818.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1004]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15822.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0471]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15826.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15827.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.0627 -2.2257 -0.2593 -0.61893 -0.10437 -0.47209 -1.0445]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0565]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15834.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1001]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15837.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1584 1.3067 1.2438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15841.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3276 1.3276 1.3276 1.3276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15844.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0404]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15849.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1442]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15853.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15854.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4715]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15859.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15865.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0101]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15866.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0979]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15872.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.027]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15873.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0164]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15879.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1691]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15883.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0173]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15889.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0748]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.038 1.2334 1.4274]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15892.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3739 1.2599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15894.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0572]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15897.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15912.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0669 1.0405 1.0618]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15914.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0121 1.0121 1.0173]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15924.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2546 1.2282 1.1147 1.0206]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15936.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1578 1.0955 1.0995 1.0935]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15937.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1353 1.2069 1.3191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15939.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0172]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15941.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.1759 -0.10982 -0.41011]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15946.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15949.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0679 1.0316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15951.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0439]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15952.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15955.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15960.png: ignoring corrupt image/label: negative class labels or coordinate [ -4.6845 -9.5459]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15961.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0529]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15968.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15974.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0362]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15975.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15976.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2262 1.2262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15980.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0239 1.0149]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15988.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0636]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15989.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.173]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15990.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11277 -0.0625 -0.29348 -0.074049 -0.31658]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15991.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1472]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15997.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1954 1.2762]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/15998.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1254]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0955 1.0325]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16008.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16010.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16022.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1237]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16024.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0845 1.0729 1.0625 1.0544 1.0451 1.0359]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16025.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0424]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16029.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.018098 -0.14057 -0.066498]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16037.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16041.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0854 1.0374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16046.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0525 1.0525]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16052.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.015 1.014 1.015 1.0401 1.0531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16055.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3021 1.3021 1.3043 1.3043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16064.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1158 1.1113 1.1038 1.1143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16069.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0235]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16076.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0458]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16083.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0693 1.2056 1.0584 1.1484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16085.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.023007]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16087.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1684 1.0263 1.0848 1.0664 1.1615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16098.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.14815 -0.39401 -0.032703 -0.16312 -0.24153 -0.58077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1639 1.2163 1.2129 1.2129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16104.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.041791 -0.31343 -0.96318]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16106.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0394 1.0178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16107.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2859 1.1378 1.6606 1.111 2.0809]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16115.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0432]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16119.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0467]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16122.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0633]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16126.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0238 1.1037]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16128.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0683]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1187 1.1465 1.1744 1.1806]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16144.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1029]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16149.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5339]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16152.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0682 1.116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16157.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4551 1.3034 1.0506 1.0885 1.1854]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1491 1.1435 1.1222 1.1413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16160.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.61624 -1.3347 -0.2296 -0.56142]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16162.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2577]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16166.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2335 1.2255 1.2403 1.2403 1.2403]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16169.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0344]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16173.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8709 1.8742 1.0456 1.9566 1.1106 2.0868 1.2343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16176.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1445 1.0996 1.1178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16179.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1171 1.1171 1.1171 1.1751]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16183.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12004 -0.010397 -0.138 -0.020321 -0.15785 -0.034026 -0.18526]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0158]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16186.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16187.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0264]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16189.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0785]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16190.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0401 1.0401 1.0401 1.0401 1.0401 1.0401]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16191.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0803 1.0823 1.0842 1.0852 1.0862]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16192.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.111]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16200.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16204.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.3147 -2.8977 -0.059099 -0.38649 -0.016886]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16212.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.153]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16215.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1102 1.2107]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16220.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0809 1.3685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0183]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16227.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1783]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16228.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3062 1.1431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16229.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0428]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0635 1.0894]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16234.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0372]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16236.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.98182 -2.2727 -9.4008 -19.111]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16239.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16245.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0994 1.1451]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16247.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0576 1.0536 1.0536 1.0335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16250.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1217]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16256.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.017045 -0.29773]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16260.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2332 1.2332 1.2332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16263.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.18215 -0.30523 -0.9477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16285.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1247]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16294.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.071732 -0.24873 -0.075976 -0.25722]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16298.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0229 1.0229 1.0431 1.0532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16299.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0447]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16300.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2705 1.2761 1.2773 1.2739 1.2807 1.275]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16306.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1073 1.0739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.031]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16310.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16312.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2624]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16313.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0899 1.0979 1.0609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16315.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1273]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16318.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1658]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16324.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16326.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.403 1.3904 1.3413 1.335 1.2859 1.2355]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16330.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.084365 -0.12345 -0.34288 -0.27477 -0.64551 -0.25426 -0.60449]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16331.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.69591 -1.4954]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3053 1.3133 1.3201 1.3269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16340.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027933 -0.40596 -1.1117 -0.11173 -0.52328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16341.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1973 1.201 1.1005 1.1042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0275 1.0674]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16343.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1987 1.0795]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16358.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1075]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3299]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16369.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2371]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16371.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1565]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16373.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0845 1.1059 1.1008 1.0743 1.0815]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16375.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2384]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.145 1.0444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16382.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1436 1.1436 1.1436 1.1436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16384.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0926 1.0522]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16393.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.32514 -0.83554 -0.43762 -1.0605 -1.405 -2.9953]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16397.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0101 1.2011]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16405.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1985 1.1985 1.1985 1.1985]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0135 1.0683 1.0797 1.0383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16409.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0639 1.0897 1.1671]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16410.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1985]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16418.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16421.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2575]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16422.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.103 1.3251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16433.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1251 1.1719]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16440.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1332 1.1269 1.1121 1.0497 1.0592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16445.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2 1.2 1.2616]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16456.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0574 1.0574]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16462.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0741 1.1111 1.1493 1.1887 1.2292 1.272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16464.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0143 1.0133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1297]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1227 1.0966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16470.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4154 1.3119 1.3472 1.3699 1.3245 1.2816]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16472.png: ignoring corrupt image/label: negative class labels or coordinate [-8.9137e+05 -1.7827e+06 -47.469 -95.284 -1.3868e+05 -2.7736e+05]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16477.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16481.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2534 1.2534 1.2534 1.2534 1.2534]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16482.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0686 1.1851]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16487.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1147]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0122 1.0591 1.1161 1.1792 1.1599 1.1945]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0568]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16510.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0544 1.0729 1.0229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16517.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1494]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16518.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0559 1.1315]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16523.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0282 1.0135 1.1172 1.168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16524.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0474]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16527.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1169 1.0569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16529.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.32046 -0.73965]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16532.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.111 1.1258 1.0663 1.1258 1.0663]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16555.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0469 1.0184 1.0827 1.1112 1.0327]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2638 1.2638 1.0951]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3545 1.3215 1.2897 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16568.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0268]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16569.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0357]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16571.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16579.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0495 1.0527 1.2002]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16580.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0892]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16584.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0414]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16586.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0112 1.0322 1.1063 1.1147]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16590.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1131 1.039 1.1141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16593.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1298]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16615.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1527]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0323]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16624.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2905]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16628.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0627]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16630.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2785 1.3061 1.328 1.3452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16636.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.11487 -0.016028 -0.28317]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16638.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0912 1.0764]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16645.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1055 1.4694]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16652.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0388]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.103 1.0601]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16659.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0377 1.0205]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16660.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4786 1.4461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16665.png: ignoring corrupt image/label: negative class labels or coordinate [ -1.1674 -2.5069 -1.4028 -2.9778 -1.7375 -3.6472 -1.0125 -2.1972]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16671.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16674.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16681.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1019 1.1325 1.1461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16683.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1558]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16686.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0196]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16689.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.02 1.1551 1.2099]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16690.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0252 1.0602 1.1915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16697.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509 1.1824 1.1811 1.1687 1.1849]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16704.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3585]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16707.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2691 1.2668 1.2566 1.2634 1.2543]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16710.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1005]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16717.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2923 1.1954 1.1185 1.3785 1.3692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16720.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3733 1.4097]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16721.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1063 1.0825 1.0406]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16723.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1119]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16730.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1721 1.1721 1.1721 1.0259 1.0259]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16731.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16733.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.89396 -1.8864 -0.7641 -1.6267 -1.5326 -3.1636 -1.7065 -3.5115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16735.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0159 1.0677 1.092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16736.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16738.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0457]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16739.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0241]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16740.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.23996 -0.047992 -2.6479 -5.6288 -4.4319 -9.1969 -0.012733 -0.35847]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16743.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16753.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1101 1.1101 1.1143 1.1175 1.1185 1.1217]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16754.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0968]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16771.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1548 1.1562 1.1712 1.1397 1.1562 1.063]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16775.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0631 1.0145]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16779.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0842 1.1232]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16796.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.8031 1.311 1.4807 1.8046 1.0549 1.933 1.0314 1.8859]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16797.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1263]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16799.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16807.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.14477 -0.3871 -0.62156 -1.3407 -0.16011 -0.41778]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16817.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16832.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.101 1.0893]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16834.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0452 1.0452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16836.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0337]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16844.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2306]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1319]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16851.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0251]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16852.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4631 1.3569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16853.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0657]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/16860.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.135]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31742.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 5.0286 92.707 22.199 13.875]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31743.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1878]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31745.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3736]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31748.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2824]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31749.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0115 1.4095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31750.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0613 1.282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31753.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0571]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31755.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2762]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31762.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0828]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31764.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1696]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31766.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31772.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31774.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157 1.4049 1.7942]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31776.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1047]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31777.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2767]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31778.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1104]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0741]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31782.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31785.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31791.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31794.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0996]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31798.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31800.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31802.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.31]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31803.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0576]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31804.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.5969 1.0846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31806.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1178]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2313 1.7254]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31810.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.044615 -0.12769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31812.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31814.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.06]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31815.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0388]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31817.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1679]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31818.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1876]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31824.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0866]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31825.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2888]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31827.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3203 25.125 1.6735]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0281]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31830.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0889]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31832.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0581]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31833.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0933]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31835.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31836.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1999]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31837.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0144 1.3032]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31839.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.7657e+07 1.4868e+09 3.4396e+08 2.0072e+05]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31840.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2781]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31844.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0323 1.328]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1759]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31846.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31848.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0839]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31852.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31854.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31863.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0658]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31867.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1123]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31868.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0447]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31870.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2425]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31871.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31872.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.038 1.3354]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31880.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31882.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3369 1.7092 2.2031]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31883.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0474]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31884.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2212]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31885.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31887.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.051]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31890.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0138]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31893.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3656]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31895.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2154 1.0105 1.2187]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31897.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0724]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31899.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31901.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1331]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31903.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31904.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31905.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.095]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31906.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0144]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31909.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1377]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31913.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0787 1.3716]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31917.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.88 1.4623]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31918.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0264 1.2532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31919.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 14.569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31921.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1631]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31922.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31925.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0459 1.272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31929.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0854]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31931.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0373]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31934.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1538 1.1992]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31936.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31937.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0725]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31939.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.19846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31940.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0689 1.2945]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31943.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31945.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31946.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.5969 4.9 9.5415 3.8185 4.7646]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31947.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1813]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31955.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0313]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31956.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31960.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0909]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31962.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0341]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31966.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0381]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31967.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0482]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31968.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1407]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31969.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.17077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31974.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3067]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31975.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1332]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31977.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0712 1.3016]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31978.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503 1.3483]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31981.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1574]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31982.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31983.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0269]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31984.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1349]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31985.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4131]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31988.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2794]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31992.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1997]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31995.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0348]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31998.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/31999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7931 1.0311 1.326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32003.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0737 1.3566 1.638]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1379 1.3733]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32006.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1151]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32007.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2376]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32008.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0398 1.2548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32009.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0101 1.2307]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32011.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32014.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1775]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32015.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32016.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32017.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0444]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32020.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32024.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 9.3792 5.5808]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32026.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2619]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32031.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1138 4.7292 1.0698]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32032.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3444 1.7038]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32033.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32034.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0274 1.316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32035.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0156]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32038.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0729]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32040.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2161]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32043.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1432]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32045.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2629]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32047.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32048.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1604]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32049.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.06]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32051.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2669]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32052.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1308 1.153 1.3838]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32055.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0261]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32057.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32059.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.081]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32063.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.2023 117.22]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32070.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32074.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0164]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32079.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0726]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32081.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32085.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1182]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32087.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32088.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.2421]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32092.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0545]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32094.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32099.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2423]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32101.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0772]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32102.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32103.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2887]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32111.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32114.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1579]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32128.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32131.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1791]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2218]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32133.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1592]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32134.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2087]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32137.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0871]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32138.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0363]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32140.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3124]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32141.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.015 1.3044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32147.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1287]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32148.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0814 1.3168]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32150.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3773]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32151.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1364]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32152.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2511]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32153.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0986]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0248]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32162.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32165.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0725 1.2978]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32166.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0953]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32167.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.26308 -0.030769]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32174.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32177.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1469]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1087]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32185.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2148]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32186.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0383]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3288]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32191.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2522 1.6091]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32193.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0998 1.3397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32194.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32196.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.017]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32204.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0865]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32206.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1391]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32210.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32212.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32213.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3429]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32222.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0238]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32223.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1243]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32224.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1377]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32231.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.204]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1151]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32237.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0613 1.2923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32238.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1745]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32239.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2884]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32241.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1931]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32244.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1229]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32245.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0214]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32249.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0725]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32255.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2508]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32259.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2706]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32260.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1008]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32266.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32270.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0162 1.24]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32273.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1099]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32276.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0325]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32279.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0349]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32281.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32282.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2602]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32284.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2257 1.5788]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32285.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.056]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32290.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1813]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2669]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32294.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.03]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32300.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.029]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32305.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2388]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2423]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1358]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32310.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2464]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32311.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3425 1.7303]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32315.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3572 1.7438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32318.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2725]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32321.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3293]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32325.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1804]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32326.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1833]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32327.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0739]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32328.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3026]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32330.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.059 1.2894]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32332.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2046 1.1506 2.6923]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32341.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2976]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32344.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0128]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32346.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0795]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.109]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32353.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0336]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32354.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0392]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32357.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0967 1.3245]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32359.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 8.9062 14.871 11.868 1.8492 2.0108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32360.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2304]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32365.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2044]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32372.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3242]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32373.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1789 1.4326]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32377.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1373]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32378.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1355]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32380.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.064 1.2956]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32381.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.302]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32383.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2656]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32385.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1204]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32386.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3283]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32389.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1993]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32391.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32392.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0943]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32396.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32406.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32407.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0599]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0863]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32413.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1732]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32414.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1515 1.86 1.1096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32417.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0956 1.3265]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32418.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.198]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32421.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1915]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32422.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32426.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.1277 2.6446]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32427.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.094]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32432.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32438.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1692 1.4225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32442.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 17848 24.725 40580]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32443.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0598]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0146]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32447.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1641]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32452.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0807]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32453.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0999 1.5673]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32454.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4285 1.0562]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32456.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1647]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32457.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0768 1.5288]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2046]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32468.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32470.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1718]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32472.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1988]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32474.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0356]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32477.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0205]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32478.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.263]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32482.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0825]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32483.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4285 1.8808 2.37]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32484.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.244]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32486.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0987]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32502.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.08]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32503.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0302]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2877]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32506.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32508.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0188]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32511.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2489]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32512.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0502]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32514.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5585 1.0385 1.2246 1.62]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32521.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32523.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0133 1.2343]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32524.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4254 1.2469 1.0149 1.2943]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32528.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0103]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32529.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0128 1.3019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32532.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1311]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32534.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0363]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32535.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0784]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32537.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1047]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2169]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32540.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0589]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32541.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.26461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32542.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32545.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1667]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32550.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.431]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32551.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0157]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32552.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0165]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32559.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0652]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32560.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32564.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.8508 2.4431 2.5169 4.3292 1.7077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32566.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0703]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32575.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2922]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32576.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0855 1.3858 1.6861]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32577.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3989]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32579.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32580.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3199]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32582.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0745]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32588.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1435]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32593.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2539]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32595.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0888]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32597.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0262 1.252]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32598.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2838 4.63 2.35]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32600.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0475]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32603.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0832 1.3175]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32607.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32610.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1799]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32611.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32612.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32614.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2626]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32619.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.094]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32623.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32624.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0265 1.3206]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32627.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.255 1.5949]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32628.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32630.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0952]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32633.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2615 1.4262 1.0408 1.6154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32634.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.06 1.2857]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32642.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.091 1.3237]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32643.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0292]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32646.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0854]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32648.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1809]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32649.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0842]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32650.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0568]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32651.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2132]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32653.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1797]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32654.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2816]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32656.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32658.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0293 1.2397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32660.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32663.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0904]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32664.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2329]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32668.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0779]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32671.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0264]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32678.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32680.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0319]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32681.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1127]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32683.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32688.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32689.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0433]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32691.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0608 1.2788]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32692.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2334 1.5657]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32693.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32696.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32700.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3012]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32701.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2685 2.1262 1.1319 1.8792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32702.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32707.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0534]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32708.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0647 1.2964]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32709.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1056]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32710.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32713.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0246 3.3338 2.8292 2.82 1.1226 3.7092]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32714.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1061]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32717.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.019]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32722.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.057]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32727.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1725]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32730.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32732.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0672]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32733.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0645 1.3698]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32734.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1643 1.4817]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32741.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1552]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32750.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.027692 -0.024615]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32756.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1567]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32758.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32763.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0283]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32764.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1565]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32768.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0574]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32774.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1354 1.118]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32780.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1102]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32783.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32786.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1633]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32789.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2289]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32791.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0481]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32792.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 14.426 5.6569 5.8108 4.1831]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32794.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2931]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32795.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2623]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32797.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1714]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32800.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0285 1.2531]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32801.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1699 1.6678]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32802.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3121]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32806.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1946]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32807.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0409]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32808.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1478]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32809.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0401 1.2555]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32811.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0198]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32812.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.9501e+05 1083.2 4424.8 1.1423]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32815.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2183]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32817.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0731]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32821.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3616]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32823.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1916]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32827.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503 1.3523]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32828.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0393]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32829.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1294]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32831.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1937]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32832.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1025]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32833.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6459]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32834.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1869]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32838.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1126 1.4267]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32845.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0716]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32848.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1239]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32851.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0619]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32855.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2497]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32858.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0118 1.2291]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32859.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32862.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0301]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32865.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3213]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32867.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32868.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0266 1.2481]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32869.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.152]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32871.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1641]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32880.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2126]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32881.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1768]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32884.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2041]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32885.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32886.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2105 1.6862]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32887.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0397]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32890.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0135 1.2365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32891.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32895.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0762]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32896.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 17.928 23.891 5.0692]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32897.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0396]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32903.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0744]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32904.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 4.9123 2.9062 1.2586]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32906.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32908.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2232]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32909.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.5123 3.0646 2.6369 3.5354 2.5492]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32910.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1375]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32911.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2205]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32924.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.21]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32927.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1394]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32928.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0135]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32929.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0535]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32932.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.3554 1.1033 2.7992]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32935.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32937.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.013 1.2321]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32938.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32939.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.27385]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32940.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2209]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32941.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.075]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32944.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0878]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32946.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0632]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32948.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.201]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32951.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32954.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2174 1.6966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32955.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2202]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32957.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32958.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0288 1.3045]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32960.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2819]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32962.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1406]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32966.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32968.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.10154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32972.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1546]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32973.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 3.1092 1.0419]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32975.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0282 1.2481]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32977.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32978.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32982.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3438]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32987.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0425 1.3427]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32988.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2868 1.5646]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32989.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2646]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32993.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.016]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/32999.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0774]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33005.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1233]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33007.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1197]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33013.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0203]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33015.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1399]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33019.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0117]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33021.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1591]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33025.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2316]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33026.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33030.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0734]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33036.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.017]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33037.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0713 1.3042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33040.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1913]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33042.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33043.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1384]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33044.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1552]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33045.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2785 1.5563]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33049.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0174]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33051.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.322]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33054.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1532]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33057.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1919]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33062.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1501]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33064.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0267]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33068.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 6.2474e+13 1.3194e+15 1.1858e+08 2.3716e+08]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33070.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1743]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33071.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1727 1.5116]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33072.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2792]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33073.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1063]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33075.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.6038 1.0169 1.0392 1.1417 1.1685]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33077.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1701]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33081.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 61.175 1.8885]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33085.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0966]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33089.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2805]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33091.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33096.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1325 1.4398]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33100.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1868]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33117.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0986]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33119.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 8.6354 22.7 9.6031]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33121.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0351 1.3216]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33122.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1625]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33128.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3779]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33129.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.036923 -0.018462]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33131.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0281 1.2509]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33132.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33136.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.013846]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33138.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0542]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33145.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0511]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33149.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0473 1.2755]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33154.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0279]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33157.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0358 1.335]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33159.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1821]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33163.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33167.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0757]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33168.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1977 1.5422]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33172.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0171]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33180.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0155 1.3082]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33181.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1154 1.0238]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33184.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0847]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33186.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33188.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33193.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1129]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33197.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0361]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33200.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0659]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33205.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1914]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33206.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2459]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33208.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2306]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33210.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1903]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33211.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2078 1.5554]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33213.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1593]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33226.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2023]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33229.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0389]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33235.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0191]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33238.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0426]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33239.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1595]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33241.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0753]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33243.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1099]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33246.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0529]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33249.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0807]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33253.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1991]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33254.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0958]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33256.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0458 1.3442]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33258.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0319]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33263.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0755]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33265.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2788]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33269.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2136]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33270.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0208]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33272.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0408]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33274.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33275.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3677]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33277.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0503]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33278.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0472]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33279.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1544]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33281.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2187 1.7309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33286.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0323 1.3276]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33287.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 2.7092 1.2031 1.1231]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33288.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1626]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33290.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0436]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33292.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1695 1.5059]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33298.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2133]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33299.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0589 1.4962]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33301.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0997]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33302.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0477]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33304.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1213]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33305.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1673 1.4021]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33307.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2035 1.7085]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33308.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1089]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33309.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0958]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33313.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0305]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33314.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1579]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33322.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1228]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33323.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0942]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33324.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1556]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33329.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1141]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33330.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2851 1.5643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33334.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1943]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33335.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0583]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33336.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0843]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33338.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7992]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33339.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1609]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33342.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0452]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33344.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0114]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33346.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2277]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33347.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0922]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33349.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0394]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33351.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.7415]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33352.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0374]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33353.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0519]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33354.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2296]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33355.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3838 1.7811]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33358.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1083]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33360.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1223]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33362.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 16.311 25.282 851.42 818.8]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33366.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1753]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33368.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0581]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33373.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0384]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33375.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.269 1.5486]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33378.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.05]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33382.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0952]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33388.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0764]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33393.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0652 1.3702]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33395.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2139]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33397.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2379]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33398.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2272]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33399.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2143]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33408.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0879]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33411.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1036]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33416.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0113]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33417.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1548]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33422.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1525]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33431.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0983]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33433.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0308]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33434.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0791]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33436.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2313 1.0662]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33437.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2042]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33442.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2885]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33443.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0309]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33445.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2122]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33446.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3482]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33449.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2093]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33450.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2889 1.6612]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33451.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0679 1.3552]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33456.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0815 1.378]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33459.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1189]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33460.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.125]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33467.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3193]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33470.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0795]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33472.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0286]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33476.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.179]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33479.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1973]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33481.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3177 1.2615 1.1225]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33482.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1969]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33485.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33487.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.4074]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33489.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0664]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33493.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1076]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33495.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2108]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33497.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.073]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33498.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0248 1.3077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33505.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0115]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33506.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.196 1.5365]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33510.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.3014 1.6636]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33511.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0422]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33516.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0463 1.2634]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33517.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0927]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33518.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0859]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33519.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0957]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33524.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.252]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33526.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1321]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33530.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0626 1.2833]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33537.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0231 1.2396]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33538.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2786]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33539.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1033 1.3413]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33540.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.282]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33545.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1184 1.5864]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33546.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.12461]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33555.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1209]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33557.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 5.4246 3.4515 2.9254]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33558.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0484]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33561.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0154]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33564.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0749]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33570.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0734 1.3066]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33571.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0902]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33572.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2009]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33574.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2291]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33576.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0644]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33579.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2561]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33584.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1262]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33585.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1098]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33589.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0105]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33590.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0643]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33591.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0709 1.3793]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33596.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.132 1.3773]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33597.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0694]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33599.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0496]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33607.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2397 1.5096]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33609.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0304]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33612.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1869]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33618.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.2466]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33625.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0479]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33630.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1569]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33633.png: ignoring corrupt image/label: negative class labels or coordinate [ -0.043077]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33639.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0342]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33641.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.1043]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33642.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0159 1.2403]\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_bar/images/val/33648.png: ignoring corrupt image/label: non-normalized or out of bounds coordinates [ 1.0263]\n", + "\u001b[34m\u001b[1moptimizer:\u001b[0m AdamW(lr=0.001, momentum=0.937) with parameter groups 81 weight(decay=0.0), 88 weight(decay=0.0005), 87 bias(decay=0.0)\n", + "Plotting labels to /content/drive/MyDrive/Spectra_YOLO_Project/Clean_Bar_Run/detect/train2/labels.jpg... \n", + "Image sizes 640 train, 640 val\n", + "Using 2 dataloader workers\n", + "Logging results to \u001b[1m/content/drive/MyDrive/Spectra_YOLO_Project/Clean_Bar_Run/detect/train2\u001b[0m\n", + "Starting training for 30 epochs...\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 1/30 6.91G 0.3818 0.3913 0.8485 385 640: 100% ━━━━━━━━━━━━ 1250/1250 1.5it/s 13:33\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.4it/s 1:51\n", + " all 9793 55012 0.857 0.765 0.779 0.742\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 2/30 6.91G 0.2788 0.2302 0.8089 367 640: 100% ━━━━━━━━━━━━ 1250/1250 1.6it/s 13:09\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.6it/s 1:35\n", + " all 9793 55012 0.848 0.769 0.803 0.773\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 3/30 6.91G 0.2661 0.2107 0.8047 359 640: 100% ━━━━━━━━━━━━ 1250/1250 1.6it/s 12:55\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.6it/s 1:35\n", + " all 9793 55012 0.874 0.755 0.808 0.779\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 4/30 6.91G 0.2484 0.1934 0.8018 329 640: 100% ━━━━━━━━━━━━ 1250/1250 1.6it/s 12:42\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.6it/s 1:37\n", + " all 9793 55012 0.856 0.763 0.806 0.783\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 5/30 6.91G 0.238 0.1823 0.8002 433 640: 100% ━━━━━━━━━━━━ 1250/1250 1.7it/s 12:38\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.6it/s 1:34\n", + " all 9793 55012 0.863 0.764 0.797 0.774\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 6/30 6.91G 0.2288 0.1726 0.7986 398 640: 100% ━━━━━━━━━━━━ 1250/1250 1.7it/s 12:19\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.6it/s 1:35\n", + " all 9793 55012 0.845 0.77 0.764 0.738\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 7/30 6.91G 0.2233 0.1671 0.798 362 640: 100% ━━━━━━━━━━━━ 1250/1250 1.7it/s 12:12\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.6it/s 1:36\n", + " all 9793 55012 0.849 0.77 0.796 0.773\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 8/30 6.91G 0.2175 0.1631 0.7971 399 640: 100% ━━━━━━━━━━━━ 1250/1250 1.7it/s 12:37\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.6it/s 1:38\n", + " all 9793 55012 0.846 0.768 0.781 0.758\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 9/30 6.91G 0.2102 0.1573 0.7959 333 640: 100% ━━━━━━━━━━━━ 1250/1250 1.6it/s 12:56\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.5it/s 1:39\n", + " all 9793 55012 0.842 0.773 0.793 0.772\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 10/30 6.91G 0.2049 0.1532 0.7959 347 640: 100% ━━━━━━━━━━━━ 1250/1250 1.6it/s 12:55\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.5it/s 1:40\n", + " all 9793 55012 0.847 0.771 0.803 0.784\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 11/30 6.91G 0.2004 0.1501 0.7956 424 640: 100% ━━━━━━━━━━━━ 1250/1250 1.6it/s 12:58\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.6it/s 1:39\n", + " all 9793 55012 0.848 0.77 0.795 0.775\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 12/30 6.91G 0.1947 0.1453 0.795 379 640: 100% ━━━━━━━━━━━━ 1250/1250 1.6it/s 12:48\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 154/154 1.5it/s 1:40\n", + " all 9793 55012 0.846 0.771 0.792 0.772\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 13/30 6.91G 0.191 0.1404 0.7942 376 640: 46% ━━━━━╸────── 577/1250 1.8it/s 6:05<6:14" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "import os\n", + "\n", + "# 1. Mount Google Drive to the Colab environment\n", + "drive.mount('/content/drive')\n", + "\n", + "# 2. Create the exact backup folder structure you requested\n", + "drive_save_path = \"/content/drive/MyDrive/Spectra_YOLO_Project/dot_line\"\n", + "os.makedirs(drive_save_path, exist_ok=True)\n", + "print(f\"✅ Drive backup folder ready at: {drive_save_path}\")\n", + "\n", + "# 3. Unzip the dataset into Colab's fast local storage\n", + "# 👇 UPDATE THIS TO MATCH THE EXACT NAME OF YOUR ZIP FILE ON DRIVE 👇\n", + "zip_file_path = \"/content/drive/MyDrive/Spectra/yolo_dataset_dots.zip\"\n", + "extraction_path = \"/content/datasets\"\n", + "\n", + "print(\"📦 Unzipping dataset... (this might take a minute)\")\n", + "!unzip -q \"{zip_file_path}\" -d \"{extraction_path}\"\n", + "print(\"✅ Dataset successfully unzipped into Colab!\")" + ], + "metadata": { + "id": "FFFeBzzXQJIf", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "9322103b-105c-4475-c684-384d10107d7a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n", + "✅ Drive backup folder ready at: /content/drive/MyDrive/Spectra_YOLO_Project/dot_line\n", + "📦 Unzipping dataset... (this might take a minute)\n", + "✅ Dataset successfully unzipped into Colab!\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "pip install easyocr" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0u17fkyz-BK4", + "outputId": "16289640-6eb5-4501-c227-74221f83a085" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting easyocr\n", + " Downloading easyocr-1.7.2-py3-none-any.whl.metadata (10 kB)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.12/dist-packages (from easyocr) (2.10.0+cu128)\n", + "Requirement already satisfied: torchvision>=0.5 in /usr/local/lib/python3.12/dist-packages (from easyocr) (0.25.0+cu128)\n", + "Requirement already satisfied: opencv-python-headless in /usr/local/lib/python3.12/dist-packages (from easyocr) (4.13.0.92)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.12/dist-packages (from easyocr) (1.16.3)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from easyocr) (2.0.2)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.12/dist-packages (from easyocr) (11.3.0)\n", + "Requirement already satisfied: scikit-image in /usr/local/lib/python3.12/dist-packages (from easyocr) (0.25.2)\n", + "Collecting python-bidi (from easyocr)\n", + " Downloading python_bidi-0.6.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (4.9 kB)\n", + "Requirement already satisfied: PyYAML in /usr/local/lib/python3.12/dist-packages (from easyocr) (6.0.3)\n", + "Requirement already satisfied: Shapely in /usr/local/lib/python3.12/dist-packages (from easyocr) (2.1.2)\n", + "Collecting pyclipper (from easyocr)\n", + " Downloading pyclipper-1.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (8.6 kB)\n", + "Collecting ninja (from easyocr)\n", + " Downloading ninja-1.13.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (5.1 kB)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.24.3)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (4.15.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (75.2.0)\n", + "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (1.14.0)\n", + "Requirement already satisfied: networkx>=2.5.1 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.6.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.1.6)\n", + "Requirement already satisfied: fsspec>=0.8.5 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (2025.3.0)\n", + "Requirement already satisfied: cuda-bindings==12.9.4 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.9.4)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.93)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.90)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.90)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (9.10.2.21)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.8.4.1 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.4.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.3.3.83 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (11.3.3.83)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.9.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (10.3.9.90)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.7.3.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (11.7.3.90)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.5.8.93 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.5.8.93)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (0.7.1)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.27.5 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (2.27.5)\n", + "Requirement already satisfied: nvidia-nvshmem-cu12==3.4.5 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.4.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.8.90 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.90)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12==12.8.93 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (12.8.93)\n", + "Requirement already satisfied: nvidia-cufile-cu12==1.13.1.3 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (1.13.1.3)\n", + "Requirement already satisfied: triton==3.6.0 in /usr/local/lib/python3.12/dist-packages (from torch->easyocr) (3.6.0)\n", + "Requirement already satisfied: cuda-pathfinder~=1.1 in /usr/local/lib/python3.12/dist-packages (from cuda-bindings==12.9.4->torch->easyocr) (1.4.0)\n", + "Requirement already satisfied: imageio!=2.35.0,>=2.33 in /usr/local/lib/python3.12/dist-packages (from scikit-image->easyocr) (2.37.2)\n", + "Requirement already satisfied: tifffile>=2022.8.12 in /usr/local/lib/python3.12/dist-packages (from scikit-image->easyocr) (2026.2.24)\n", + "Requirement already satisfied: packaging>=21 in /usr/local/lib/python3.12/dist-packages (from scikit-image->easyocr) (26.0)\n", + "Requirement already satisfied: lazy-loader>=0.4 in /usr/local/lib/python3.12/dist-packages (from scikit-image->easyocr) (0.4)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch->easyocr) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch->easyocr) (3.0.3)\n", + "Downloading easyocr-1.7.2-py3-none-any.whl (2.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.9/2.9 MB\u001b[0m \u001b[31m47.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading ninja-1.13.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (180 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m180.7/180.7 kB\u001b[0m \u001b[31m22.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pyclipper-1.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (978 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m978.2/978.2 kB\u001b[0m \u001b[31m81.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading python_bidi-0.6.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (300 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m300.6/300.6 kB\u001b[0m \u001b[31m36.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: python-bidi, pyclipper, ninja, easyocr\n", + "Successfully installed easyocr-1.7.2 ninja-1.13.0 pyclipper-1.4.0 python-bidi-0.6.7\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from ultralytics import YOLO\n", + "\n", + "# 1. Create the dataset configuration file\n", + "# Note: Adjust the paths if your zip file extracted slightly differently!\n", + "yaml_content = \"\"\"\n", + "train: /content/datasets/yolo_dataset_dots/images/train\n", + "val: /content/datasets/yolo_dataset_dots/images/val\n", + "nc: 1\n", + "names: ['dot']\n", + "\"\"\"\n", + "\n", + "with open(\"/content/dots.yaml\", \"w\") as f:\n", + " f.write(yaml_content.strip())\n", + "\n", + "print(\"✅ Configuration saved. Booting up AI training...\\n\")\n", + "\n", + "# 2. Start Local Training\n", + "model = YOLO(\"yolo11n.pt\")\n", + "\n", + "model.train(\n", + " data=\"/content/dots.yaml\",\n", + " epochs=25,\n", + " imgsz=640,\n", + " batch=32,\n", + " device=0,\n", + " optimizer='AdamW',\n", + " lr0=0.001,\n", + "\n", + " # 🛡️ THE SAFETY NET: Save progress directly to Google Drive\n", + " project=\"/content/drive/MyDrive/Spectra_YOLO_Project/dot_line\",\n", + " name=\"dot_detector_run\",\n", + "\n", + " save=True,\n", + " save_period=5 # Forces a hard backup of the weights every 5 epochs\n", + ")\n", + "\n", + "print(\"✅ Dot Constellation Training Complete! Your weights are safely in Google Drive.\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GFL6x9M_9zhJ", + "outputId": "9afac6b9-7f26-43a4-bd37-b5383305089a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[1;30;43mStreaming output truncated to the last 5000 lines.\u001b[0m\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94924.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94929.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94930.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94932.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94934.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94939.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94944.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94945.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94946.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94951.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94955.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94958.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94962.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94963.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94965.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94967.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94970.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94972.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94974.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94976.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94979.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94982.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94983.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94985.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94989.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94990.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94995.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_94997.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95002.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95003.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95004.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95006.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95013.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95015.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95016.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95021.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95023.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95024.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95029.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95030.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95031.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95032.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95036.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95039.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95041.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95042.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95043.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95046.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95047.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95048.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95049.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95050.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95055.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95058.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95060.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95062.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95063.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95065.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95066.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95070.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95071.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95076.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95081.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95083.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95084.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95085.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95088.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95090.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95091.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95092.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95096.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95099.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95102.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95103.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95108.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95112.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95114.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95115.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95117.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95120.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95122.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95128.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95133.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95135.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95140.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95145.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95147.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95151.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95152.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95156.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95165.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95166.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95167.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95169.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95171.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95173.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95175.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95177.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95179.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95180.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95183.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95185.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95187.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95191.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95194.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95196.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95198.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95201.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95202.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95205.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95208.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95210.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95211.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95212.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95214.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95215.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95216.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95217.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95222.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95227.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95230.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95231.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95232.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95235.png: 33 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95237.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95239.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95241.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95244.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95245.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95256.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95258.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95259.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95266.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95268.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95272.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95274.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95280.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95287.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95290.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95292.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95296.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95297.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95298.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95300.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95302.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95309.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95311.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95316.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95317.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95319.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95321.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95323.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95324.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95327.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95328.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95329.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95330.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95331.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95340.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95342.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95345.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95346.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95352.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95355.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95356.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95363.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95364.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95365.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95367.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95369.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95372.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95377.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95383.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95389.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95392.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95395.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95396.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95399.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95402.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95404.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95406.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95413.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95418.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95419.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95421.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95423.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95428.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95433.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95435.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95438.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95442.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95443.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95447.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95449.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95451.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95458.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95460.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95461.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95462.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95472.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95473.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95478.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95486.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95487.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95489.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95493.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95495.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95498.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95502.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95503.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95504.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95505.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95510.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95516.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95518.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95521.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95528.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95529.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95530.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95536.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95537.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95541.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95542.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95544.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95545.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95549.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95552.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95557.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95559.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95560.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95561.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95562.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95564.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95565.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95567.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95569.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95573.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95574.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95576.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95577.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95578.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95581.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95589.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95592.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95593.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95594.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95596.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95597.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95598.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95599.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95600.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95603.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95605.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95606.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95608.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95618.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95619.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95622.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95625.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95628.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95629.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95632.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95633.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95635.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95636.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95644.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95645.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95648.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95651.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95652.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95654.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95655.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95656.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95657.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95660.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95670.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95679.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95680.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95681.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95682.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95687.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95688.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95689.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95692.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95694.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95697.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95703.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95704.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95711.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95719.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95721.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95722.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95723.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95724.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95727.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95728.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95729.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95734.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95735.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95736.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95739.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95740.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95741.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95742.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95745.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95746.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95747.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95750.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95754.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95757.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95759.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95763.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95764.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95765.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95766.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95772.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95773.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95774.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95775.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95777.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95781.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95783.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95792.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95795.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95797.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95801.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95802.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95804.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95808.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95809.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95810.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95811.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95816.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95818.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95821.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95822.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95826.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95828.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95830.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95832.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95833.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95837.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95839.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95840.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95842.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95844.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95846.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95851.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95856.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95860.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95864.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95866.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95867.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95868.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95872.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95873.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95875.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95878.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95879.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95881.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95884.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95885.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95886.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95887.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95888.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95892.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95893.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95896.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95898.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95899.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95900.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95913.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95915.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95922.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95924.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95925.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95932.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95934.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95935.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95945.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95946.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95948.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95949.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95953.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95956.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95958.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95961.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95962.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95964.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95965.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95967.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95971.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95974.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95976.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95979.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95980.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95981.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95985.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95988.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95989.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95993.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95994.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95995.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95996.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95997.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_95998.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96003.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96004.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96009.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96010.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96013.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96014.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96017.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96018.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96019.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96021.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96023.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96024.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96025.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96027.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96030.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96033.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96034.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96036.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96038.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96039.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96041.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96046.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96051.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96056.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96061.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96065.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96072.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96077.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96079.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96080.png: 31 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96081.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96083.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96089.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96090.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96093.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96094.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96097.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96100.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96102.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96103.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96104.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96105.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96106.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96107.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96108.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96117.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96118.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96123.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96125.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96126.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96127.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96130.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96131.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96137.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96141.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96142.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96147.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96151.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96155.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96157.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96159.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96160.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96163.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96164.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96165.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96166.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96167.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96168.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96176.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96177.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96178.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96179.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96182.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96186.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96189.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96196.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96197.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96199.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96200.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96203.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96204.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96207.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96210.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96215.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96217.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96218.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96219.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96222.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96223.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96224.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96226.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96230.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96231.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96232.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96233.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96235.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96236.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96239.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96241.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96243.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96254.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96257.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96261.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96262.png: 23 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96263.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96267.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96271.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96273.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96274.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96278.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96279.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96281.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96289.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96291.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96292.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96293.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96294.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96299.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96300.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96304.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96305.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96306.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96307.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96309.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96310.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96312.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96313.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96314.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96315.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96316.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96318.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96322.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96325.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96333.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96334.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96335.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96341.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96345.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96355.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96361.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96364.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96367.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96368.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96372.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96373.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96374.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96376.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96377.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96379.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96383.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96386.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96389.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96390.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96392.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96393.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96394.png: 28 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96395.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96396.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96397.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96399.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96401.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96407.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96408.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96409.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96411.png: 28 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96413.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96415.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96419.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96422.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96423.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96424.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96426.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96431.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96435.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96437.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96439.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96440.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96442.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96444.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96446.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96448.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96449.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96452.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96453.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96454.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96455.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96461.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96463.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96465.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96469.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96470.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96473.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96475.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96477.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96479.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96480.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96484.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96485.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96487.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96494.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96497.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96501.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96502.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96504.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96505.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96507.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96509.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96511.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96515.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96516.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96519.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96520.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96523.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96524.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96525.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96526.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96532.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96533.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96540.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96542.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96546.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96547.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96549.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96557.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96559.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96561.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96563.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96570.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96576.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96577.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96581.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96583.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96585.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96588.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96589.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96593.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96597.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96598.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96601.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96604.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96606.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96608.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96610.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96611.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96615.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96616.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96617.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96618.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96620.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96624.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96627.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96628.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96629.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96633.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96634.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96640.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96642.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96644.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96645.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96650.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96652.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96654.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96655.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96656.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96658.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96661.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96662.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96665.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96671.png: 24 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96672.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96677.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96680.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96685.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96687.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96688.png: 24 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96690.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96693.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96694.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96695.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96697.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96698.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96700.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96702.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96703.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96707.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96708.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96717.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96723.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96726.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96727.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96731.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96732.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96736.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96740.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96745.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96748.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96750.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96752.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96755.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96758.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96760.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96761.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96762.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96766.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96769.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96772.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96776.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96779.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96791.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96793.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96794.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96795.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96796.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96802.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96804.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96807.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96809.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96811.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96815.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96817.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96819.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96823.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96826.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96827.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96832.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96835.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96836.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96837.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96842.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96846.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96847.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96849.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96850.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96852.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96855.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96857.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96858.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96859.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96860.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96863.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96868.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96873.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96874.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96877.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96882.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96884.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96886.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96890.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96891.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96895.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96898.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96899.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96900.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96901.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96902.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96907.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96911.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96912.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96916.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96917.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96918.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96922.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96927.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96929.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96933.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96937.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96945.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96952.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96953.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96954.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96960.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96961.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96964.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96965.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96970.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96971.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96974.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96975.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96978.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96979.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96981.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96983.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96989.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96990.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96991.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_96999.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97001.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97002.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97004.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97006.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97008.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97009.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97011.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97013.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97014.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97017.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97020.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97024.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97025.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97029.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97030.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97034.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97038.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97040.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97047.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97052.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97055.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97057.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97058.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97060.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97061.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97064.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97070.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97075.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97076.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97077.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97078.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97079.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97080.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97082.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97083.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97085.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97092.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97093.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97095.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97096.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97099.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97100.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97102.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97110.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97113.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97114.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97115.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97116.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97117.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97122.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97126.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97130.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97132.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97133.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97139.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97142.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97145.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97148.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97150.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97153.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97154.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97155.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97156.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97159.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97160.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97161.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97164.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97170.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97171.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97172.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97173.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97176.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97177.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97180.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97184.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97187.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97189.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97193.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97195.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97199.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97201.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97203.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97206.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97207.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97212.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97214.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97216.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97218.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97219.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97220.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97222.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97223.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97224.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97225.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97227.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97229.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97230.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97231.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97237.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97242.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97244.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97245.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97246.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97247.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97248.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97252.png: 26 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97253.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97261.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97263.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97267.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97268.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97269.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97270.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97272.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97275.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97277.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97281.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97282.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97287.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97288.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97291.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97299.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97305.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97309.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97312.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97314.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97316.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97320.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97321.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97323.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97324.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97327.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97328.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97330.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97334.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97337.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97339.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97340.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97343.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97345.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97346.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97347.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97349.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97350.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97351.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97356.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97357.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97358.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97362.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97363.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97364.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97365.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97369.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97370.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97373.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97374.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97375.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97376.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97377.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97378.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97380.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97383.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97388.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97390.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97393.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97396.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97398.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97401.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97402.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97403.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97413.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97414.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97419.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97421.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97422.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97426.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97432.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97434.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97436.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97437.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97439.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97443.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97444.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97445.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97448.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97449.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97450.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97452.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97453.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97456.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97459.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97461.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97466.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97467.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97472.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97473.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97476.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97477.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97478.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97480.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97481.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97483.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97484.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97485.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97486.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97492.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97493.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97494.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97496.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97502.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97504.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97507.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97510.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97511.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97514.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97517.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97518.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97522.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97527.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97528.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97529.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97530.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97531.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97532.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97536.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97544.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97545.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97546.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97547.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97548.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97554.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97561.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97564.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97567.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97569.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97570.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97577.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97579.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97583.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97584.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97585.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97591.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97592.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97596.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97602.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97603.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97604.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97606.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97612.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97613.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97618.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97621.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97622.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97623.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97626.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97627.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97629.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97632.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97634.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97635.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97636.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97638.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97640.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97644.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97647.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97650.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97651.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97653.png: 32 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97656.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97657.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97662.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97664.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97668.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97672.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97673.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97675.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97681.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97683.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97684.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97687.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97688.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97689.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97699.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97703.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97705.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97706.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97707.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97712.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97713.png: 53 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97724.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97726.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97727.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97730.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97731.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97732.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97733.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97735.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97736.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97737.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97738.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97742.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97745.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97747.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97748.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97752.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97755.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97756.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97757.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97758.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97763.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97766.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97767.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97771.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97772.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97775.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97778.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97779.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97782.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97783.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97784.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97786.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97799.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97804.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97805.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97808.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97809.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97813.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97814.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97816.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97817.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97820.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97826.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97830.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97832.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97833.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97836.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97838.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97839.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97840.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97843.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97846.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97849.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97850.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97853.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97854.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97860.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97861.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97862.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97865.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97871.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97873.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97876.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97879.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97882.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97887.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97890.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97891.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97896.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97905.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97909.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97911.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97914.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97917.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97920.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97923.png: 63 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97929.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97930.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97932.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97933.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97937.png: 24 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97941.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97943.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97947.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97948.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97949.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97952.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97953.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97955.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97956.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97958.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97960.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97961.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97963.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97966.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97967.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97970.png: 24 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97973.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97974.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97976.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97980.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97982.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97985.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97989.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97990.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97992.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_97999.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98002.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98003.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98005.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98006.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98014.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98015.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98017.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98023.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98025.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98026.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98027.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98029.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98030.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98035.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98038.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98050.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98060.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98061.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98062.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98063.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98064.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98065.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98067.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98070.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98076.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98078.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98079.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98083.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98086.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98087.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98091.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98104.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98109.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98114.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98119.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98120.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98121.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98129.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98130.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98135.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98138.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98139.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98143.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98145.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98148.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98152.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98153.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98156.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98157.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98158.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98164.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98165.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98169.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98172.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98173.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98174.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98178.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98182.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98183.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98187.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98188.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98191.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98192.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98195.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98198.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98200.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98206.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98210.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98212.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98213.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98214.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98216.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98218.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98219.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98221.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98222.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98233.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98243.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98245.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98246.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98247.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98259.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98264.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98267.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98268.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98269.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98272.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98275.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98280.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98281.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98284.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98287.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98288.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98290.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98298.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98299.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98300.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98301.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98306.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98311.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98315.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98316.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98318.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98321.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98322.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98325.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98328.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98331.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98332.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98339.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98343.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98344.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98348.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98349.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98352.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98357.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98358.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98359.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98365.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98367.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98368.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98372.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98373.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98374.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98375.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98381.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98382.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98383.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98386.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98387.png: 32 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98392.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98401.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98405.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98409.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98410.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98411.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98414.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98415.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98420.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98421.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98422.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98428.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98432.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98433.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98437.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98438.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98439.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98443.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98444.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98447.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98448.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98449.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98455.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98461.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98467.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98469.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98471.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98475.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98476.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98477.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98480.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98482.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98484.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98486.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98487.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98488.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98493.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98494.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98496.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98497.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98499.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98502.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98506.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98507.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98511.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98514.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98516.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98517.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98518.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98519.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98522.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98523.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98531.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98533.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98534.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98536.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98537.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98540.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98541.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98544.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98547.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98553.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98554.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98556.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98558.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98561.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98563.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98568.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98569.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98573.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98577.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98578.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98579.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98581.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98586.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98587.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98592.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98597.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98600.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98601.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98606.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98607.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98610.png: 25 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98613.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98619.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98623.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98625.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98627.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98630.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98631.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98635.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98636.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98637.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98639.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98646.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98648.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98649.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98650.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98651.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98653.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98661.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98664.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98669.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98673.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98678.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98679.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98680.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98683.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98686.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98687.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98691.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98696.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98701.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98709.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98710.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98714.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98718.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98722.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98724.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98725.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98732.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98736.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98741.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98742.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98747.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98748.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98762.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98767.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98768.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98771.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98772.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98773.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98774.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98778.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98781.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98782.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98784.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98785.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98786.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98789.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98790.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98793.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98803.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98807.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98808.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98812.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98816.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98817.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98819.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98823.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98826.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98827.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98828.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98829.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98830.png: 23 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98834.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98838.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98840.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98845.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98848.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98849.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98850.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98852.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98854.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98855.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98859.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98871.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98879.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98882.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98884.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98885.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98887.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98889.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98891.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98895.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98906.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98907.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98910.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98911.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98913.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98921.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98923.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98928.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98929.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98931.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98935.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98936.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98937.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98939.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98954.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98955.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98960.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98971.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98974.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98976.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98977.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98979.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98981.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98982.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98984.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98988.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98992.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98995.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98996.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98997.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98998.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_98999.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99003.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99006.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99007.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99010.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99012.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99013.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99015.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99018.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99021.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99022.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99025.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99026.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99028.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99034.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99038.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99039.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99043.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99045.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99047.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99048.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99049.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99050.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99051.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99053.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99059.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99061.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99064.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99067.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99069.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99070.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99071.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99076.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99078.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99079.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99083.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99085.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99087.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99088.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99089.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99090.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99091.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99092.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99094.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99098.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99099.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99100.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99105.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99106.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99109.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99116.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99121.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99122.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99128.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99132.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99141.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99144.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99147.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99148.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99150.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99154.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99155.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99160.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99161.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99163.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99168.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99169.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99171.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99173.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99177.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99178.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99180.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99185.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99193.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99194.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99196.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99201.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99205.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99211.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99212.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99213.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99215.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99217.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99220.png: 25 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99223.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99224.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99225.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99230.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99233.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99236.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99243.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99245.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99253.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99259.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99261.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99262.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99264.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99271.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99273.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99275.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99277.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99278.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99283.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99284.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99285.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99286.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99287.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99294.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99298.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99301.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99305.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99307.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99310.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99313.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99314.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99317.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99318.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99322.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99324.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99325.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99326.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99328.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99329.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99332.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99333.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99339.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99340.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99341.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99344.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99351.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99355.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99357.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99358.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99359.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99361.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99363.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99364.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99367.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99368.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99370.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99371.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99375.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99377.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99378.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99381.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99383.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99391.png: 29 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99392.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99393.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99396.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99398.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99400.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99401.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99404.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99405.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99407.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99413.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99415.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99416.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99420.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99423.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99425.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99426.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99429.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99433.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99437.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99439.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99440.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99441.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99444.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99446.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99448.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99454.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99455.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99457.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99458.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99467.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99469.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99470.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99471.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99472.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99478.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99481.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99482.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99483.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99487.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99488.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99495.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99496.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99499.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99500.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99501.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99505.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99506.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99507.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99508.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99512.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99515.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99516.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99524.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99528.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99529.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99530.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99532.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99536.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99537.png: 28 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99539.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99542.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99543.png: 21 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99546.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99549.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99550.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99552.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99554.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99555.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99556.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99557.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99558.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99563.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99565.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99566.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99567.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99568.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99572.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99574.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99575.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99584.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99585.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99588.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99589.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99590.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99591.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99592.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99593.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99594.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99596.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99599.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99601.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99603.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99605.png: 33 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99608.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99610.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99611.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99613.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99616.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99620.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99621.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99622.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99624.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99626.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99628.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99631.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99633.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99635.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99637.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99640.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99644.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99645.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99648.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99649.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99650.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99653.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99659.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99660.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99662.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99663.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99664.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99668.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99671.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99673.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99675.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99677.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99680.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99681.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99682.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99687.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99694.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99695.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99696.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99703.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99706.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99712.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99714.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99716.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99723.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99727.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99728.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99733.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99734.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99737.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99739.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99742.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99745.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99748.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99749.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99750.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99751.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99752.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99753.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99756.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99759.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99763.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99764.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99772.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99774.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99777.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99778.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99780.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99784.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99791.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99793.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99796.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99797.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99805.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99808.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99809.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99810.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99812.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99815.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99816.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99825.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99826.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99829.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99831.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99832.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99834.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99839.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99840.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99843.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99844.png: 25 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99848.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99849.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99852.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99854.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99859.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99860.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99863.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99864.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99865.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99866.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99868.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99877.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99879.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99880.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99881.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99883.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99884.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99886.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99890.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99892.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99893.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99897.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99899.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99902.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99907.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99909.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99911.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99917.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99919.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99920.png: 28 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99922.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99924.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99928.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99932.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99935.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99936.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99937.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99938.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99940.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99944.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99947.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99951.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99960.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99963.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99970.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99972.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99975.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99976.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99982.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99985.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99986.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99991.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99992.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99997.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0m/content/datasets/yolo_dataset_dots/images/train/FigureQA_99999.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mtrain: \u001b[0mNew cache created: /content/datasets/yolo_dataset_dots/labels/train.cache\n", + "\u001b[34m\u001b[1malbumentations: \u001b[0mBlur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, method='weighted_average', num_output_channels=3), CLAHE(p=0.01, clip_limit=(1.0, 4.0), tile_grid_size=(8, 8))\n", + "\u001b[34m\u001b[1mval: \u001b[0mFast image access ✅ (ping: 0.0±0.0 ms, read: 597.5±217.8 MB/s, size: 29.1 KB)\n", + "\u001b[K\u001b[34m\u001b[1mval: \u001b[0mScanning /content/datasets/yolo_dataset_dots/labels/val... 4000 images, 0 backgrounds, 0 corrupt: 100% ━━━━━━━━━━━━ 4000/4000 495.9it/s 8.1s\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10003.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10016.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10028.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1003.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10036.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10037.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10079.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1008.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1009.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10098.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_101.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10101.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10102.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10103.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10107.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10109.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10112.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10159.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10161.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10166.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10189.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10201.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10205.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10206.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10217.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10219.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10247.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10250.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10255.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1026.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10262.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10263.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10264.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10277.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10285.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10288.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10294.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10299.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_103.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10309.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10312.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10315.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10318.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10319.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10323.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10325.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10330.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10339.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10341.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10346.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10348.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10350.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10355.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1036.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10364.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10366.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1038.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10401.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10405.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10409.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10410.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10413.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10415.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10419.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10429.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10436.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10437.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10462.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10465.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10484.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10491.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10498.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10509.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10527.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10529.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10549.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10550.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10553.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10568.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10570.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10571.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10574.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10580.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10581.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10586.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1059.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10605.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1061.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10616.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10620.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10628.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1063.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10639.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10654.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10668.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10669.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10670.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10690.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10692.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10695.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10696.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10706.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10714.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10718.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10719.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10729.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10737.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10740.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10747.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10748.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10749.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10750.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10759.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10778.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10779.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10783.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10789.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10792.png: 26 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10794.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10797.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10816.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10817.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10818.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10836.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10838.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10842.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10845.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1085.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10851.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10856.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10862.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10865.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10869.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1089.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10912.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10926.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10930.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10937.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10939.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10940.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10949.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10952.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10956.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10957.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10962.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10966.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10973.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_10999.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11006.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1101.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11018.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11023.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11030.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11034.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11041.png: 21 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11053.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1106.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11066.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11070.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11071.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11077.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11095.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11098.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11102.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11107.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11125.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11134.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11154.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11155.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11156.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1116.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11163.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1119.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11191.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11218.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11230.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11237.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1124.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11240.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11243.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11249.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1125.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11254.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11267.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11273.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11283.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11289.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1129.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11299.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11301.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11311.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11316.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11319.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11320.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11323.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11334.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11336.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11338.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11344.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11350.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11362.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11365.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11397.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11417.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11418.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1142.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11422.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11424.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11429.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11431.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11438.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11443.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11452.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11459.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11465.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11488.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11497.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1150.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11500.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11516.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11517.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11529.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1154.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11560.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11561.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11565.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1157.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11571.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11584.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11590.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11599.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11614.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11616.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11629.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1163.png: 25 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11632.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11642.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11647.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11653.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11658.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1166.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11667.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11670.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11680.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11683.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1170.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11715.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11717.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11726.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11732.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11733.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11734.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11737.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11743.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11746.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11751.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11755.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11759.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11761.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11767.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11771.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11780.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11782.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11787.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11791.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11793.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11795.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1180.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1181.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11818.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11820.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11824.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11838.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1184.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11841.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11848.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11854.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1186.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11879.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11884.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11890.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11893.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11897.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1193.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11937.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11946.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11947.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11959.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11971.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11973.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11976.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11980.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11985.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11988.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1199.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_11993.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12019.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12026.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12028.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12038.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12039.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1204.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12040.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12043.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12045.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12046.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12047.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12062.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12066.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1207.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12070.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12087.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12090.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12095.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12097.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_121.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12121.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12124.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12131.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12136.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12137.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1214.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12149.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12159.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1218.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12196.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12206.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12226.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1223.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12231.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12237.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12238.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12249.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1226.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12271.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12272.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12276.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12278.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12284.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12293.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12298.png: 21 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12302.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12310.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12317.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12318.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12319.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12320.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12321.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12330.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12332.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12335.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12336.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12349.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12350.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12355.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12368.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12381.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12385.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1239.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12399.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_124.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12404.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12407.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12408.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12415.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12421.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12426.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12428.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12432.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12433.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1244.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12444.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12446.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12447.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1245.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12452.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12460.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12463.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12469.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12470.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12471.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12474.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12477.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1248.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12482.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12485.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12486.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1250.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12504.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12508.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12515.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12519.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12522.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12523.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12524.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12532.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12560.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12572.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12579.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12586.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12592.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12598.png: 23 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_126.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12602.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12605.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12608.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12614.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12616.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1262.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12625.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12633.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12641.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12647.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12653.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12665.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12666.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12671.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12673.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12675.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12699.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_127.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12700.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12709.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12715.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12724.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12726.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12730.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12743.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12757.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1276.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12773.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12784.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12785.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_128.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1280.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12801.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12804.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12809.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12812.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12817.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12824.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12831.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12837.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12845.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1285.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12853.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12854.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12859.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12865.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12868.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12870.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12871.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12884.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12886.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12900.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12910.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12913.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12926.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12939.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12947.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12952.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12958.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12976.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12978.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12979.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1298.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12982.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12984.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_12997.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13004.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13015.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13024.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13026.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13031.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13041.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13045.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13050.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13072.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13076.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13078.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1308.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13082.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13086.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13094.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13095.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_131.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1310.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13100.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1311.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13126.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13130.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13135.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13136.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13144.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13148.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13152.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13158.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13161.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13182.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13188.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13189.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13192.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1321.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13217.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13240.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13241.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13244.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13247.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13250.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13262.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13269.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13272.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13278.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13293.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13295.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13299.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1330.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13303.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13308.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13318.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13327.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13348.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13356.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1336.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13362.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13368.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13369.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1337.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13374.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13385.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13390.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13400.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13409.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13417.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13427.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1343.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13441.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13448.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13450.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13464.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13472.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13474.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13482.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13499.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13506.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13525.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13531.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13539.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1354.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13549.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13550.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13554.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13557.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1356.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13570.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13593.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13600.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13613.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13616.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13634.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13637.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13638.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13648.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13657.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1366.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13680.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13683.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1369.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13693.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13694.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13697.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13717.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13724.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13729.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13735.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13736.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13743.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13747.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13750.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13754.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13768.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13774.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13780.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13800.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13816.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13826.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13838.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13840.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13857.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13858.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1386.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13863.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13872.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13880.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13883.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13887.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13890.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13892.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13919.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1392.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13922.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1393.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13938.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13948.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13951.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13957.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13960.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13977.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13994.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_13999.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14002.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14003.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14006.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14011.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14012.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14028.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14033.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14041.png: 29 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14047.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14056.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14063.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14065.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14066.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14070.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14072.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14083.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14093.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14099.png: 26 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14106.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14115.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14117.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14119.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14136.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1414.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1415.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14180.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14193.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14195.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14198.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14216.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14219.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1423.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14248.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14260.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14274.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14285.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14302.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14306.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14319.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14333.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14334.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14338.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14339.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14342.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14355.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14356.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14374.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14377.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14380.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14399.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14402.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14409.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14418.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14420.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14426.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14433.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14437.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14453.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14459.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14471.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14477.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14485.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14495.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14516.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14517.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14519.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14557.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14576.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14577.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14582.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14583.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14584.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14585.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14588.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14591.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14592.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14595.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14596.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1460.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14604.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14605.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14607.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14614.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14618.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14622.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14633.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14635.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14638.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14642.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14644.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14647.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14648.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1465.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14655.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14658.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14660.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14661.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14663.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14667.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14669.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14673.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14674.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14676.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14677.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14682.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1470.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14705.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14706.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14707.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1471.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14711.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14725.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14731.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14736.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14748.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14761.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14764.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14765.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14768.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14769.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1477.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14785.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14793.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14797.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14800.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14802.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14803.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14804.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14809.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14812.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14816.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14817.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1482.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14820.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14823.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14824.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14845.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14848.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1485.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14852.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14856.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14860.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14862.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14864.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14866.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14900.png: 25 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14901.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14913.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14933.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14934.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14935.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14946.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14958.png: 21 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1496.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14967.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14978.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14980.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14981.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14983.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14984.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14988.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1499.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14996.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_14998.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15005.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15016.png: 24 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15027.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15030.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15034.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15035.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15039.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15042.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15046.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15054.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15061.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15073.png: 23 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15087.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15098.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15103.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15113.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15122.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15128.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15132.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15142.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15153.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15158.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15163.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15171.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15181.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15183.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15186.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15189.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15192.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15195.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15197.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15205.png: 32 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15211.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15215.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15218.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15222.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15223.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15224.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15228.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15231.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15234.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15237.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15247.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1525.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15251.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15264.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15271.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15272.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15277.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15278.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15284.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15304.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15314.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15315.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15317.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15318.png: 33 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15324.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15327.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15347.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1535.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15360.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15371.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15378.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15379.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15407.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15416.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1543.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15432.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15437.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15444.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15445.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15457.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15467.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15468.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15474.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15484.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15488.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15503.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15505.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15506.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15510.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15526.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15545.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1555.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15556.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15569.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15577.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15580.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15587.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1559.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15597.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15608.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15615.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15617.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1562.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15622.png: 39 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15625.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15641.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15642.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15645.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15652.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15669.png: 21 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15677.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15678.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1568.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15680.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15684.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15685.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15688.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1572.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1573.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15739.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15769.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15782.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15793.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15795.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15797.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15802.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15804.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15809.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15815.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15817.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15822.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15828.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1583.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15847.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15856.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1586.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15860.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15879.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15882.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15889.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15911.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15914.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15918.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15919.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15923.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15925.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15928.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1593.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15937.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15939.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15946.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15955.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1596.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15966.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15967.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15974.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15976.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1598.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15983.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15985.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_15996.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16000.png: 23 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16018.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16028.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1603.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16034.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16038.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16039.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16042.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16049.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1605.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16052.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16057.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16062.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16078.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16087.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16090.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16092.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16103.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16108.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16109.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16110.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16113.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16118.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16139.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16140.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16167.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16169.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16179.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1618.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16182.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16188.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1619.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16193.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16198.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16206.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16216.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1622.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16221.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16242.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16246.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16250.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16261.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16266.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16269.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16272.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16274.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16287.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16291.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16292.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16303.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16318.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16319.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16320.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16323.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1633.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16332.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16345.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16353.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16374.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16377.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16381.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16385.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16386.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16388.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16390.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16399.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16400.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16403.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16425.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16431.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16432.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16434.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16439.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16442.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16444.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16447.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16449.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16455.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16463.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16486.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16488.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16498.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16500.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16502.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16515.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16516.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16528.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16534.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16537.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16544.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16547.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16550.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16558.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1657.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16580.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16583.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16584.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16585.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16586.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1659.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16595.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1661.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16611.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16613.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16633.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16641.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16642.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16643.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16652.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16655.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16663.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16674.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16681.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16685.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1669.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16705.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16707.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1671.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16710.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16717.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16721.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16726.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16728.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16730.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16735.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16737.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16742.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16773.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16791.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16797.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16804.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16807.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16814.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16821.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16824.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16829.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16831.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16832.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16836.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16848.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16849.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1685.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16850.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16853.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16855.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16864.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16869.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16878.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16901.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16905.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16908.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1692.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16934.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16935.png: 25 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16936.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16951.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16952.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16953.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16960.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16964.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16967.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1697.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16970.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16971.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16987.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16988.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16990.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16993.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16994.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16995.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_16996.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17002.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17014.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17020.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17025.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17027.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17028.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17032.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17033.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17037.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17051.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17052.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17061.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17074.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17089.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17099.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17100.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17104.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17114.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17123.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17125.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17129.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17132.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17133.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17139.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17141.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17148.png: 46 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17153.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1717.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17173.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17176.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17179.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17185.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1719.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17191.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17194.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17199.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_172.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17200.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17208.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17215.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17229.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17247.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17249.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17258.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17264.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17279.png: 39 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17282.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17283.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17289.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17291.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17296.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17303.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17306.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17308.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17320.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17322.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17339.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17349.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17357.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17359.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17368.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17370.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17371.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17373.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17388.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1739.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17392.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17397.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17409.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17414.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17415.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17417.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17426.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17429.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17432.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17436.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17443.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17448.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17451.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17462.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17475.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17483.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17484.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17487.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17488.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17489.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17490.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17501.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17505.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17513.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17515.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17522.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17525.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17526.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17527.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17528.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17530.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1754.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17551.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17555.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17560.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1757.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17574.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17582.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17584.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17585.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17589.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17594.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17595.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17597.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17603.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17605.png: 23 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17606.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17611.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17621.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17630.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17655.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17669.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17676.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17685.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17692.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17702.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17703.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17706.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1771.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17716.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17719.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1773.png: 33 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17746.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17747.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1775.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17750.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17754.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17758.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17761.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17768.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17771.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17774.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17783.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17786.png: 30 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17798.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_178.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17813.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17815.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17838.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17843.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17848.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17851.png: 26 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17860.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1787.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17870.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17871.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17872.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17873.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17878.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17879.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17882.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17888.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17889.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1790.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17908.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17913.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17914.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17915.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17922.png: 25 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17929.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17932.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17937.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17938.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17939.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17943.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17950.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17957.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1796.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17963.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17968.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17970.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1798.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17981.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17986.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_17994.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18000.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18007.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18021.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18027.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1803.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18037.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18055.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18060.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18063.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18068.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1807.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18082.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1809.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18097.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1812.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18125.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18127.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18133.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18144.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1815.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18152.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18153.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18154.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18156.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18162.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18166.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18180.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18181.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18182.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18197.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18206.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18219.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18235.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18249.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18252.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18261.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18266.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18270.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18277.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18280.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18282.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18283.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18290.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18292.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18295.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_183.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18305.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18307.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18309.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18315.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18324.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18340.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18345.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18352.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18356.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18358.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18366.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18370.png: 24 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18379.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18381.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18382.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18399.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18406.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18409.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18412.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18413.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18418.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18419.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18421.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18424.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1843.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18435.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18438.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18440.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18442.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18448.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18466.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18467.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18477.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18498.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1850.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18509.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1851.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18510.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18512.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18516.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18527.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18529.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18531.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18541.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18543.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18547.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18552.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18554.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18565.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18570.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18571.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18582.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18583.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18585.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18592.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18595.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18613.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18625.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18626.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18642.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18652.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18658.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18664.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18667.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18674.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18676.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18677.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18680.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18686.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18692.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18696.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18704.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1871.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18719.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18722.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18723.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18728.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1873.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18730.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18731.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18741.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18746.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18749.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18751.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18765.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18768.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18780.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18782.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18785.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18792.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18797.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18798.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18806.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18808.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18809.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18810.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18814.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18815.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18820.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18822.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18833.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18838.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18842.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18843.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18847.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18851.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18862.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18865.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18871.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1888.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18884.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18889.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18894.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18897.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18901.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18905.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18910.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18916.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18917.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1893.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18934.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18936.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18937.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18940.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18962.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18963.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18973.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18977.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18980.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18984.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18985.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_18994.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19002.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1901.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19011.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19023.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1903.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19055.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19057.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19063.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19068.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19069.png: 26 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1907.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19075.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19079.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19085.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19102.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19114.png: 21 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19121.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19122.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19136.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19139.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19140.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19153.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19164.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19165.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19169.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19188.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19190.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19192.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19195.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19196.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_192.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19202.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19206.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19207.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19211.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19221.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19242.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19252.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19253.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19258.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19267.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19268.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1927.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19273.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19277.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1928.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19280.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19299.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19301.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19313.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19316.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19327.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19335.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19346.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19358.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1936.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19363.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19374.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19375.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19389.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1939.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19399.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_194.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19409.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19420.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19428.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19443.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1945.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19468.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1947.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19474.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19490.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19499.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19501.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19504.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19506.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19515.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19516.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19522.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19527.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19529.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19533.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19535.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1954.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19543.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19553.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19575.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19580.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19581.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19582.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1959.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19602.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19607.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1962.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19623.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19631.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19635.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19637.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19639.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19656.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19658.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1966.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19669.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19676.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19677.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19678.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19679.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19682.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19685.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19689.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19692.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19702.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19706.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19710.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19715.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19717.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19720.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19741.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19742.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19749.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19751.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19754.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19756.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19767.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19769.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19772.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19775.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19778.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1979.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19803.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19807.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1981.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19813.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19814.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19824.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19828.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19829.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19834.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19836.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19846.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19848.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19863.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19880.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19881.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19899.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19900.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19906.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19909.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1991.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19918.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19925.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19928.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19929.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19933.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19936.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19941.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19943.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_1995.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19950.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19957.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19959.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19961.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19962.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19964.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19967.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19968.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19969.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19980.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19982.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19991.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_19994.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_20.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2001.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_201.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2020.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2021.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2024.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_203.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2036.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2039.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_205.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2053.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2056.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2067.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2072.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2074.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2079.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2081.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2091.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2093.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2094.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2098.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2099.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2103.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2104.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2107.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2108.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2113.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2117.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2118.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2119.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2120.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2125.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2126.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2134.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2141.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2151.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2153.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2157.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2164.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2165.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2167.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2168.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_217.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2172.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2176.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2178.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2179.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2184.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2187.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2190.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_220.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2208.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2212.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2215.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2220.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2230.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2235.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2237.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2243.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2247.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2249.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2251.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2253.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2256.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2266.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2273.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2274.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2292.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2299.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2306.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2307.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2308.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2309.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2319.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2341.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2343.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2351.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2370.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2383.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2392.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2399.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2406.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2414.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2420.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2424.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2431.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2434.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_244.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2444.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2446.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2447.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2451.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2460.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2467.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_247.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2473.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2476.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2484.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2487.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2488.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2489.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2493.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2495.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_250.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2508.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2509.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2512.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2513.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2528.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2529.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2538.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2545.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2553.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2569.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2573.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2575.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2580.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2591.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2596.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2602.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2603.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2604.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2606.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_261.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2624.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2633.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2638.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2639.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2646.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2651.png: 28 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2655.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_266.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2679.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2683.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2684.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2689.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2691.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2697.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_27.png: 33 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2702.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2706.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2713.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2717.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2719.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2721.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2735.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2747.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2756.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2759.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2766.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2777.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2782.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2786.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2791.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2798.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2799.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2804.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2806.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2817.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2818.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2827.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_284.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_285.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2857.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2861.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2863.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2866.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2878.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2884.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2885.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2891.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2894.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2898.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2899.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_290.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2902.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2903.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2904.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2907.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2915.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2916.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2922.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2933.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2951.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2953.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2956.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_296.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2967.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2969.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2979.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_298.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2983.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2985.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2987.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2995.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2997.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_2999.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3001.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3003.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3009.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3011.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3021.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3033.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3039.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3042.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3043.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3055.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3065.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3066.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3083.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3085.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3096.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3106.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_311.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3111.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3117.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3120.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3138.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3151.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3177.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_318.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3193.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3202.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3209.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_321.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3213.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3230.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3234.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3242.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3246.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3254.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3262.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3264.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3265.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3270.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3271.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3274.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3281.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3289.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_329.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3291.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3297.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3303.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_331.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3310.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3321.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3323.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3325.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3342.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3352.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_336.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3361.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3365.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3367.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3377.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3382.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3387.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3389.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3394.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3395.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3399.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3401.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3405.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3406.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3408.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3412.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3418.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3420.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3425.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_343.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3433.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3436.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3443.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3450.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3452.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3458.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3459.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3460.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3468.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3478.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_348.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3480.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3484.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3490.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3497.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3500.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3501.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3517.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3529.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3532.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3543.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3545.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_356.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3568.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_357.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3571.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3574.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3578.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_358.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3584.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3588.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3600.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3606.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3608.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3617.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3631.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3635.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3641.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3650.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3653.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3655.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3660.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3671.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3679.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3682.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_37.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3728.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3739.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3757.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3763.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3764.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3771.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3774.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_378.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3783.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3785.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3788.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_379.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3791.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3810.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3811.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3819.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3820.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_383.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3833.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3835.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3845.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3859.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3864.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3865.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3875.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3879.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3881.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3883.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3898.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_39.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3900.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3917.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3918.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_392.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3929.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_393.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3935.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3936.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3942.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3946.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3950.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3953.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3954.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3963.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3967.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3968.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3975.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3981.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3990.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_3993.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4006.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_401.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4013.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4015.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4017.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4020.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4029.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4032.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4033.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_404.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4041.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4056.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4069.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4073.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4080.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4083.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4088.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4099.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4100.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4121.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4136.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4152.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4153.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4155.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4157.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4159.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_416.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4178.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4180.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4181.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4200.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_422.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4224.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4225.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4227.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4240.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4242.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4244.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4248.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4258.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4262.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4264.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4266.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4271.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4283.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4303.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4309.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4344.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4365.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4378.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4379.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4380.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4381.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_442.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4446.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4447.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_445.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4451.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4452.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4458.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_446.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4468.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4469.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4483.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4484.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_449.png: 40 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4495.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4506.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4522.png: 26 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4531.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4542.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4543.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_455.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4552.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4560.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4569.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_457.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4581.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4585.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4587.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4588.png: 33 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4589.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4590.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4603.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4605.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4606.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4617.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4624.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4626.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4634.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4639.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4644.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4648.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4655.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4686.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4687.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_469.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4696.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4708.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4709.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_471.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4710.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4724.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4729.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4735.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4740.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4754.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4779.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4786.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4801.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_481.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4816.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4819.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_482.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4821.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4822.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4823.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_483.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4830.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4836.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4838.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4841.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4845.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_485.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4850.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4854.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4861.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4881.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4882.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4883.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4887.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_489.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4891.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4905.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4908.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4917.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4918.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4921.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4925.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4928.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_493.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4946.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4953.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4958.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4959.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4963.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4966.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4970.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4972.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4974.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4977.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4982.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4985.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_4993.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5005.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5007.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_502.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5021.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5040.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5044.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5046.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5048.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5052.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5072.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5080.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5081.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5089.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5091.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5094.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5098.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5107.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5114.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5120.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5125.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5141.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5147.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5149.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5151.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5152.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5165.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5168.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5182.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5194.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5205.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5207.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5226.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5242.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5247.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5253.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5264.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5266.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5277.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5288.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5292.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5295.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5296.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5297.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_530.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5322.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5326.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5330.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5346.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5350.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5355.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5359.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5361.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5363.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5368.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5371.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5375.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_538.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5387.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5388.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5395.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_54.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5420.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_543.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5432.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5436.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5440.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5447.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5470.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5471.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5476.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5485.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5490.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5491.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5492.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5493.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5495.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5513.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5537.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5542.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5551.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5552.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5564.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5568.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5578.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5583.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5593.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5625.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_563.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5634.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5645.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5647.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5649.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5652.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5654.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5655.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5679.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5687.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5691.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5692.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5697.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5709.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5714.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5715.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5720.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5722.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5725.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5726.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_573.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5732.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5740.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5742.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5744.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5749.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5751.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5773.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5784.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_58.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5809.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5820.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5846.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5852.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5858.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_586.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5864.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5871.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5873.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5877.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5878.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5883.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5885.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5887.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5898.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5902.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5910.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5913.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5915.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5917.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_592.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5921.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5926.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5927.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5934.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5937.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_594.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5944.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5946.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5954.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5957.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5958.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_596.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5960.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5969.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5978.png: 27 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5987.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5989.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_5999.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6006.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6009.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6012.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6021.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6031.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6037.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6044.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6057.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6061.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6085.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6087.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6093.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_61.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6112.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6119.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6138.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6139.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6142.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6194.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6195.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6205.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6213.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6229.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6235.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_625.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6250.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6266.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6276.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6279.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_63.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6301.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6302.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6306.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6309.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6313.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_633.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6332.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6334.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6339.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6346.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6347.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6357.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6364.png: 23 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6369.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_637.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6370.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6378.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6383.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6386.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6387.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6392.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6395.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6398.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6399.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_640.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6405.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6428.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6431.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6439.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_644.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6442.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6447.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6450.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6462.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6465.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_647.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6474.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6487.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6518.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6519.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6520.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6521.png: 42 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6526.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6528.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6532.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6534.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6545.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6546.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6558.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6559.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6565.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6568.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6575.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6589.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6590.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6598.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6601.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6622.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6627.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6633.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6636.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6639.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6654.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6669.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6681.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6688.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6691.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6697.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6712.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6717.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6719.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_672.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6728.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6733.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6734.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6742.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6756.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6759.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6764.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6770.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6772.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_678.png: 25 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6781.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6782.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6789.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6805.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6811.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6813.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6821.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6826.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6831.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6836.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6839.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6849.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_686.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6861.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6862.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6864.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6874.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6887.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6892.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6907.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6912.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6919.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_692.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6928.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6935.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6940.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6944.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6945.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6949.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6954.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6958.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_696.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6961.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6962.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6966.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6971.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6980.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6984.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_6989.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7005.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7006.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7009.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7018.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_702.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7021.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7028.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7030.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7036.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7037.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7040.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7041.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7046.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7047.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7060.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7061.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7064.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7067.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7078.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7082.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7102.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7103.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7105.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7110.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7113.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7119.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7124.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7128.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7142.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7143.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7152.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7154.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7162.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7164.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_718.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7181.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7182.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7185.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_719.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7208.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7217.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7218.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7223.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7224.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7233.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7238.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7251.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7253.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7258.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7259.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_726.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7267.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7272.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7274.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7277.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7285.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7294.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_73.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7304.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7312.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7321.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7322.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7333.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7339.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7350.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7353.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7354.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7357.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_736.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7369.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_737.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7377.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7379.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_738.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7389.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7399.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7406.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7407.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7408.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7411.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7423.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7430.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7437.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7441.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7443.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7465.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7468.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7470.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7475.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7476.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7480.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7489.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7490.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7497.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7502.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7510.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7520.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7526.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_753.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7539.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7549.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7562.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7568.png: 24 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7570.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7572.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7578.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7581.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7582.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7608.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7616.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7624.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7642.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7646.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7649.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7663.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7676.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7679.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7680.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7683.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7684.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7686.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7702.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7703.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7704.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7710.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7716.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7718.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7720.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7729.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7739.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7746.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7747.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7748.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7752.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7757.png: 29 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7764.png: 21 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7784.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7788.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7798.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7803.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7812.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7822.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7838.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7839.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_784.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7847.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_785.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7870.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7874.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7878.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_788.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7899.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7912.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_792.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7921.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7922.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7926.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7931.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7937.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7943.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7955.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7960.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7963.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7969.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7973.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7981.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7985.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7987.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7989.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7997.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7998.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_7999.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8007.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8008.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8010.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8017.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8018.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8029.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8037.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8038.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_804.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8048.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8051.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8076.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8085.png: 25 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8088.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8103.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8120.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8121.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8134.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8140.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8141.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8142.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8149.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8157.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8167.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8181.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8191.png: 20 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8192.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8199.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_82.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8200.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8201.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8211.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8216.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8219.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8226.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8227.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_823.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8232.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8233.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8246.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8249.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8254.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_826.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8260.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8276.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8290.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8308.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8312.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8324.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8331.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8339.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_834.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8347.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8353.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8362.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8370.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8378.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8383.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8392.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8406.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_841.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8412.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8413.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8422.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8427.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8433.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8434.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8441.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8445.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_845.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8459.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8466.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8478.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8488.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_850.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8502.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_851.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8524.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8534.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8542.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8544.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8551.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8552.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8555.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8556.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8561.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8565.png: 26 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8567.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_857.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8573.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8574.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8584.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8586.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8592.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8617.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8627.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8629.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8637.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8658.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8659.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8669.png: 24 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8670.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8674.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8675.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8695.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8699.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_87.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8703.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_872.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8721.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8723.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8728.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8735.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8753.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8754.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8766.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8768.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8774.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8777.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8781.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8787.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8792.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8793.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8794.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8795.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8797.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_880.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8801.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8824.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8827.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8837.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8839.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_884.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8843.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8855.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8878.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8884.png: 19 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8906.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8914.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8917.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_892.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8923.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8932.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8940.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8945.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8947.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8949.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8953.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8959.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8968.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8979.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_898.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8984.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8985.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8987.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8989.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8998.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_8999.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_90.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9001.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9008.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9015.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9017.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9019.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9023.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9026.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_903.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9047.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9048.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9051.png: 31 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9053.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9082.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9083.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9096.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9098.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9104.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9105.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9116.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9117.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_912.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9126.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9152.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9172.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9175.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9177.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9180.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9182.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9191.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_92.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9211.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9218.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_923.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9232.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9234.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9246.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9249.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_925.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9256.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_926.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9264.png: 22 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9269.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_927.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9284.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9286.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9289.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9293.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_930.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9303.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9318.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9327.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9331.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9345.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_937.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9379.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9384.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9385.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9386.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9387.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9388.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9394.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9403.png: 10 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9405.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9420.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9421.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9423.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9430.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9434.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9435.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9439.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9443.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9449.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9457.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_946.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9486.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9489.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_949.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9512.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_952.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9522.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9523.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9526.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9530.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_954.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9545.png: 11 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9573.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9579.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9585.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9599.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9605.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9608.png: 7 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_961.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9612.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9619.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9620.png: 18 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9623.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9627.png: 17 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9633.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9635.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9641.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9643.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9650.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9655.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9660.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9662.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9667.png: 15 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9670.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9690.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9714.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9716.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9728.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9730.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9731.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9741.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9749.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9750.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9751.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9771.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9775.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9777.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9778.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9784.png: 16 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9785.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_979.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_98.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9800.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9803.png: 32 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_981.png: 8 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_982.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9825.png: 9 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9827.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9834.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9839.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_985.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9856.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9859.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_986.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9860.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_987.png: 4 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9879.png: 12 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9893.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9899.png: 13 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9911.png: 6 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9915.png: 5 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9917.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9920.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9922.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9937.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9938.png: 14 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9958.png: 36 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9961.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9972.png: 1 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9973.png: 2 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0m/content/datasets/yolo_dataset_dots/images/val/FigureQA_9986.png: 3 duplicate labels removed\n", + "\u001b[34m\u001b[1mval: \u001b[0mNew cache created: /content/datasets/yolo_dataset_dots/labels/val.cache\n", + "\u001b[34m\u001b[1moptimizer:\u001b[0m AdamW(lr=0.001, momentum=0.937) with parameter groups 81 weight(decay=0.0), 88 weight(decay=0.0005), 87 bias(decay=0.0)\n", + "Plotting labels to /content/drive/MyDrive/Spectra_YOLO_Project/dot_line/dot_detector_run/labels.jpg... \n", + "Image sizes 640 train, 640 val\n", + "Using 2 dataloader workers\n", + "Logging results to \u001b[1m/content/drive/MyDrive/Spectra_YOLO_Project/dot_line/dot_detector_run\u001b[0m\n", + "Starting training for 25 epochs...\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 1/25 13.1G 1.384 0.676 0.7638 2700 640: 100% ━━━━━━━━━━━━ 625/625 1.4it/s 7:23\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.3s/it 1:22\n", + " all 4000 211586 0.984 0.942 0.966 0.693\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 2/25 11.9G 1.051 0.4523 0.7468 2711 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:50\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 42.4s\n", + " all 4000 211586 0.976 0.914 0.962 0.758\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 3/25 12.9G 0.9703 0.417 0.7435 2939 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:50\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 42.5s\n", + " all 4000 211586 0.993 0.961 0.974 0.769\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 4/25 13.2G 0.9266 0.3997 0.7413 3468 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:49\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 41.8s\n", + " all 4000 211586 0.978 0.938 0.971 0.761\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 5/25 14G 0.874 0.3788 0.7397 2778 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:51\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 41.3s\n", + " all 4000 211586 0.966 0.943 0.956 0.746\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 6/25 10.8G 0.8636 0.3731 0.7384 2872 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:49\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 42.0s\n", + " all 4000 211586 0.996 0.96 0.974 0.809\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 7/25 11.8G 0.837 0.3615 0.7374 2240 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:46\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 42.2s\n", + " all 4000 211586 0.996 0.961 0.976 0.82\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 8/25 11.2G 0.8183 0.3535 0.7366 2856 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:47\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 40.8s\n", + " all 4000 211586 0.996 0.962 0.978 0.828\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 9/25 10.2G 0.7919 0.345 0.7361 2507 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:49\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.6it/s 40.6s\n", + " all 4000 211586 0.997 0.961 0.977 0.829\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 10/25 13.3G 0.7776 0.3389 0.7352 3483 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:49\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 41.9s\n", + " all 4000 211586 0.997 0.961 0.977 0.846\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 11/25 9.9G 0.7649 0.3337 0.7351 2595 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:52\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.6it/s 40.6s\n", + " all 4000 211586 0.997 0.961 0.975 0.837\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 12/25 7.57G 0.7449 0.3263 0.7353 2966 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:52\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 41.6s\n", + " all 4000 211586 0.998 0.961 0.979 0.858\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 13/25 7.59G 0.7369 0.3221 0.7345 2608 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:52\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.6it/s 40.4s\n", + " all 4000 211586 0.997 0.961 0.978 0.849\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 14/25 7.78G 0.7221 0.3168 0.7348 2558 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:49\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 40.7s\n", + " all 4000 211586 0.997 0.962 0.979 0.853\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 15/25 10.9G 0.7116 0.3114 0.7344 2813 640: 100% ━━━━━━━━━━━━ 625/625 1.5it/s 6:48\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 42.6s\n", + " all 4000 211586 0.997 0.962 0.979 0.861\n", + "Closing dataloader mosaic\n", + "\u001b[34m\u001b[1malbumentations: \u001b[0mBlur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, method='weighted_average', num_output_channels=3), CLAHE(p=0.01, clip_limit=(1.0, 4.0), tile_grid_size=(8, 8))\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 16/25 6.98G 0.6071 0.2886 0.7506 1700 640: 100% ━━━━━━━━━━━━ 625/625 1.6it/s 6:27\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 42.5s\n", + " all 4000 211586 0.997 0.962 0.978 0.844\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 17/25 7.48G 0.5859 0.2802 0.7511 1532 640: 100% ━━━━━━━━━━━━ 625/625 1.6it/s 6:19\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 42.3s\n", + " all 4000 211586 0.998 0.961 0.978 0.864\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 18/25 7.04G 0.5786 0.2747 0.7495 1364 640: 100% ━━━━━━━━━━━━ 625/625 1.6it/s 6:19\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 41.2s\n", + " all 4000 211586 0.998 0.962 0.979 0.869\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 19/25 8.77G 0.5628 0.2674 0.7501 1500 640: 100% ━━━━━━━━━━━━ 625/625 1.7it/s 6:17\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.6it/s 39.4s\n", + " all 4000 211586 0.998 0.96 0.978 0.87\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 20/25 6.67G 0.555 0.2642 0.7494 1623 640: 100% ━━━━━━━━━━━━ 625/625 1.6it/s 6:20\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 42.6s\n", + " all 4000 211586 0.998 0.961 0.978 0.87\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 21/25 8.05G 0.5477 0.26 0.7491 1496 640: 100% ━━━━━━━━━━━━ 625/625 1.6it/s 6:25\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.6it/s 40.3s\n", + " all 4000 211586 0.998 0.962 0.979 0.879\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 22/25 7.02G 0.5386 0.2557 0.7482 1434 640: 100% ━━━━━━━━━━━━ 625/625 1.6it/s 6:23\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 43.0s\n", + " all 4000 211586 0.998 0.962 0.979 0.875\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 23/25 8.38G 0.5316 0.2526 0.7486 1554 640: 100% ━━━━━━━━━━━━ 625/625 1.6it/s 6:21\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 41.6s\n", + " all 4000 211586 0.998 0.961 0.979 0.878\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 24/25 6.84G 0.5239 0.2483 0.7484 1692 640: 100% ━━━━━━━━━━━━ 625/625 1.6it/s 6:21\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.5it/s 43.0s\n", + " all 4000 211586 0.998 0.962 0.979 0.881\n", + "\n", + " Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size\n", + "\u001b[K 25/25 7.52G 0.5212 0.2457 0.7478 1462 640: 100% ━━━━━━━━━━━━ 625/625 1.6it/s 6:19\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.6it/s 39.2s\n", + " all 4000 211586 0.998 0.961 0.979 0.879\n", + "\n", + "25 epochs completed in 3.091 hours.\n", + "Optimizer stripped from /content/drive/MyDrive/Spectra_YOLO_Project/dot_line/dot_detector_run/weights/last.pt, 5.5MB\n", + "Optimizer stripped from /content/drive/MyDrive/Spectra_YOLO_Project/dot_line/dot_detector_run/weights/best.pt, 5.5MB\n", + "\n", + "Validating /content/drive/MyDrive/Spectra_YOLO_Project/dot_line/dot_detector_run/weights/best.pt...\n", + "Ultralytics 8.4.21 🚀 Python-3.12.12 torch-2.10.0+cu128 CUDA:0 (Tesla T4, 14913MiB)\n", + "YOLO11n summary (fused): 101 layers, 2,582,347 parameters, 0 gradients, 6.3 GFLOPs\n", + "\u001b[K Class Images Instances Box(P R mAP50 mAP50-95): 100% ━━━━━━━━━━━━ 63/63 1.3it/s 47.6s\n", + " all 4000 211586 0.998 0.962 0.979 0.881\n", + "Speed: 0.1ms preprocess, 1.6ms inference, 0.0ms loss, 2.0ms postprocess per image\n", + "Results saved to \u001b[1m/content/drive/MyDrive/Spectra_YOLO_Project/dot_line/dot_detector_run\u001b[0m\n", + "✅ Dot Constellation Training Complete! Your weights are safely in Google Drive.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import random\n", + "from ultralytics import YOLO\n", + "\n", + "# 1. Load your newly trained \"Brain\"\n", + "model_path = \"/content/drive/MyDrive/Spectra_YOLO_Project/dot_line/dot_detector_run/weights/best.pt\"\n", + "print(\"🧠 Loading STEM Sight Dot Detector...\")\n", + "dot_model = YOLO(model_path)\n", + "\n", + "# 2. Pick a random test image from the validation set\n", + "val_dir = \"/content/datasets/yolo_dataset_dots/images/val\"\n", + "test_images = [f for f in os.listdir(val_dir) if f.endswith(('.png', '.jpg'))]\n", + "test_image_path = os.path.join(val_dir, random.choice(test_images))\n", + "\n", + "print(f\"🔍 Inspecting: {test_image_path}\")\n", + "\n", + "# 3. Run AI Inference (Find the dots!)\n", + "# We use conf=0.5 to only show dots it is at least 50% confident about\n", + "results = dot_model(test_image_path, conf=0.5)\n", + "\n", + "# 4. Draw and Display the Results\n", + "annotated_img = results[0].plot()\n", + "annotated_img_rgb = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)\n", + "\n", + "plt.figure(figsize=(12, 8))\n", + "plt.imshow(annotated_img_rgb)\n", + "plt.title(\"STEM Sight: AI Dot Constellation Test\")\n", + "plt.axis('off')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 764 + }, + "id": "h4qCvnBsuz9U", + "outputId": "368b80c1-b93c-4830-9e9f-658c9f34826c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Loading STEM Sight Dot Detector...\n", + "🔍 Inspecting: /content/datasets/yolo_dataset_dots/images/val/FigureQA_1790.png\n", + "\n", + "image 1/1 /content/datasets/yolo_dataset_dots/images/val/FigureQA_1790.png: 480x640 85 dots, 50.4ms\n", + "Speed: 2.6ms preprocess, 50.4ms inference, 1.3ms postprocess per image at shape (1, 3, 480, 640)\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "import cv2\n", + "import numpy as np\n", + "import easyocr\n", + "import matplotlib.pyplot as plt\n", + "from ultralytics import YOLO\n", + "import warnings\n", + "import random\n", + "import os\n", + "import re\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "print(\"🧠 Booting up STEM Sight Audio-Optimized Engine...\")\n", + "yolo_dot_model = YOLO(\"/content/drive/MyDrive/Spectra_YOLO_Project/dot_line/dot_detector_run/weights/best.pt\")\n", + "ocr_reader = easyocr.Reader(['en'], gpu=True)\n", + "\n", + "def extract_dot_line_data(image_path):\n", + " print(f\"\\n🚀 Analyzing: {image_path}\")\n", + " print(\"-\" * 40)\n", + "\n", + " img = cv2.imread(image_path)\n", + " img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + " img_h, img_w, _ = img.shape\n", + " failed = False\n", + "\n", + " # --- STEP 1: YOLO DOT DETECTION ---\n", + " results = yolo_dot_model(image_path, conf=0.5, verbose=False)\n", + " boxes = results[0].boxes.xyxy.cpu().numpy()\n", + "\n", + " if len(boxes) == 0:\n", + " print(\"❌ No dots detected.\")\n", + " return None\n", + "\n", + " dots = []\n", + " for box in boxes:\n", + " x1, y1, x2, y2 = box\n", + " cx = (x1 + x2) / 2\n", + " cy = (y1 + y2) / 2\n", + "\n", + " patch = img_rgb[int(cy)-1:int(cy)+2, int(cx)-1:int(cx)+2]\n", + " avg_color = np.median(patch, axis=(0,1))\n", + "\n", + " # 🔥 THE ARTIFACT SLAYER: Ignore white/light-gray background dots\n", + " if avg_color[0] > 200 and avg_color[1] > 200 and avg_color[2] > 200:\n", + " continue\n", + "\n", + " color_group = f\"RGB({int(avg_color[0]//50*50)}, {int(avg_color[1]//50*50)}, {int(avg_color[2]//50*50)})\"\n", + " dots.append({'cx': cx, 'cy': cy, 'color': color_group})\n", + "\n", + " min_dot_x = min(d['cx'] for d in dots) if dots else 0\n", + " max_dot_y = max(d['cy'] for d in dots) if dots else 0\n", + "\n", + " # --- STEP 2: HIGH-CONTRAST OCR (Y-Axis Only Focus) ---\n", + " ocr_results = ocr_reader.readtext(\n", + " image_path,\n", + " mag_ratio=3,\n", + " contrast_ths=0.1,\n", + " adjust_contrast=0.5\n", + " )\n", + "\n", + " y_axis_nums = []\n", + "\n", + " for (bbox, text, prob) in ocr_results:\n", + " tcx = (bbox[0][0] + bbox[1][0]) / 2\n", + " tcy = (bbox[0][1] + bbox[2][1]) / 2\n", + " clean_text = text.lower()\n", + "\n", + " forbidden = [\"axis\", \"label\", \"title\", \"blue\", \"red\", \"green\", \"yellow\", \"purple\", \"orange\", \"pink\", \"brown\", \"black\", \"white\", \"gray\", \"cyan\", \"magenta\", \"dodger\"]\n", + " if any(word in clean_text for word in forbidden): continue\n", + "\n", + " numbers_found = re.findall(r\"[-+]?\\d*\\.\\d+|\\d+\", text)\n", + "\n", + " # We only care about establishing the Y-scale math\n", + " if tcx < min_dot_x + 15 and numbers_found:\n", + " y_axis_nums.append({'val': float(numbers_found[0]), 'x': tcx, 'y': tcy})\n", + "\n", + " # --- STEP 3: Y-AXIS SCALE MATH ---\n", + " y_axis_nums = sorted(y_axis_nums, key=lambda d: d['y'], reverse=True)\n", + " unique_y = []\n", + " for y in y_axis_nums:\n", + " if not unique_y or abs(unique_y[-1]['val'] - y['val']) > 0:\n", + " unique_y.append(y)\n", + "\n", + " if len(unique_y) >= 2:\n", + " base_y = unique_y[0]['y']\n", + " base_val = unique_y[0]['val']\n", + " top_y = unique_y[-1]['y']\n", + " top_val = unique_y[-1]['val']\n", + "\n", + " pixel_diff = abs(top_y - base_y)\n", + " units_per_pixel = abs(top_val - base_val) / pixel_diff if pixel_diff > 5 else 0\n", + " else:\n", + " print(\"❌ OCR failed to find Y-Axis bounds.\")\n", + " return None\n", + "\n", + " # --- STEP 4: INDEPENDENT LINE SORTING (AUDIO OPTIMIZED) ---\n", + " extracted_data = {}\n", + "\n", + " # First, group all dots by their physical color\n", + " for dot in dots:\n", + " pixel_height = base_y - dot['cy']\n", + " real_value = base_val + (pixel_height * units_per_pixel)\n", + "\n", + " line_name = dot['color']\n", + " if line_name not in extracted_data: extracted_data[line_name] = []\n", + " # Store the X-pixel so we can sort them later\n", + " extracted_data[line_name].append({'cx': dot['cx'], 'y_val': round(real_value, 2)})\n", + "\n", + " # Now, process each line independently\n", + " final_audio_sequence = {}\n", + " print(\"✅ Extraction Complete! (Ready for Audio Engine)\")\n", + "\n", + " for line_color, points in extracted_data.items():\n", + " print(f\"\\n🔵 Line: {line_color}\")\n", + " final_audio_sequence[line_color] = []\n", + "\n", + " # Sort this specific line's dots perfectly from left to right\n", + " sorted_points = sorted(points, key=lambda p: p['cx'])\n", + "\n", + " for i, point in enumerate(sorted_points):\n", + " category = f\"Point_{i+1}\"\n", + " val = point['y_val']\n", + " final_audio_sequence[line_color].append((category, val))\n", + " print(f\" {category}: {val}\")\n", + "\n", + " # --- DRAW THE IMAGE ---\n", + " plt.figure(figsize=(10, 8))\n", + " for dot in dots:\n", + " cv2.circle(img_rgb, (int(dot['cx']), int(dot['cy'])), 8, (255, 0, 0), 3)\n", + " plt.imshow(img_rgb)\n", + " plt.title(\"STEM Sight: Audio-Optimized Extraction\")\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " return final_audio_sequence\n", + "\n", + "# Run it on that exact same broken image!\n", + "test_image = \"/content/datasets/yolo_dataset_dots/images/val/FigureQA_5645.png\"\n", + "if os.path.exists(test_image):\n", + " final_output = extract_dot_line_data(test_image)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "3rqU3z3XvLZ1", + "outputId": "f7a3609a-946d-46d7-9744-e4f154aa1f21" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "🧠 Booting up STEM Sight Audio-Optimized Engine...\n", + "\n", + "🚀 Analyzing: /content/datasets/yolo_dataset_dots/images/val/FigureQA_5645.png\n", + "----------------------------------------\n", + "✅ Extraction Complete! (Ready for Audio Engine)\n", + "\n", + "🔵 Line: RGB(100, 0, 0)\n", + " Point_1: 9.28\n", + " Point_2: 9.23\n", + " Point_3: 9.15\n", + " Point_4: 9.08\n", + " Point_5: 9.03\n", + " Point_6: 8.92\n", + " Point_7: 8.87\n", + " Point_8: 8.82\n", + " Point_9: 8.72\n", + "\n", + "🔵 Line: RGB(150, 200, 50)\n", + " Point_1: 0.38\n", + " Point_2: 0.47\n", + " Point_3: 0.52\n", + " Point_4: 0.52\n", + " Point_5: 0.47\n", + " Point_6: 0.37\n", + " Point_7: 0.22\n", + " Point_8: 0.01\n", + " Point_9: -0.9\n", + " Point_10: -1.3\n", + " Point_11: -1.76\n", + "\n", + "🔵 Line: RGB(200, 100, 200)\n", + " Point_1: -2.62\n", + " Point_2: -2.08\n", + " Point_3: -1.51\n", + " Point_4: -0.95\n", + " Point_5: 0.12\n", + " Point_6: 0.68\n", + " Point_7: 1.23\n", + "\n", + "🔵 Line: RGB(0, 250, 0)\n", + " Point_1: -3.92\n", + " Point_2: -3.38\n", + " Point_3: -3.08\n", + " Point_4: -3.12\n", + " Point_5: -3.48\n", + " Point_6: -4.09\n", + " Point_7: -4.9\n", + " Point_8: -5.41\n", + "\n", + "🔵 Line: RGB(150, 150, 150)\n", + " Point_1: -4.66\n", + " Point_2: -3.47\n", + " Point_3: -2.52\n", + " Point_4: -1.86\n", + " Point_5: -1.5\n", + " Point_6: -1.45\n", + " Point_7: -2.21\n", + " Point_8: -3.03\n", + " Point_9: 8.65\n", + " Point_10: -4.14\n", + " Point_11: -5.4\n", + " Point_12: -5.41\n", + " Point_13: -5.4\n", + "\n", + "🔵 Line: RGB(0, 250, 150)\n", + " Point_1: -5.4\n", + " Point_2: -4.94\n", + " Point_3: -4.27\n", + " Point_4: -4.08\n", + " Point_5: -3.74\n", + " Point_6: -3.64\n", + " Point_7: -3.17\n", + " Point_8: -2.98\n", + " Point_9: -2.06\n", + " Point_10: -1.66\n", + " Point_11: -0.64\n", + " Point_12: -0.28\n", + " Point_13: -0.34\n", + " Point_14: -0.54\n", + " Point_15: 1.58\n", + " Point_16: 1.28\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file