diff --git a/.dockerignore b/.dockerignore index 184623a..4c00337 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,17 +1,50 @@ -.git -.vscode -.venv-sdr +# Default-deny: include only files required by Docker images. +* + +!.dockerignore +!deploy/ +!deploy/docker/ +!deploy/docker/** +!deploy/requirements/ +!deploy/requirements/** +!src/ +!src/** +!common/ +!common/** +!NN_server/ +!NN_server/** +!telemetry/ +!telemetry/** +!torchsig/ +!torchsig/** + +# Drop heavy or host-only artifacts even if their parent directory is included. +.git/ +.vscode/ +.venv*/ __pycache__/ *.pyc *.pyo - -# Heavy host-only SDR sources +*.tar +*.tar.gz +*.tgz +*.zip +*.iq +logs/ +runtime/ +train_scripts/ +scripts_nn/ +orange_scripts/ +signal/ gnuradio/ gr-osmosdr/ gr-osmosdr-0.2.6/ - -# Local runtime artifacts -NN_server/result/ - -# Legacy install artifacts not needed in docker image install_scripts/ +NN_server/NN/ +NN_server/result/ +NN_server/__pycache__/ +src/__pycache__/ +common/__pycache__/ +telemetry/__pycache__/ +torchsig/__pycache__/ +torchsig/docs/ diff --git a/.gitignore b/.gitignore index 20ca32f..d707a11 100644 --- a/.gitignore +++ b/.gitignore @@ -185,6 +185,8 @@ cython_debug/ *.png /logs/*.log +logs/nn_results_*.csv +logs/nn_results_*.jsonl runtime/ /.venv-*/* @@ -194,4 +196,6 @@ runtime/ NN_server/server.py.bak_streak_gate *.npy -train_scripts/models/ensemble*/ \ No newline at end of file +train_scripts/models/ensemble*/ + +.codex \ No newline at end of file diff --git a/NN_server/Model.py b/NN_server/Model.py index 776a658..9acdd00 100644 --- a/NN_server/Model.py +++ b/NN_server/Model.py @@ -154,18 +154,22 @@ class Model(object): except Exception as exc: print(str(exc)) - def _prepare_data(self, data=None): + def _prepare_data(self, data=None, ind_inference=None): try: + if ind_inference is None: + ind_inference = Model.get_ind_inference() print('Подготовка данных' + self._shablon) - self._data = self._pre_func(data, src=self._src_result, ind_inference=Model.get_ind_inference()) + self._data = self._pre_func(data, src=self._src_result, ind_inference=ind_inference) except Exception as exc: print(str(exc)) - def _post_data(self, prediction=None): + def _post_data(self, prediction=None, ind_inference=None): + if ind_inference is None: + ind_inference = Model.get_ind_inference() print('Постобработка данных' + self._shablon) self._ind_inference += 1 self._post_func(src=self._src_result, data=self._data, model_id=self._model_id, model_type=self._type_model, - ind_inference=Model.get_ind_inference(), prediction=prediction) + ind_inference=ind_inference, prediction=prediction) def get_test_inference(self): try: @@ -248,22 +252,25 @@ class Model(object): except Exception as exc: print(str(exc)) - def get_inference(self, data=None): + def get_inference(self, data=None, ind_inference=None): try: - return self._inference(data=data) + return self._inference(data=data, ind_inference=ind_inference) except Exception as exc: print(str(exc)) return None - def _inference(self, data=None): + def _inference(self, data=None, ind_inference=None): try: - Model._add_in_result_list(type_model=self._type_model, ind_inference=self.get_ind_inference(), list_to_add=[]) - self._prepare_data(data=data) + if ind_inference is None: + ind_inference = Model.get_ind_inference() + Model._add_in_result_list(type_model=self._type_model, ind_inference=ind_inference, list_to_add=[]) + self._prepare_data(data=data, ind_inference=ind_inference) print('Инференс' + self._shablon) prediction, probability = self._inference_func(data=self._data, model=self._model, mapping=self._classes, shablon=self._shablon) - Model._add_in_result_list(type_model=self._type_model, ind_inference=self.get_ind_inference(), list_to_add=[prediction, probability]) - self._post_data(prediction=prediction) + print('RESULT' + self._shablon + ': ' + str(prediction) + ' (probability=' + str(probability) + ')') + Model._add_in_result_list(type_model=self._type_model, ind_inference=ind_inference, list_to_add=[prediction, probability]) + self._post_data(prediction=prediction, ind_inference=ind_inference) gc.collect() return prediction, probability diff --git a/NN_server/Models/ensemble_1200_v44.py b/NN_server/Models/ensemble_1200_v44.py index d805a4f..aa1b561 100644 --- a/NN_server/Models/ensemble_1200_v44.py +++ b/NN_server/Models/ensemble_1200_v44.py @@ -6,9 +6,11 @@ import torch import cv2 import gc import io +import os +import re -def _render_plot(values, figsize=(16, 16), dpi=16): +def _render_signal_channel(values, figsize=(16, 16), dpi=16, resize=(256, 256)): import matplotlib.pyplot as plt fig = plt.figure(figsize=figsize) @@ -28,6 +30,34 @@ def _render_plot(values, figsize=(16, 16), dpi=16): if img is None: raise RuntimeError("failed to decode plot image") + img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) + if resize is not None: + img = cv2.resize(img, resize) + + plt.clf() + plt.cla() + plt.close() + plt.close(fig) + + return img + + +def _render_training_png(image): + import matplotlib.pyplot as plt + + fig = plt.figure() + plt.imshow(image) + + buf = io.BytesIO() + fig.savefig(buf, format="png") + buf.seek(0) + img_arr = np.frombuffer(buf.getvalue(), dtype=np.uint8) + buf.close() + + img = cv2.imdecode(img_arr, 1) + if img is None: + raise RuntimeError("failed to decode training-style image") + plt.clf() plt.cla() plt.close() @@ -36,6 +66,42 @@ def _render_plot(values, figsize=(16, 16), dpi=16): return np.asarray(cv2.split(img), dtype=np.float32) +def _prune_old_inference_images(src, model_type, model_id, keep_last=200): + try: + keep_last = int(os.getenv("INFERENCE_IMAGE_KEEP_LAST", str(keep_last))) + except ValueError: + keep_last = keep_last + + if keep_last <= 0 or not src or not os.path.isdir(src): + return + + pattern = re.compile( + r"_inference_(\d+)_.*_" + + re.escape(str(model_id)) + + "_" + + re.escape(str(model_type)) + + r"\.png$" + ) + grouped = {} + for name in os.listdir(src): + match = pattern.match(name) + if match is None: + continue + grouped.setdefault(int(match.group(1)), []).append(name) + + if len(grouped) <= keep_last: + return + + for old_result_id in sorted(grouped)[: len(grouped) - keep_last]: + for name in grouped[old_result_id]: + try: + os.remove(os.path.join(src, name)) + except FileNotFoundError: + pass + except OSError as exc: + print(f"failed to remove old inference image {name}: {exc}") + + def pre_func_ensemble(data=None, src="", ind_inference=0): try: import matplotlib.pyplot as plt @@ -47,8 +113,8 @@ def pre_func_ensemble(data=None, src="", ind_inference=0): imag = np.asarray(data[1], dtype=np.float32) signal = real + 1j * imag - img_real = _render_plot(signal.real) - img_mag = _render_plot(np.abs(signal)) + img_real = _render_training_png(_render_signal_channel(signal.real)) + img_mag = _render_training_png(_render_signal_channel(np.abs(signal))) cv2.destroyAllWindows() gc.collect() @@ -164,7 +230,7 @@ def post_func_ensemble(src="", model_type="", prediction="", model_id=0, ind_inf matplotlib.use("Agg") plt.ioff() - if int(ind_inference) <= 100 and isinstance(data, (list, tuple)) and len(data) >= 2: + if isinstance(data, (list, tuple)) and len(data) >= 2: fig, ax = plt.subplots() ax.imshow(np.moveaxis(data[0], 0, -1)) plt.savefig(src + "_inference_" + str(ind_inference) + "_" + prediction + "_real_" + str(model_id) + "_" + model_type + ".png") @@ -183,6 +249,8 @@ def post_func_ensemble(src="", model_type="", prediction="", model_id=0, ind_inf cv2.destroyAllWindows() gc.collect() + _prune_old_inference_images(src, model_type, model_id) + plt.clf() plt.cla() plt.close() diff --git a/NN_server/Models/ensemble_2400_v44.py b/NN_server/Models/ensemble_2400_v44.py index d805a4f..aa1b561 100644 --- a/NN_server/Models/ensemble_2400_v44.py +++ b/NN_server/Models/ensemble_2400_v44.py @@ -6,9 +6,11 @@ import torch import cv2 import gc import io +import os +import re -def _render_plot(values, figsize=(16, 16), dpi=16): +def _render_signal_channel(values, figsize=(16, 16), dpi=16, resize=(256, 256)): import matplotlib.pyplot as plt fig = plt.figure(figsize=figsize) @@ -28,6 +30,34 @@ def _render_plot(values, figsize=(16, 16), dpi=16): if img is None: raise RuntimeError("failed to decode plot image") + img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) + if resize is not None: + img = cv2.resize(img, resize) + + plt.clf() + plt.cla() + plt.close() + plt.close(fig) + + return img + + +def _render_training_png(image): + import matplotlib.pyplot as plt + + fig = plt.figure() + plt.imshow(image) + + buf = io.BytesIO() + fig.savefig(buf, format="png") + buf.seek(0) + img_arr = np.frombuffer(buf.getvalue(), dtype=np.uint8) + buf.close() + + img = cv2.imdecode(img_arr, 1) + if img is None: + raise RuntimeError("failed to decode training-style image") + plt.clf() plt.cla() plt.close() @@ -36,6 +66,42 @@ def _render_plot(values, figsize=(16, 16), dpi=16): return np.asarray(cv2.split(img), dtype=np.float32) +def _prune_old_inference_images(src, model_type, model_id, keep_last=200): + try: + keep_last = int(os.getenv("INFERENCE_IMAGE_KEEP_LAST", str(keep_last))) + except ValueError: + keep_last = keep_last + + if keep_last <= 0 or not src or not os.path.isdir(src): + return + + pattern = re.compile( + r"_inference_(\d+)_.*_" + + re.escape(str(model_id)) + + "_" + + re.escape(str(model_type)) + + r"\.png$" + ) + grouped = {} + for name in os.listdir(src): + match = pattern.match(name) + if match is None: + continue + grouped.setdefault(int(match.group(1)), []).append(name) + + if len(grouped) <= keep_last: + return + + for old_result_id in sorted(grouped)[: len(grouped) - keep_last]: + for name in grouped[old_result_id]: + try: + os.remove(os.path.join(src, name)) + except FileNotFoundError: + pass + except OSError as exc: + print(f"failed to remove old inference image {name}: {exc}") + + def pre_func_ensemble(data=None, src="", ind_inference=0): try: import matplotlib.pyplot as plt @@ -47,8 +113,8 @@ def pre_func_ensemble(data=None, src="", ind_inference=0): imag = np.asarray(data[1], dtype=np.float32) signal = real + 1j * imag - img_real = _render_plot(signal.real) - img_mag = _render_plot(np.abs(signal)) + img_real = _render_training_png(_render_signal_channel(signal.real)) + img_mag = _render_training_png(_render_signal_channel(np.abs(signal))) cv2.destroyAllWindows() gc.collect() @@ -164,7 +230,7 @@ def post_func_ensemble(src="", model_type="", prediction="", model_id=0, ind_inf matplotlib.use("Agg") plt.ioff() - if int(ind_inference) <= 100 and isinstance(data, (list, tuple)) and len(data) >= 2: + if isinstance(data, (list, tuple)) and len(data) >= 2: fig, ax = plt.subplots() ax.imshow(np.moveaxis(data[0], 0, -1)) plt.savefig(src + "_inference_" + str(ind_inference) + "_" + prediction + "_real_" + str(model_id) + "_" + model_type + ".png") @@ -183,6 +249,8 @@ def post_func_ensemble(src="", model_type="", prediction="", model_id=0, ind_inf cv2.destroyAllWindows() gc.collect() + _prune_old_inference_images(src, model_type, model_id) + plt.clf() plt.cla() plt.close() diff --git a/NN_server/server.py b/NN_server/server.py index 54ab334..bcbbf67 100644 --- a/NN_server/server.py +++ b/NN_server/server.py @@ -20,6 +20,8 @@ import shutil import json import gc import logging +import time +import re from pathlib import Path TORCHSIG_PATH = "/app/torchsig" @@ -34,6 +36,7 @@ loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) queue = asyncio.Queue() semaphore = asyncio.Semaphore(3) +receive_data_lock = threading.Lock() prediction_list = [] result_msg = {} @@ -91,11 +94,82 @@ def update_drone_streak(freq, prediction): if not config: raise RuntimeError("[NN_server/server.py] .env was loaded but no keys were parsed") +MODEL_ENV_RE = re.compile(r"^NN_\d+$") + +if not any(MODEL_ENV_RE.match(key) for key in config): + raise RuntimeError("[NN_server/server.py] no NN_* model entries configured") logging.info("NN config loaded from %s", ROOT_ENV) if RUNTIME_ENV.exists(): logging.info("NN runtime overrides loaded from %s", RUNTIME_ENV) gen_server_ip = config['GENERAL_SERVER_IP'] gen_server_port = config['GENERAL_SERVER_PORT'] +INFERENCE_TELEMETRY_HOST = os.getenv('telemetry_host', '127.0.0.1') +INFERENCE_TELEMETRY_PORT = os.getenv('telemetry_port', '5020') +INFERENCE_TELEMETRY_ENDPOINT = os.getenv('telemetry_inference_endpoint', 'inference/result') +INFERENCE_TELEMETRY_TIMEOUT_SEC = float(os.getenv('telemetry_inference_timeout_sec', '0.30')) +INFERENCE_IMAGE_RE = re.compile(r"_inference_(\d+)_") + + +def get_result_dir(): + return config.get('SRC_RESULT', '') + + +def collect_inference_images(result_id, model_name=''): + result_dir = get_result_dir() + if not result_dir or not os.path.isdir(result_dir): + return result_id, [] + + needle = f"_inference_{result_id}_" + model_suffix = f"_{model_name}.png" if model_name else '' + exact_images = [] + grouped_images = {} + + for name in sorted(os.listdir(result_dir)): + if not name.endswith('.png'): + continue + if model_suffix and not name.endswith(model_suffix): + continue + match = INFERENCE_IMAGE_RE.search(name) + if match is None: + continue + + image_result_id = int(match.group(1)) + grouped_images.setdefault(image_result_id, []).append(name) + if image_result_id == result_id and needle in name: + exact_images.append(name) + + if exact_images: + return result_id, exact_images + return result_id, [] + + +def send_inference_result(payload): + try: + requests.post( + "http://{0}:{1}/{2}".format( + INFERENCE_TELEMETRY_HOST, + INFERENCE_TELEMETRY_PORT, + INFERENCE_TELEMETRY_ENDPOINT.lstrip('/'), + ), + json=payload, + timeout=INFERENCE_TELEMETRY_TIMEOUT_SEC, + ) + except Exception as exc: + print(str(exc)) + + +def reset_directory_contents(path): + os.makedirs(path, exist_ok=True) + for name in os.listdir(path): + full_path = os.path.join(path, name) + try: + if os.path.isdir(full_path) and not os.path.islink(full_path): + shutil.rmtree(full_path) + else: + os.remove(full_path) + except FileNotFoundError: + continue + requested_profile = normalize_profile_name(config.get("NN_ACTIVE_PROFILE")) active_profile = resolve_active_profile({k: v for k, v in config.items() if k != "NN_SCHEDULE"}) if requested_profile != active_profile: @@ -109,18 +183,37 @@ drone_streaks = {} def init_data_for_inference(): try: - if os.path.isdir(config['SRC_RESULT']): - shutil.rmtree(config['SRC_RESULT']) - os.mkdir(config['SRC_RESULT']) - if os.path.isdir(config['SRC_EXAMPLE']): - shutil.rmtree(config['SRC_EXAMPLE']) - os.mkdir(config['SRC_EXAMPLE']) + reset_directory_contents(config['SRC_RESULT']) + reset_directory_contents(config['SRC_EXAMPLE']) except Exception as exc: print(str(exc)) print() try: global model_list + for key in config.keys(): + if MODEL_ENV_RE.match(key): + params = config[key].split(' && ') + module = importlib.import_module('Models.' + params[4]) + classes = {} + for value in params[9][1:-1].split(','): + classes[len(classes)] = value + model = Model(file_model=params[0], file_config=params[1], src_example=params[2], src_result=params[3], + type_model=params[4], build_model_func=getattr(module, params[5]), + pre_func=getattr(module, params[6]), inference_func=getattr(module, params[7]), + post_func=getattr(module, params[8]), classes=classes, number_synthetic_examples=int(params[10]), + number_src_data_for_one_synthetic_example=int(params[11]), path_to_src_dataset=params[12]) + model_list.append(model) + # if key.startswith('ALG_'): + # params = config[key].split(' && ') + # module = importlib.import_module('Algorithms.' + params[2]) + # classes = {} + # for value in params[6][1:-1].split(','): + # classes[len(classes)] = value + # alg = Algorithm(src_example=params[0], src_result=params[1], type_alg=params[2], pre_func=getattr(module, params[3]), + # inference_func=getattr(module, params[4]), post_func=getattr(module, params[5]), classes=classes, + # number_synthetic_examples=int(params[7]), number_src_data_for_one_synthetic_example=int(params[8]), path_to_src_dataset=params[9]) + # alg_list.append(alg) model_list = [] loaded_model_keys = [] model_entries = get_profile_model_entries(config, active_profile) @@ -162,11 +255,19 @@ def run_example(): @app.route('/receive_data', methods=['POST']) def receive_data(): + with receive_data_lock: + return _receive_data_locked() + + +def _receive_data_locked(): try: print() - data = json.loads(request.json) + data = request.json + if isinstance(data, str): + data = json.loads(data) print('#' * 100) print('Получен пакет ' + str(Model.get_ind_inference())) + result_id = Model.get_ind_inference() freq = int(data['freq']) print('Частота: ' + str(freq)) # print('Канал: ' + str(data['channel'])) @@ -182,23 +283,49 @@ def receive_data(): print('-' * 100) print(str(model)) result_msg[str(model.get_model_name())] = {'freq': freq} - prediction, probability = model.get_inference([np.asarray(data['data_real'], dtype=np.float32), np.asarray(data['data_imag'], dtype=np.float32)]) + prediction, probability = model.get_inference([np.asarray(data['data_real'], dtype=np.float32), np.asarray(data['data_imag'], dtype=np.float32)], ind_inference=result_id) result_msg[str(model.get_model_name())]['prediction'] = prediction result_msg[str(model.get_model_name())]['probability'] = str(probability) prediction_list.append(prediction) + image_result_id, images = collect_inference_images(result_id, model.get_model_name()) + send_inference_result({ + 'result_id': image_result_id, + 'ts': time.time(), + 'freq': str(freq), + 'model': model.get_model_name(), + 'prediction': prediction, + 'probability': float(probability), + 'drone_probability': float(probability) if prediction == 'drone' else 0.0, + 'drone_threshold': None, + 'images': images, + }) print('-' * 100) print() try: - result = update_drone_streak(freq, prediction_list[0]) - if str(freq)==2400: - result=0 - data_to_send={ - 'freq': str(freq), - 'amplitude': result - #'triggered': False if result < 7 else True, - #'light_len': result - } + + result = 0 + freq_int = int(freq) + prediction = prediction_list[0] + prob = float(probability) + + if freq_int == 2400: + if prediction in ["drone", "drone_noise"]: + result += 0 + elif prediction == "wifi" and prob >= 0.95: + result += 0 + + elif freq_int == 1200: + if prediction == "drone" and prob >= 0.95: + result += 0 + + elif freq_int == 915: + result = 0 + + data_to_send = { + "freq": str(freq), + "amplitude": result, + } response = requests.post("http://{0}:{1}/process_data".format(gen_server_ip, gen_server_port), json=data_to_send) if response.status_code == 200: print("Данные успешно отправлены!") diff --git a/README.md b/README.md index 45c08b7..2c42ea8 100644 --- a/README.md +++ b/README.md @@ -256,3 +256,12 @@ sudo hackrf_spiflash -w hackrf_one_usb.bin ``` ./.venv-sdr/bin/python scripts_nn/data_saver_headless.py --serial 000 --freq 4500000000 --save-dir /home/sibscience-4/Dataset/3300 --file-tag DJI_3_ --samp-rate 20000000 --split-size 400000 --delay 0.1 --rf-gain 12 --if-gain 30 --bb-gain 36 + +### Парсинг логов +``` bash +.venv-train/bin/python scripts/capture_nn_results.py \ + --output logs/nn_results_live_6gb.csv \ + --format csv \ + --max-bytes 6442450944 \ + --tail 0 +``` diff --git a/capture_hourly.sh b/capture_hourly.sh index b1d1e81..49f1cf5 100755 --- a/capture_hourly.sh +++ b/capture_hourly.sh @@ -10,7 +10,7 @@ cd "$SCRIPT_DIR" # НАСТРОЙКИ ############################ -BASE_DIR="${BASE_DIR:-/mnt/nvme1/dataset_5_5_26}" +BASE_DIR="/mnt/data/dataset_6_5_26" PYTHON_BIN="${PYTHON_BIN:-$SCRIPT_DIR/.venv-sdr/bin/python}" SCRIPT_PATH="${SCRIPT_PATH:-$SCRIPT_DIR/scripts_nn/data_saver_headless.py}" @@ -28,22 +28,22 @@ STOPPED_SERVICE_UNIT="" # Лимиты PER_FREQ_LIMIT_GIB="${PER_FREQ_LIMIT_GIB:-12}" -TOTAL_LIMIT_GIB="${TOTAL_LIMIT_GIB:-380}" +TOTAL_LIMIT_GIB="${TOTAL_LIMIT_GIB:-266}" PER_FREQ_LIMIT_BYTES=$((PER_FREQ_LIMIT_GIB * 1024 * 1024 * 1024)) TOTAL_LIMIT_BYTES=$((TOTAL_LIMIT_GIB * 1024 * 1024 * 1024)) # Для обычного hourly можно поставить 3600. # Для RUN_ONCE это почти не важно. -CYCLE_SECONDS="${CYCLE_SECONDS:-100}" +CYCLE_SECONDS="${CYCLE_SECONDS:-1}" # Параметры SDR SAMP_RATE="${SAMP_RATE:-20e6}" SPLIT_SIZE="${SPLIT_SIZE:-400000}" -DELAY="${DELAY:-0.15}" +DELAY="${DELAY:-0.25}" RF_GAIN="${RF_GAIN:-12}" -IF_GAIN="${IF_GAIN:-30}" -BB_GAIN="${BB_GAIN:-36}" +IF_GAIN="${IF_GAIN:-12}" +BB_GAIN="${BB_GAIN:-0}" ############################ # MOCK SENDER @@ -335,7 +335,7 @@ on_signal() { # ЧАСТОТЫ И SERIAL ############################ -ORDER=(1200 2400 5200 5800) +ORDER=(2400) declare -A SERIAL declare -A FREQ_HZ diff --git a/deploy/docker/docker-compose.yml b/deploy/docker/docker-compose.yml index 65298c8..096a326 100644 --- a/deploy/docker/docker-compose.yml +++ b/deploy/docker/docker-compose.yml @@ -20,6 +20,7 @@ services: - ../../runtime:/app/runtime - ../../src:/app/src - ../../common:/app/common + - ../../train_scripts:/app/train_scripts:ro networks: - dronedetector-net extra_hosts: @@ -36,6 +37,7 @@ services: environment: - PYTHONPATH=/app:/app/NN_server - NN_HOT_RELOAD=${NN_HOT_RELOAD:-1} + - telemetry_host=dronedetector-telemetry-server working_dir: /app/NN_server command: - sh @@ -76,6 +78,7 @@ services: - ../../.env:/app/.env:ro - ../../telemetry:/app/telemetry - ../../common:/app/common + - ../../NN_server/result:/app/inference_result:ro networks: - dronedetector-net diff --git a/logs/analysis.ipynb b/logs/analysis.ipynb new file mode 100644 index 0000000..a28f089 --- /dev/null +++ b/logs/analysis.ipynb @@ -0,0 +1,673 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "215a6c3a", + "metadata": {}, + "source": [ + "# NN inference analysis\n", + "\n", + "Анализ CSV с результатами инференса: доля класса `drone`, частоты срабатываний, уверенность модели и интервалы между `drone`-классификациями." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "4e8cff32", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CSV path: /home/sibscience-4/from_ssh/DroneDetector/logs/nn_results_live_6gb.csv\n", + "Rows: 27258\n", + "Time range: 2026-05-04 17:35:21.019627763+07:00 -> 2026-05-05 12:17:19.369858371+07:00\n", + "Missing freq rows: 0\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
docker_timestampevent_time_isoevent_time_epochfreqmodel_idmodel_typepredictionprobabilitytslocal_time
02026-05-04T10:35:21.019627763Z2026-05-04T17:35:21+07:001.777891e+0924002ensemble_2400_v44drone0.992026-05-04 10:35:21.019627763+00:002026-05-04 17:35:21.019627763+07:00
12026-05-04T10:35:21.019631281Z2026-05-04T17:35:21+07:001.777891e+0912001ensemble_1200_v44noise1.002026-05-04 10:35:21.019631281+00:002026-05-04 17:35:21.019631281+07:00
22026-05-04T10:35:27.048188525Z2026-05-04T17:35:27+07:001.777891e+0924002ensemble_2400_v44drone0.992026-05-04 10:35:27.048188525+00:002026-05-04 17:35:27.048188525+07:00
32026-05-04T10:35:29.238925690Z2026-05-04T17:35:29+07:001.777891e+0912001ensemble_1200_v44noise1.002026-05-04 10:35:29.238925690+00:002026-05-04 17:35:29.238925690+07:00
42026-05-04T10:35:32.842234116Z2026-05-04T17:35:32+07:001.777891e+0924002ensemble_2400_v44drone0.922026-05-04 10:35:32.842234116+00:002026-05-04 17:35:32.842234116+07:00
\n", + "
" + ], + "text/plain": [ + " docker_timestamp event_time_iso \\\n", + "0 2026-05-04T10:35:21.019627763Z 2026-05-04T17:35:21+07:00 \n", + "1 2026-05-04T10:35:21.019631281Z 2026-05-04T17:35:21+07:00 \n", + "2 2026-05-04T10:35:27.048188525Z 2026-05-04T17:35:27+07:00 \n", + "3 2026-05-04T10:35:29.238925690Z 2026-05-04T17:35:29+07:00 \n", + "4 2026-05-04T10:35:32.842234116Z 2026-05-04T17:35:32+07:00 \n", + "\n", + " event_time_epoch freq model_id model_type prediction \\\n", + "0 1.777891e+09 2400 2 ensemble_2400_v44 drone \n", + "1 1.777891e+09 1200 1 ensemble_1200_v44 noise \n", + "2 1.777891e+09 2400 2 ensemble_2400_v44 drone \n", + "3 1.777891e+09 1200 1 ensemble_1200_v44 noise \n", + "4 1.777891e+09 2400 2 ensemble_2400_v44 drone \n", + "\n", + " probability ts \\\n", + "0 0.99 2026-05-04 10:35:21.019627763+00:00 \n", + "1 1.00 2026-05-04 10:35:21.019631281+00:00 \n", + "2 0.99 2026-05-04 10:35:27.048188525+00:00 \n", + "3 1.00 2026-05-04 10:35:29.238925690+00:00 \n", + "4 0.92 2026-05-04 10:35:32.842234116+00:00 \n", + "\n", + " local_time \n", + "0 2026-05-04 17:35:21.019627763+07:00 \n", + "1 2026-05-04 17:35:21.019631281+07:00 \n", + "2 2026-05-04 17:35:27.048188525+07:00 \n", + "3 2026-05-04 17:35:29.238925690+07:00 \n", + "4 2026-05-04 17:35:32.842234116+07:00 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "import pandas as pd\n", + "\n", + "csv_path = Path('/home/sibscience-4/from_ssh/DroneDetector/logs/nn_results_live_6gb.csv')\n", + "df = pd.read_csv(csv_path)\n", + "\n", + "df['ts'] = pd.to_datetime(df['docker_timestamp'], utc=True)\n", + "df['local_time'] = df['ts'].dt.tz_convert('Asia/Novosibirsk')\n", + "df['freq'] = pd.to_numeric(df['freq'], errors='coerce').astype('Int64')\n", + "df['probability'] = pd.to_numeric(df['probability'], errors='coerce')\n", + "df = df.sort_values('ts').reset_index(drop=True)\n", + "\n", + "print(f'CSV path: {csv_path}')\n", + "print(f'Rows: {len(df)}')\n", + "print(f'Time range: {df[\"local_time\"].min()} -> {df[\"local_time\"].max()}')\n", + "print(f'Missing freq rows: {df[\"freq\"].isna().sum()}')\n", + "display(df.head())" + ] + }, + { + "cell_type": "markdown", + "id": "0fcc6dd6", + "metadata": {}, + "source": [ + "## Общая сводка по частотам и классам" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "7bf0fc3f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
freqpredictioncountavg_probabilitymin_probabilitymax_probabilityfreq_totalclass_rate
01200drone30.8400000.780.91136320.000220
11200noise136290.9974360.911.00136320.999780
22400drone119210.8680130.501.00136260.874872
32400noise17050.6491850.501.00136260.125128
\n", + "
" + ], + "text/plain": [ + " freq prediction count avg_probability min_probability max_probability \\\n", + "0 1200 drone 3 0.840000 0.78 0.91 \n", + "1 1200 noise 13629 0.997436 0.91 1.00 \n", + "2 2400 drone 11921 0.868013 0.50 1.00 \n", + "3 2400 noise 1705 0.649185 0.50 1.00 \n", + "\n", + " freq_total class_rate \n", + "0 13632 0.000220 \n", + "1 13632 0.999780 \n", + "2 13626 0.874872 \n", + "3 13626 0.125128 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "class_summary = (\n", + " df.groupby(['freq', 'prediction'], dropna=False)\n", + " .agg(\n", + " count=('prediction', 'size'),\n", + " avg_probability=('probability', 'mean'),\n", + " min_probability=('probability', 'min'),\n", + " max_probability=('probability', 'max'),\n", + " )\n", + " .reset_index()\n", + ")\n", + "\n", + "freq_total = df.groupby('freq', dropna=False).size().rename('freq_total').reset_index()\n", + "class_summary = class_summary.merge(freq_total, on='freq', how='left')\n", + "class_summary['class_rate'] = class_summary['count'] / class_summary['freq_total']\n", + "class_summary = class_summary.sort_values(['freq', 'prediction']).reset_index(drop=True)\n", + "\n", + "display(class_summary)" + ] + }, + { + "cell_type": "markdown", + "id": "039fcfa6", + "metadata": {}, + "source": [ + "## Статистика по классу drone" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "c1ed2bc4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
freqtotal_inferencesdrone_countavg_drone_probabilitymedian_drone_probabilitymin_drone_probabilitymax_drone_probabilityfirst_drone_timelast_drone_timedrone_ratedataset_duration_mindrone_per_min
012001363230.8400000.830.780.912026-05-05 03:18:55.374394280+07:002026-05-05 08:39:23.676669045+07:000.0002201121.9725040.002674
1240013626119210.8680130.930.501.002026-05-04 17:35:21.019627763+07:002026-05-05 12:17:19.369858371+07:000.8748721121.97250410.625038
\n", + "
" + ], + "text/plain": [ + " freq total_inferences drone_count avg_drone_probability \\\n", + "0 1200 13632 3 0.840000 \n", + "1 2400 13626 11921 0.868013 \n", + "\n", + " median_drone_probability min_drone_probability max_drone_probability \\\n", + "0 0.83 0.78 0.91 \n", + "1 0.93 0.50 1.00 \n", + "\n", + " first_drone_time last_drone_time \\\n", + "0 2026-05-05 03:18:55.374394280+07:00 2026-05-05 08:39:23.676669045+07:00 \n", + "1 2026-05-04 17:35:21.019627763+07:00 2026-05-05 12:17:19.369858371+07:00 \n", + "\n", + " drone_rate dataset_duration_min drone_per_min \n", + "0 0.000220 1121.972504 0.002674 \n", + "1 0.874872 1121.972504 10.625038 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "drone = df[df['prediction'].eq('drone')].copy()\n", + "\n", + "total_by_freq = df.groupby('freq', dropna=False).size().rename('total_inferences')\n", + "drone_by_freq = drone.groupby('freq', dropna=False).agg(\n", + " drone_count=('prediction', 'size'),\n", + " avg_drone_probability=('probability', 'mean'),\n", + " median_drone_probability=('probability', 'median'),\n", + " min_drone_probability=('probability', 'min'),\n", + " max_drone_probability=('probability', 'max'),\n", + " first_drone_time=('local_time', 'min'),\n", + " last_drone_time=('local_time', 'max'),\n", + ")\n", + "\n", + "drone_stats = total_by_freq.to_frame().join(drone_by_freq, how='left').fillna({'drone_count': 0})\n", + "drone_stats['drone_count'] = drone_stats['drone_count'].astype(int)\n", + "drone_stats['drone_rate'] = drone_stats['drone_count'] / drone_stats['total_inferences']\n", + "\n", + "if len(df) > 1:\n", + " duration_min = (df['ts'].max() - df['ts'].min()).total_seconds() / 60\n", + "else:\n", + " duration_min = 0\n", + "\n", + "drone_stats['dataset_duration_min'] = duration_min\n", + "drone_stats['drone_per_min'] = drone_stats['drone_count'] / duration_min if duration_min > 0 else 0\n", + "drone_stats = drone_stats.reset_index().sort_values('freq').reset_index(drop=True)\n", + "\n", + "display(drone_stats)" + ] + }, + { + "cell_type": "markdown", + "id": "56ae5e2b", + "metadata": {}, + "source": [ + "## Интервалы между drone-классификациями" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "0c43eb07", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
freqinterval_countavg_interval_secmedian_interval_secmin_interval_secmax_interval_secp90_interval_secp95_interval_sec
0120029614.1511379614.151137619.19611218609.10616316810.11515817709.610661
12400119205.6475134.9741570.0000001210.1079509.20372810.079097
\n", + "
" + ], + "text/plain": [ + " freq interval_count avg_interval_sec median_interval_sec \\\n", + "0 1200 2 9614.151137 9614.151137 \n", + "1 2400 11920 5.647513 4.974157 \n", + "\n", + " min_interval_sec max_interval_sec p90_interval_sec p95_interval_sec \n", + "0 619.196112 18609.106163 16810.115158 17709.610661 \n", + "1 0.000000 1210.107950 9.203728 10.079097 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if drone.empty:\n", + " print('No drone predictions found')\n", + " drone_interval_stats = pd.DataFrame()\n", + "else:\n", + " drone = drone.sort_values(['freq', 'ts']).copy()\n", + " drone['dt_drone_freq_sec'] = drone.groupby('freq')['ts'].diff().dt.total_seconds()\n", + " drone_interval_stats = (\n", + " drone.groupby('freq', dropna=False)['dt_drone_freq_sec']\n", + " .agg(\n", + " interval_count='count',\n", + " avg_interval_sec='mean',\n", + " median_interval_sec='median',\n", + " min_interval_sec='min',\n", + " max_interval_sec='max',\n", + " p90_interval_sec=lambda s: s.quantile(0.90),\n", + " p95_interval_sec=lambda s: s.quantile(0.95),\n", + " )\n", + " .reset_index()\n", + " )\n", + " display(drone_interval_stats)" + ] + }, + { + "cell_type": "markdown", + "id": "2ecf96f0", + "metadata": {}, + "source": [ + "## Drone-события" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff14a339", + "metadata": {}, + "outputs": [], + "source": [ + "drone_events = drone[[\n", + " 'local_time',\n", + " 'docker_timestamp',\n", + " 'freq',\n", + " 'model_id',\n", + " 'model_type',\n", + " 'prediction',\n", + " 'probability',\n", + "]].sort_values('local_time').reset_index(drop=True)\n", + "\n", + "display(drone_events.head(50))\n", + "display(drone_events.tail(50))" + ] + }, + { + "cell_type": "markdown", + "id": "376b84d0", + "metadata": {}, + "source": [ + "## Частота drone-классификаций по минутам" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5f82f5c1", + "metadata": {}, + "outputs": [], + "source": [ + "if drone.empty:\n", + " print('No drone predictions found')\n", + "else:\n", + " drone_per_minute = (\n", + " drone.set_index('local_time')\n", + " .groupby('freq')\n", + " .resample('1min')\n", + " .size()\n", + " .rename('drone_count')\n", + " .reset_index()\n", + " )\n", + " display(drone_per_minute.tail(100))\n", + "\n", + " pivot = drone_per_minute.pivot_table(\n", + " index='local_time',\n", + " columns='freq',\n", + " values='drone_count',\n", + " fill_value=0,\n", + " )\n", + " display(pivot.tail(50))" + ] + }, + { + "cell_type": "markdown", + "id": "ad570d05", + "metadata": {}, + "source": [ + "## Быстрые графики" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "895550a1", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "if not drone.empty:\n", + " ax = drone_stats.set_index('freq')['drone_rate'].plot(kind='bar', figsize=(8, 4), title='Drone rate by frequency')\n", + " ax.set_ylabel('drone_count / total_inferences')\n", + " plt.show()\n", + "\n", + " ax = drone.boxplot(column='probability', by='freq', figsize=(8, 4))\n", + " ax.set_title('Drone probability by frequency')\n", + " ax.set_xlabel('freq')\n", + " ax.set_ylabel('probability')\n", + " plt.suptitle('')\n", + " plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/orange_scripts/main_2400.py b/orange_scripts/main_2400.py index c15c661..9dabeb0 100644 --- a/orange_scripts/main_2400.py +++ b/orange_scripts/main_2400.py @@ -67,8 +67,8 @@ class get_center_freq(gr.top_block): self.rtlsdr_source_0.set_sample_rate(samp_rate) self.rtlsdr_source_0.set_center_freq(center_freq, 0) self.rtlsdr_source_0.set_freq_corr(0, 0) - self.rtlsdr_source_0.set_gain(16, 0) - self.rtlsdr_source_0.set_if_gain(16, 0) + self.rtlsdr_source_0.set_gain(0, 0) + self.rtlsdr_source_0.set_if_gain(0, 0) self.rtlsdr_source_0.set_bb_gain(0, 0) self.rtlsdr_source_0.set_antenna('', 0) self.rtlsdr_source_0.set_bandwidth(0, 0) diff --git a/restart_all.sh b/restart_all.sh index 2827cd1..53dbad0 100755 --- a/restart_all.sh +++ b/restart_all.sh @@ -8,7 +8,7 @@ SDR_UNITS=( dronedetector-sdr-433.service dronedetector-sdr-750.service #dronedetector-sdr-868-915.service - #dronedetector-sdr-868.service + dronedetector-sdr-868.service dronedetector-sdr-1500.service dronedetector-sdr-3300.service dronedetector-sdr-4500.service diff --git a/scripts/capture_nn_results.py b/scripts/capture_nn_results.py new file mode 100644 index 0000000..22b2d3e --- /dev/null +++ b/scripts/capture_nn_results.py @@ -0,0 +1,223 @@ +#!/usr/bin/env python3 +import argparse +import csv +import json +import os +import re +import subprocess +import sys +import time +from datetime import datetime, timezone + + +RESULT_RE = re.compile( + r"^(?P\S+)\s+RESULT Модель (?P\d+) с типом (?P.+?): " + r"(?P\S+) \(probability=(?P[-+]?\d+(?:\.\d+)?)\)\s*$" +) +FREQ_RE = re.compile(r"(\d{3,5})") + + +def parse_args(): + parser = argparse.ArgumentParser( + description="Capture NN inference RESULT logs into CSV or JSONL until time or size limit." + ) + parser.add_argument( + "--output", + required=True, + help="Output file path (.csv or .jsonl recommended).", + ) + parser.add_argument( + "--format", + choices=("csv", "jsonl"), + default="csv", + help="Output format.", + ) + parser.add_argument( + "--minutes", + type=float, + default=0.0, + help="Stop after this many minutes. 0 means no time limit.", + ) + parser.add_argument( + "--max-bytes", + type=int, + default=3 * 1024 * 1024 * 1024, + help="Stop when output file reaches this size in bytes. Default: 3 GiB.", + ) + parser.add_argument( + "--since", + default=None, + help="Optional docker logs --since value, e.g. 20m, 2h, 2026-05-04T12:00:00.", + ) + parser.add_argument( + "--tail", + type=int, + default=0, + help="How many previous log lines to include before following. Default: 0.", + ) + parser.add_argument( + "--compose-file", + default="deploy/docker/docker-compose.yml", + help="Path to docker compose file.", + ) + parser.add_argument( + "--service", + default="dronedetector-nn-server", + help="Docker compose service name.", + ) + parser.add_argument( + "--follow", + action="store_true", + help="Follow logs live. By default the script captures a finite history snapshot.", + ) + return parser.parse_args() + + +def extract_freq(model_type): + matches = FREQ_RE.findall(model_type) + if not matches: + return "" + known_freqs = {"433", "750", "868", "915", "1200", "1500", "2400", "3300", "4500", "5200", "5800"} + for value in matches: + if value in known_freqs: + return value + return matches[0] + + +def parse_docker_timestamp(value): + try: + return datetime.fromisoformat(value.replace("Z", "+00:00")) + except ValueError: + return datetime.now(timezone.utc) + + +def open_output(path, fmt): + os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True) + fh = open(path, "a", encoding="utf-8", newline="") + writer = None + if fmt == "csv": + writer = csv.writer(fh) + if fh.tell() == 0: + writer.writerow( + [ + "docker_timestamp", + "event_time_iso", + "event_time_epoch", + "freq", + "model_id", + "model_type", + "prediction", + "probability", + ] + ) + fh.flush() + return fh, writer + + +def write_record(fh, writer, fmt, record): + if fmt == "csv": + writer.writerow( + [ + record["docker_timestamp"], + record["event_time_iso"], + record["event_time_epoch"], + record["freq"], + record["model_id"], + record["model_type"], + record["prediction"], + record["probability"], + ] + ) + else: + fh.write(json.dumps(record, ensure_ascii=False) + "\n") + fh.flush() + + +def build_command(args): + cmd = [ + "docker", + "compose", + "-f", + args.compose_file, + "logs", + "--timestamps", + "--no-log-prefix", + args.service, + ] + if args.since: + cmd[5:5] = ["--since", args.since] + if int(args.tail) > 0: + cmd[-1:-1] = ["--tail", str(args.tail)] + if args.follow: + cmd.insert(-1, "-f") + return cmd + + +def main(): + args = parse_args() + deadline = time.time() + (args.minutes * 60.0) if args.minutes > 0 else None + + fh, writer = open_output(args.output, args.format) + cmd = build_command(args) + + print("Running:", " ".join(cmd), file=sys.stderr) + proc = subprocess.Popen( + cmd, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + encoding="utf-8", + errors="replace", + bufsize=1, + ) + + captured = 0 + try: + assert proc.stdout is not None + for line in proc.stdout: + if deadline is not None and time.time() >= deadline: + print("Stopping: time limit reached", file=sys.stderr) + break + + match = RESULT_RE.match(line.rstrip("\n")) + if not match: + continue + + docker_dt = parse_docker_timestamp(match.group("docker_ts")) + event_dt = docker_dt.astimezone() + model_type = match.group("model_type") + record = { + "docker_timestamp": match.group("docker_ts"), + "event_time_iso": event_dt.isoformat(timespec="seconds"), + "event_time_epoch": round(docker_dt.timestamp(), 3), + "freq": extract_freq(model_type), + "model_id": int(match.group("model_id")), + "model_type": model_type, + "prediction": match.group("prediction"), + "probability": float(match.group("probability")), + } + write_record(fh, writer, args.format, record) + captured += 1 + + if fh.tell() >= args.max_bytes: + print("Stopping: file size limit reached", file=sys.stderr) + break + finally: + try: + proc.terminate() + except Exception: + pass + try: + proc.wait(timeout=5) + except Exception: + try: + proc.kill() + except Exception: + pass + fh.close() + + print(f"Captured {captured} inference results into {args.output}", file=sys.stderr) + + +if __name__ == "__main__": + main() diff --git a/src/main_2400.py b/src/main_2400.py index 8790050..a036c1b 100644 --- a/src/main_2400.py +++ b/src/main_2400.py @@ -40,8 +40,8 @@ class get_center_freq(gr.top_block): self.rtlsdr_source_0.set_sample_rate(self.samp_rate) self.rtlsdr_source_0.set_center_freq(self.center_freq, 0) self.rtlsdr_source_0.set_freq_corr(0, 0) - self.rtlsdr_source_0.set_gain(24, 0) - self.rtlsdr_source_0.set_if_gain(24, 0) + self.rtlsdr_source_0.set_gain(0, 0) + self.rtlsdr_source_0.set_if_gain(0, 0) self.rtlsdr_source_0.set_bb_gain(100, 0) self.rtlsdr_source_0.set_antenna('', 0) self.rtlsdr_source_0.set_bandwidth(0, 0) diff --git a/src/server_to_master.py b/src/server_to_master.py index 6053254..96e7ffd 100644 --- a/src/server_to_master.py +++ b/src/server_to_master.py @@ -298,7 +298,7 @@ async def agregate_data(data_to_agregate: list): data = [] - if any(item is not None for item in data_to_agregate): + if all(item is not None for item in data_to_agregate): for item in data_to_agregate: if item is not None: item['freq'] = int(item['freq']) diff --git a/telemetry/telemetry_server.py b/telemetry/telemetry_server.py index d507fb4..99298a7 100644 --- a/telemetry/telemetry_server.py +++ b/telemetry/telemetry_server.py @@ -1,11 +1,13 @@ import asyncio import os +import re import time from collections import defaultdict, deque +from pathlib import Path from typing import Any, Deque, Dict, List, Optional -from fastapi import FastAPI, Query, WebSocket, WebSocketDisconnect -from fastapi.responses import HTMLResponse +from fastapi import FastAPI, HTTPException, Query, WebSocket, WebSocketDisconnect +from fastapi.responses import FileResponse, HTMLResponse from pydantic import BaseModel, Field from common.runtime import load_root_env @@ -16,15 +18,25 @@ TELEMETRY_BIND_HOST = os.getenv('telemetry_bind_host', os.getenv('lochost', '0.0 TELEMETRY_BIND_PORT = int(os.getenv('telemetry_bind_port', os.getenv('telemetry_port', '5020'))) TELEMETRY_HISTORY_SEC = int(float(os.getenv('telemetry_history_sec', '900'))) TELEMETRY_MAX_POINTS_PER_FREQ = int(os.getenv('telemetry_max_points_per_freq', '5000')) +INFERENCE_HISTORY_SEC = int(float(os.getenv('inference_history_sec', str(TELEMETRY_HISTORY_SEC)))) +INFERENCE_MAX_RESULTS_PER_FREQ = int(os.getenv('inference_max_results_per_freq', '100')) +INFERENCE_RESULT_DIR = Path(os.getenv('inference_result_dir', '/app/inference_result')).resolve() +INFERENCE_IMAGE_RE = re.compile(r"_inference_(\d+)_") def _new_buffer() -> Deque[Dict[str, Any]]: return deque(maxlen=TELEMETRY_MAX_POINTS_PER_FREQ) +def _new_inference_buffer() -> Deque[Dict[str, Any]]: + return deque(maxlen=INFERENCE_MAX_RESULTS_PER_FREQ) + + app = FastAPI(title='DroneDetector Telemetry Server') _buffers: Dict[str, Deque[Dict[str, Any]]] = defaultdict(_new_buffer) _ws_clients: List[WebSocket] = [] +_inference_buffers: Dict[str, Deque[Dict[str, Any]]] = defaultdict(_new_inference_buffer) +_inference_ws_clients: List[WebSocket] = [] _state_lock = asyncio.Lock() @@ -41,6 +53,18 @@ class TelemetryPoint(BaseModel): alarm_channels: Optional[List[int]] = None +class InferenceResult(BaseModel): + result_id: int + ts: float = Field(default_factory=lambda: time.time()) + freq: str + model: str + prediction: str + probability: float + drone_probability: Optional[float] = None + drone_threshold: Optional[str] = None + images: List[str] = Field(default_factory=list) + + def _prune_freq_locked(freq: str, now_ts: float) -> None: cutoff = now_ts - TELEMETRY_HISTORY_SEC buf = _buffers[freq] @@ -62,6 +86,71 @@ def _copy_series_locked(seconds: int, freq: Optional[str] = None) -> Dict[str, L return series +def _prune_inference_freq_locked(freq: str, now_ts: float) -> None: + cutoff = now_ts - INFERENCE_HISTORY_SEC + buf = _inference_buffers[freq] + while buf and float(buf[0].get('ts', 0.0)) < cutoff: + buf.popleft() + + +def _copy_inference_series_locked(limit: int, freq: Optional[str] = None) -> Dict[str, List[Dict[str, Any]]]: + now_ts = time.time() + cutoff = now_ts - INFERENCE_HISTORY_SEC + + def _slice(buf: Deque[Dict[str, Any]]) -> List[Dict[str, Any]]: + recent = [item for item in buf if float(item.get('ts', 0.0)) >= cutoff] + return recent[-limit:] + + if freq is not None: + return {freq: _slice(_inference_buffers.get(freq, deque()))} + + series: Dict[str, List[Dict[str, Any]]] = {} + for key, buf in _inference_buffers.items(): + series[key] = _slice(buf) + return series + + +def _sanitize_image_names(names: List[str]) -> List[str]: + safe_names: List[str] = [] + for name in names: + base = Path(str(name)).name + if not base or not base.endswith('.png'): + continue + safe_names.append(base) + return safe_names + + +def _resolve_latest_images_for_model(payload: Dict[str, Any]) -> Dict[str, Any]: + model_name = str(payload.get('model', '')) + if not model_name or not INFERENCE_RESULT_DIR.is_dir(): + payload['images'] = _sanitize_image_names(payload.get('images', [])) + return payload + + model_suffix = f"_{model_name}.png" + grouped: Dict[int, List[str]] = {} + for path in INFERENCE_RESULT_DIR.iterdir(): + if not path.is_file(): + continue + name = path.name + if not name.endswith(model_suffix): + continue + match = INFERENCE_IMAGE_RE.search(name) + if match is None: + continue + grouped.setdefault(int(match.group(1)), []).append(name) + + if not grouped: + payload['images'] = _sanitize_image_names(payload.get('images', [])) + return payload + + current_id = int(payload.get('result_id', 0) or 0) + if current_id in grouped: + payload['images'] = sorted(grouped[current_id]) + else: + payload['images'] = _sanitize_image_names(payload.get('images', [])) + return payload + + async def _broadcast(message: Dict[str, Any]) -> None: dead: List[WebSocket] = [] for ws in list(_ws_clients): @@ -77,6 +166,21 @@ async def _broadcast(message: Dict[str, Any]) -> None: _ws_clients.remove(ws) +async def _broadcast_inference(message: Dict[str, Any]) -> None: + dead: List[WebSocket] = [] + for ws in list(_inference_ws_clients): + try: + await ws.send_json(message) + except Exception: + dead.append(ws) + + if dead: + async with _state_lock: + for ws in dead: + if ws in _inference_ws_clients: + _inference_ws_clients.remove(ws) + + @app.post('/telemetry') async def ingest_telemetry(point: TelemetryPoint): payload = point.model_dump() @@ -102,6 +206,31 @@ async def telemetry_history( return {'seconds': seconds, 'series': series} +@app.post('/inference/result') +async def ingest_inference_result(result: InferenceResult): + payload = result.model_dump() + payload = _resolve_latest_images_for_model(payload) + freq = str(payload['freq']) + now_ts = time.time() + + async with _state_lock: + _inference_buffers[freq].append(payload) + _prune_inference_freq_locked(freq, now_ts) + + await _broadcast_inference({'type': 'inference_result', 'data': payload}) + return {'ok': True} + + +@app.get('/inference/history') +async def inference_history( + freq: Optional[str] = Query(default=None), + limit: int = Query(default=20, ge=1, le=200), +): + async with _state_lock: + series = _copy_inference_series_locked(limit=limit, freq=freq) + return {'limit': limit, 'series': series} + + @app.websocket('/telemetry/ws') async def telemetry_ws(websocket: WebSocket): await websocket.accept() @@ -123,6 +252,26 @@ async def telemetry_ws(websocket: WebSocket): _ws_clients.remove(websocket) +@app.websocket('/inference/ws') +async def inference_ws(websocket: WebSocket): + await websocket.accept() + async with _state_lock: + _inference_ws_clients.append(websocket) + snapshot = _copy_inference_series_locked(limit=20, freq=None) + + await websocket.send_json({'type': 'snapshot', 'data': snapshot}) + + try: + while True: + await websocket.receive_text() + except WebSocketDisconnect: + pass + finally: + async with _state_lock: + if websocket in _inference_ws_clients: + _inference_ws_clients.remove(websocket) + + MONITOR_HTML = """ @@ -453,12 +602,294 @@ loadInitial().then(connectWs).catch((e) => { """ +INFERENCE_VIEWER_HTML = """ + + + + + + DroneDetector Inference Viewer + + + +
+
+
+

DroneDetector Inference Viewer

+
Latest inference card per frequency. Browser keeps last 20 results per frequency.
+
+
+
connecting...
+ +
+
+
+
+ + + + +""" + + @app.get('/', response_class=HTMLResponse) @app.get('/monitor', response_class=HTMLResponse) async def monitor_page(): return HTMLResponse(content=MONITOR_HTML) +@app.get('/inference-viewer', response_class=HTMLResponse) +async def inference_viewer_page(): + return HTMLResponse(content=INFERENCE_VIEWER_HTML) + + +@app.get('/inference/images/{filename}') +async def inference_image(filename: str): + safe_name = Path(filename).name + if safe_name != filename: + raise HTTPException(status_code=404, detail='image not found') + + image_path = (INFERENCE_RESULT_DIR / safe_name).resolve() + if image_path.parent != INFERENCE_RESULT_DIR or not image_path.is_file(): + raise HTTPException(status_code=404, detail='image not found') + + return FileResponse(image_path) + + if __name__ == '__main__': import uvicorn diff --git a/train_scripts/ImageDatasetCreate_spec_imag_real_915.ipynb b/train_scripts/ImageDatasetCreate_spec_imag_real_915.ipynb index fd80e16..226c059 100644 --- a/train_scripts/ImageDatasetCreate_spec_imag_real_915.ipynb +++ b/train_scripts/ImageDatasetCreate_spec_imag_real_915.ipynb @@ -2,10 +2,18 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "4fdb98fc-65bb-467e-be0c-168fee9b0fca", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n", + " warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -14,32 +22,14 @@ ] }, { - "ename": "NameError", - "evalue": "name '_ndimage_api' 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[3]\u001b[39m\u001b[32m, line 29\u001b[39m\n\u001b[32m 27\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mgc\u001b[39;00m\n\u001b[32m 28\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mutils\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mu\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m29\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mtransforms\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mtransforms\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mT\u001b[39;00m\n\u001b[32m 30\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mtransforms\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m functional \u001b[38;5;28;01mas\u001b[39;00m F\n\u001b[32m 31\u001b[39m matplotlib.use(\u001b[33m'\u001b[39m\u001b[33mAgg\u001b[39m\u001b[33m'\u001b[39m)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/torchsig/torchsig/transforms/transforms.py:1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01mdataset_transforms\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Spectrogram \u001b[38;5;28;01mas\u001b[39;00m _Spectrogram\n\u001b[32m 4\u001b[39m \u001b[38;5;28;01mclass\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mSpectrogram\u001b[39;00m(_Spectrogram):\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, nperseg=\u001b[38;5;28;01mNone\u001b[39;00m, fft_size=\u001b[38;5;28;01mNone\u001b[39;00m, nfft=\u001b[38;5;28;01mNone\u001b[39;00m, **kwargs):\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/torchsig/torchsig/transforms/dataset_transforms.py:37\u001b[39m\n\u001b[32m 4\u001b[39m __all__ = [\n\u001b[32m 5\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mDatasetTransform\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 6\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 33\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mTimeReversal\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 34\u001b[39m ]\n\u001b[32m 36\u001b[39m \u001b[38;5;66;03m# TorchSig\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m37\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mtransforms\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mbase_transforms\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Transform\n\u001b[32m 38\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01msignals\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01msignal_types\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m DatasetSignal, SignalMetadata\n\u001b[32m 39\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mtransforms\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mfunctional\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mF\u001b[39;00m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/torchsig/torchsig/transforms/base_transforms.py:16\u001b[39m\n\u001b[32m 6\u001b[39m __all__ = [\n\u001b[32m 7\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mTransform\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 8\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mCompose\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m (...)\u001b[39m\u001b[32m 12\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mRandAugment\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 13\u001b[39m ]\n\u001b[32m 15\u001b[39m \u001b[38;5;66;03m# TorchSig\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m16\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mtransforms\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mfunctional\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mF\u001b[39;00m\n\u001b[32m 17\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01msignals\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01msignal_types\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Signal, DatasetSignal\n\u001b[32m 18\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mutils\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mrandom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Seedable\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/torchsig/torchsig/transforms/functional.py:6\u001b[39m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtyping\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Literal, Optional, Tuple\n\u001b[32m 5\u001b[39m \u001b[38;5;66;03m# TorchSig\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mutils\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mdsp\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mdsp\u001b[39;00m\n\u001b[32m 7\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mutils\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mdsp\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[32m 8\u001b[39m torchsig_complex_data_type,\n\u001b[32m 9\u001b[39m torchsig_float_data_type\n\u001b[32m 10\u001b[39m )\n\u001b[32m 12\u001b[39m \u001b[38;5;66;03m# Third Party\u001b[39;00m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/torchsig/torchsig/utils/dsp.py:5\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[33;03m\"\"\"Digital Signal Processing (DSP) Utils\u001b[39;00m\n\u001b[32m 2\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 4\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtorchsig\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m __version__ \u001b[38;5;28;01mas\u001b[39;00m torchsig_version\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mscipy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m signal \u001b[38;5;28;01mas\u001b[39;00m sp\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n\u001b[32m 7\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mcopy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m copy\n", - "\u001b[36mFile \u001b[39m\u001b[32m:1412\u001b[39m, in \u001b[36m_handle_fromlist\u001b[39m\u001b[34m(module, fromlist, import_, recursive)\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/scipy/__init__.py:131\u001b[39m, in \u001b[36m__getattr__\u001b[39m\u001b[34m(name)\u001b[39m\n\u001b[32m 129\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__getattr__\u001b[39m(name):\n\u001b[32m 130\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01min\u001b[39;00m submodules:\n\u001b[32m--> \u001b[39m\u001b[32m131\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_importlib\u001b[49m\u001b[43m.\u001b[49m\u001b[43mimport_module\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mscipy.\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mname\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 132\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 133\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n", - "\u001b[36mFile \u001b[39m\u001b[32m/usr/lib/python3.12/importlib/__init__.py:90\u001b[39m, in \u001b[36mimport_module\u001b[39m\u001b[34m(name, package)\u001b[39m\n\u001b[32m 88\u001b[39m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[32m 89\u001b[39m level += \u001b[32m1\u001b[39m\n\u001b[32m---> \u001b[39m\u001b[32m90\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_bootstrap\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_gcd_import\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m[\u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpackage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/scipy/signal/__init__.py:306\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 2\u001b[39m \u001b[33;03m=======================================\u001b[39;00m\n\u001b[32m 3\u001b[39m \u001b[33;03mSignal processing (:mod:`scipy.signal`)\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 300\u001b[39m \n\u001b[32m 301\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 302\u001b[39m \u001b[38;5;66;03m# bring in the public functionality from private namespaces\u001b[39;00m\n\u001b[32m 303\u001b[39m \n\u001b[32m 304\u001b[39m \u001b[38;5;66;03m# mypy: ignore-errors\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m306\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_support_alternative_backends\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m *\n\u001b[32m 307\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m _support_alternative_backends\n\u001b[32m 308\u001b[39m __all__ = _support_alternative_backends.__all__\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/scipy/signal/_support_alternative_backends.py:7\u001b[39m\n\u001b[32m 2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mtypes\u001b[39;00m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mscipy\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_lib\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_array_api\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m (\n\u001b[32m 4\u001b[39m is_cupy, is_jax, scipy_namespace_for, SCIPY_ARRAY_API, xp_capabilities\n\u001b[32m 5\u001b[39m )\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_signal_api\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m * \u001b[38;5;66;03m# noqa: F403\u001b[39;00m\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m _signal_api\n\u001b[32m 9\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m _delegators\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/scipy/signal/_signal_api.py:16\u001b[39m\n\u001b[32m 12\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_upfirdn\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m upfirdn \u001b[38;5;66;03m# noqa: F401\u001b[39;00m\n\u001b[32m 14\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_spline\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m sepfir2d \u001b[38;5;66;03m# noqa: F401\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m16\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_spline_filters\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m * \u001b[38;5;66;03m# noqa: F403\u001b[39;00m\n\u001b[32m 17\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_filter_design\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m * \u001b[38;5;66;03m# noqa: F403\u001b[39;00m\n\u001b[32m 18\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_fir_filter_design\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m * \u001b[38;5;66;03m# noqa: F403\u001b[39;00m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/scipy/signal/_spline_filters.py:14\u001b[39m\n\u001b[32m 12\u001b[39m \u001b[38;5;66;03m# From splinemodule.c\u001b[39;00m\n\u001b[32m 13\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_spline\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m sepfir2d, symiirorder1_ic, symiirorder2_ic_fwd, symiirorder2_ic_bwd\n\u001b[32m---> \u001b[39m\u001b[32m14\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_signaltools\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m lfilter, sosfilt, lfiltic\n\u001b[32m 15\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_arraytools\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m axis_slice, axis_reverse\n\u001b[32m 17\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mscipy\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01minterpolate\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m BSpline\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/scipy/signal/_signaltools.py:19\u001b[39m\n\u001b[32m 17\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_upfirdn\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m upfirdn, _output_len, _upfirdn_modes\n\u001b[32m 18\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mscipy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m linalg, fft \u001b[38;5;28;01mas\u001b[39;00m sp_fft\n\u001b[32m---> \u001b[39m\u001b[32m19\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mscipy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m ndimage\n\u001b[32m 20\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mscipy\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mfft\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01m_helper\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m _init_nd_shape_and_axes\n\u001b[32m 21\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n", - "\u001b[36mFile \u001b[39m\u001b[32m:1412\u001b[39m, in \u001b[36m_handle_fromlist\u001b[39m\u001b[34m(module, fromlist, import_, recursive)\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/scipy/__init__.py:131\u001b[39m, in \u001b[36m__getattr__\u001b[39m\u001b[34m(name)\u001b[39m\n\u001b[32m 129\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__getattr__\u001b[39m(name):\n\u001b[32m 130\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01min\u001b[39;00m submodules:\n\u001b[32m--> \u001b[39m\u001b[32m131\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_importlib\u001b[49m\u001b[43m.\u001b[49m\u001b[43mimport_module\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mscipy.\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mname\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 132\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 133\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n", - "\u001b[36mFile \u001b[39m\u001b[32m/usr/lib/python3.12/importlib/__init__.py:90\u001b[39m, in \u001b[36mimport_module\u001b[39m\u001b[34m(name, package)\u001b[39m\n\u001b[32m 88\u001b[39m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[32m 89\u001b[39m level += \u001b[32m1\u001b[39m\n\u001b[32m---> \u001b[39m\u001b[32m90\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_bootstrap\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_gcd_import\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m[\u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpackage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlevel\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/scipy/ndimage/__init__.py:162\u001b[39m\n\u001b[32m 160\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m _support_alternative_backends\n\u001b[32m 161\u001b[39m __all__ = _support_alternative_backends.__all__\n\u001b[32m--> \u001b[39m\u001b[32m162\u001b[39m \u001b[38;5;28;01mdel\u001b[39;00m _support_alternative_backends, \u001b[43m_ndimage_api\u001b[49m, _delegators \u001b[38;5;66;03m# noqa: F821\u001b[39;00m\n\u001b[32m 165\u001b[39m \u001b[38;5;66;03m# Deprecated namespaces, to be removed in v2.0.0\u001b[39;00m\n\u001b[32m 166\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01m.\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m filters\n", - "\u001b[31mNameError\u001b[39m: name '_ndimage_api' is not defined" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -82,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "4848b066-2e09-4c1c-b8fa-8e3fa84d907a", "metadata": {}, "outputs": [], @@ -92,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "9267fbe1", "metadata": {}, "outputs": [], @@ -165,20 +155,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "448da74a-e0ae-44d8-9877-8dd1f257a24f", "metadata": {}, "outputs": [], "source": [ "selected_freq=2400\n", "\n", - "path_to_binaries = f'/mnt/nvme1/dataset_5_5_26/noise/{selected_freq}'\n", - "path_to_pictures = f'/mnt/nvme1/dataset_5_5_26_img/noise/{selected_freq}_jpg'" + "path_to_binaries = f'/mnt/data/Dataset/noise/{selected_freq}'\n", + "path_to_pictures = f'/mnt/data/Dataset_img/noise/{selected_freq}_jpg'" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "ac4945a8-29c4-4da4-945f-08658953e3e5", "metadata": {}, "outputs": [], @@ -188,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "6f226f86-5d72-4573-8af6-750128b70263", "metadata": {}, "outputs": [ @@ -196,14 +186,42 @@ "name": "stderr", "output_type": "stream", "text": [ - "drone: 100%|██████████| 935/935 [13:33<00:00, 1.15it/s]" + "2026-04-08_18-06-46: 100%|██████████| 1013/1013 [19:43<00:00, 1.17s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dir: 2026-04-08_18-06-46 finished!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-04-08_18-10-32: 100%|██████████| 353/353 [06:53<00:00, 1.17s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dir: 2026-04-08_18-10-32 finished!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-04-08_18-08-39: 100%|██████████| 1017/1017 [19:48<00:00, 1.17s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Dir: drone finished!\n" + "Dir: 2026-04-08_18-08-39 finished!\n" ] }, { @@ -227,7 +245,7 @@ " sig2pic_with_spec(path_to_data=filepath, filename=file, specT=s, resize=size)\n", "\n", " files = os.listdir(filepath)\n", - " k = max(1, int(len(files) * 0.3))\n", + " k = max(1, int(len(files) * 1))\n", " files = random.sample(files, k)\n", " for file in tqdm(files, desc=subdir):\n", " full_input_path = filepath + file\n", diff --git a/train_scripts/Training_models 3pic.ipynb b/train_scripts/Training_models 3pic.ipynb index 5e170f5..c2a7f77 100644 --- a/train_scripts/Training_models 3pic.ipynb +++ b/train_scripts/Training_models 3pic.ipynb @@ -24,6 +24,14 @@ "tags": [] }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n", + " warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -34,7 +42,7 @@ { "data": { "text/plain": [ - "112" + "191" ] }, "execution_count": 1, @@ -98,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "46e4dc99-6994-4fee-a32e-f3983bd991bd", "metadata": {}, "outputs": [], @@ -106,6 +114,7 @@ "def prepare_and_learning_detection(num_classes, num_samples, path_dataset, model_name, config_name, model,selected_freq):\n", " num_samples_per_class = num_samples // num_classes\n", "\n", + "\n", " #----------Создаём папку для сохранения результатов обучения--------------\n", " os.makedirs(\"models\", exist_ok=True)\n", " ind = 1\n", @@ -177,6 +186,7 @@ " for row in list(reader)[1:]:\n", " row = str(row)\n", " data.append(row[2: len(row)-2])\n", + "\n", " self.sig_filenames = data\n", " self.path_dataset = path_dataset\n", " \n", @@ -186,6 +196,9 @@ " def __getitem__(self, idx):\n", " base = os.path.splitext(self.sig_filenames[idx])[0]\n", "\n", + " #raise(base)\n", + "\n", + " exit(1)\n", " image_real = np.asarray(cv2.split(cv2.imread(base + '_real.png')), dtype=np.float32)\n", " image_imag = np.asarray(cv2.split(cv2.imread(base + '_imag.png')), dtype=np.float32)\n", " image_spec = np.asarray(cv2.split(cv2.imread(base + '_spec.png')), dtype=np.float32)\n", @@ -193,11 +206,12 @@ " if 'drone' in list(self.sig_filenames[idx].split('/')):\n", " label = torch.tensor(0)\n", " if 'noise' in list(self.sig_filenames[idx].split('/')):\n", + " exit(1)\n", " label = torch.tensor(1)\n", " return image_real, image_imag, image_spec, label\n", " \n", " #----------Создаём датасет--------------\n", - " \n", + " exit(1)\n", " dataset = MyDataset(path_dataset=path_res, csv_file='dataset.csv')\n", " train_set, valid_set = torch.utils.data.random_split(dataset, [0.7, 0.3], generator=torch.Generator().manual_seed(42))\n", " batch_size = config.batch_size\n", @@ -332,242 +346,40 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 13, "id": "52e8d4c5", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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", - "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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=None`.\n", - " warnings.warn(msg)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['noise', 'drone']\n", - "Epoch : 1\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 168/168 [01:10<00:00, 2.39it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train Loss: 0.0628 Acc: 0.9956\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 72/72 [00:11<00:00, 6.27it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "val Loss: 0.0029 Acc: 1.0000\n", - "\n", - "Epoch : 2\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 168/168 [01:10<00:00, 2.38it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train Loss: 0.0018 Acc: 0.9956\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 72/72 [00:11<00:00, 6.13it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "val Loss: 0.0011 Acc: 1.0000\n", - "\n", - "Epoch : 3\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 168/168 [01:10<00:00, 2.38it/s]\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "train Loss: 0.0008 Acc: 0.9956\n" + "['noise', 'drone']\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 72/72 [00:11<00:00, 6.20it/s]\n" + "/tmp/ipykernel_3754538/2835334388.py:103: UserWarning: Length of split at index 0 is 0. This might result in an empty dataset.\n", + " train_set, valid_set = torch.utils.data.random_split(dataset, [0.7, 0.3], generator=torch.Generator().manual_seed(42))\n", + "/tmp/ipykernel_3754538/2835334388.py:103: UserWarning: Length of split at index 1 is 0. This might result in an empty dataset.\n", + " train_set, valid_set = torch.utils.data.random_split(dataset, [0.7, 0.3], generator=torch.Generator().manual_seed(42))\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "val Loss: 0.0006 Acc: 1.0000\n", - "\n", - "Epoch : 4\n", - "\n" + "ename": "ValueError", + "evalue": "num_samples should be a positive integer value, but got num_samples=0", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[13]\u001b[39m\u001b[32m, line 49\u001b[39m\n\u001b[32m 45\u001b[39m model = model.to(device)\n\u001b[32m 46\u001b[39m \n\u001b[32m 47\u001b[39m \u001b[38;5;66;03m#----------Создания датасета и обучение модели--------------\u001b[39;00m\n\u001b[32m 48\u001b[39m \n\u001b[32m---> \u001b[39m\u001b[32m49\u001b[39m path_res, model_name = prepare_and_learning_detection(num_classes = num_classes, num_samples = 10000, path_dataset = \"/mnt/data/Dataset_img\", \n\u001b[32m 50\u001b[39m selected_freq=\u001b[32m2400\u001b[39m,model_name = config_name+\u001b[33m\"_2.4_jpg_\"\u001b[39m, config_name = config_name, model=model)\n\u001b[32m 51\u001b[39m \n\u001b[32m 52\u001b[39m \n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[12]\u001b[39m\u001b[32m, line 105\u001b[39m, in \u001b[36mprepare_and_learning_detection\u001b[39m\u001b[34m(num_classes, num_samples, path_dataset, model_name, config_name, model, selected_freq)\u001b[39m\n\u001b[32m 101\u001b[39m exit(\u001b[32m1\u001b[39m)\n\u001b[32m 102\u001b[39m dataset = MyDataset(path_dataset=path_res, csv_file=\u001b[33m'dataset.csv'\u001b[39m)\n\u001b[32m 103\u001b[39m train_set, valid_set = torch.utils.data.random_split(dataset, [\u001b[32m0.7\u001b[39m, \u001b[32m0.3\u001b[39m], generator=torch.Generator().manual_seed(\u001b[32m42\u001b[39m))\n\u001b[32m 104\u001b[39m batch_size = config.batch_size\n\u001b[32m--> \u001b[39m\u001b[32m105\u001b[39m train_dataloader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=\u001b[38;5;28;01mTrue\u001b[39;00m, drop_last=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m 106\u001b[39m valid_dataloader = torch.utils.data.DataLoader(valid_set, batch_size=batch_size, shuffle=\u001b[38;5;28;01mTrue\u001b[39;00m, drop_last=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m 107\u001b[39m \n\u001b[32m 108\u001b[39m dataloaders = {}\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/torch/utils/data/dataloader.py:394\u001b[39m, in \u001b[36mDataLoader.__init__\u001b[39m\u001b[34m(self, dataset, batch_size, shuffle, sampler, batch_sampler, num_workers, collate_fn, pin_memory, drop_last, timeout, worker_init_fn, multiprocessing_context, generator, prefetch_factor, persistent_workers, pin_memory_device, in_order)\u001b[39m\n\u001b[32m 392\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m: \u001b[38;5;66;03m# map-style\u001b[39;00m\n\u001b[32m 393\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m shuffle:\n\u001b[32m--> \u001b[39m\u001b[32m394\u001b[39m sampler = \u001b[30;43mRandomSampler\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mdataset\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mgenerator\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mgenerator\u001b[39;49m\u001b[30;43m)\u001b[39;49m \u001b[38;5;66;03m# type: ignore[arg-type]\u001b[39;00m\n\u001b[32m 395\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 396\u001b[39m sampler = SequentialSampler(dataset) \u001b[38;5;66;03m# type: ignore[arg-type]\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/torch/utils/data/sampler.py:149\u001b[39m, in \u001b[36mRandomSampler.__init__\u001b[39m\u001b[34m(self, data_source, replacement, num_samples, generator)\u001b[39m\n\u001b[32m 144\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[32m 145\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mreplacement should be a boolean value, but got replacement=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.replacement\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m 146\u001b[39m )\n\u001b[32m 148\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(\u001b[38;5;28mself\u001b[39m.num_samples, \u001b[38;5;28mint\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.num_samples <= \u001b[32m0\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m149\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 150\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mnum_samples should be a positive integer value, but got num_samples=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.num_samples\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m 151\u001b[39m )\n", + "\u001b[31mValueError\u001b[39m: num_samples should be a positive integer value, but got num_samples=0" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 168/168 [01:10<00:00, 2.38it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train Loss: 0.0005 Acc: 0.9956\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 72/72 [00:11<00:00, 6.13it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "val Loss: 0.0004 Acc: 1.0000\n", - "\n", - "Epoch : 5\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 168/168 [01:10<00:00, 2.38it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train Loss: 0.0003 Acc: 0.9956\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 72/72 [00:11<00:00, 6.12it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "val Loss: 0.0003 Acc: 1.0000\n", - "\n", - "Epoch : 6\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 168/168 [01:10<00:00, 2.38it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train Loss: 0.0002 Acc: 0.9956\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 72/72 [00:11<00:00, 6.11it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "val Loss: 0.0002 Acc: 1.0000\n", - "Total time elapsed = 493.41988416798995 seconds\n" - ] - }, - { - "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": { - "text/plain": [ - "67" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -577,7 +389,7 @@ "cv2.destroyAllWindows()\n", "gc.collect()\n", "\n", - "num_classes = 3\n", + "num_classes = 2\n", "config_name = \"ensemble\"\n", " \n", "def load_function(attr):\n", @@ -588,31 +400,27 @@ "\n", "model1 = models.resnet18(pretrained=False)\n", "model2 = models.resnet50(pretrained=False)\n", - "model3 = models.resnet101(pretrained=False)\n", "\n", "num_classes = 2\n", "\n", "model1.fc = nn.Linear(model1.fc.in_features, num_classes)\n", "model2.fc = nn.Linear(model2.fc.in_features, num_classes)\n", - "model3.fc = nn.Linear(model3.fc.in_features, num_classes)\n", "\n", "class Ensemble(nn.Module):\n", - " def __init__(self, model1, model2, model3):\n", + " def __init__(self, model1, model2):\n", " super(Ensemble, self).__init__()\n", " self.model1 = model1\n", " self.model2 = model2\n", - " self.model3 = model3\n", - " self.fc = nn.Linear(3 * num_classes, num_classes)\n", + " self.fc = nn.Linear(2 * num_classes, num_classes)\n", "\n", " def forward(self, x):\n", " x1 = self.model1(x[0])\n", " x2 = self.model2(x[1])\n", - " x3 = self.model3(x[2])\n", - " x = torch.cat((x1, x2, x3), dim=1)\n", + " x = torch.cat((x1, x2), dim=1)\n", " x = self.fc(x)\n", " return x\n", "\n", - "model = Ensemble(model1, model2, model3)\n", + "model = Ensemble(model1, model2)\n", "\n", "optimizer = load_function(config.optimizer.name)(model.parameters(), lr=config.optimizer.lr)\n", "criterion = load_function(config.loss_function.name)()\n", @@ -623,8 +431,8 @@ "\n", "#----------Создания датасета и обучение модели--------------\n", "\n", - "path_res, model_name = prepare_and_learning_detection(num_classes = num_classes, num_samples = 10000, path_dataset = \"/mnt/nvme1/dataset_img\", \n", - " selected_freq=1200,model_name = config_name+\"_1.2_jpg_\", config_name = config_name, model=model)\n", + "path_res, model_name = prepare_and_learning_detection(num_classes = num_classes, num_samples = 10000, path_dataset = \"/mnt/data/Dataset_img\", \n", + " selected_freq=2400,model_name = config_name+\"_2.4_jpg_\", config_name = config_name, model=model)\n", "\n", "\n", "torch.cuda.empty_cache()\n", @@ -645,7 +453,7 @@ "metadata": { "celltoolbar": "Отсутствует", "kernelspec": { - "display_name": ".venv-train (3.12.3)", + "display_name": ".venv-train", "language": "python", "name": "python3" }, diff --git a/train_scripts/Training_models2pic.ipynb b/train_scripts/Training_models2pic.ipynb new file mode 100644 index 0000000..75cf800 --- /dev/null +++ b/train_scripts/Training_models2pic.ipynb @@ -0,0 +1,634 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "e1db882b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n", + " warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cuda\n" + ] + }, + { + "data": { + "text/plain": [ + "191" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from torch import default_generator, randperm\n", + "from torch.utils.data.dataset import Subset\n", + "import torchvision.transforms as transforms\n", + "from torchvision.io import read_image\n", + "from importlib import import_module\n", + "import matplotlib.pyplot as plt\n", + "from torchvision import models\n", + "import torch, torchvision\n", + "from pathlib import Path\n", + "from PIL import Image\n", + "import torch.nn as nn\n", + "from tqdm import tqdm\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib\n", + "import os, shutil\n", + "import mlconfig\n", + "import random\n", + "import shutil\n", + "import timeit\n", + "import copy\n", + "import time\n", + "import cv2\n", + "import csv\n", + "import sys\n", + "import io\n", + "import gc\n", + "\n", + "plt.rcParams[\"savefig.bbox\"] = 'tight'\n", + "torch.manual_seed(1)\n", + "#matplotlib.use('Agg')\n", + "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n", + "print(device)\n", + "torch.cuda.empty_cache()\n", + "cv2.destroyAllWindows()\n", + "gc.collect()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8e009995", + "metadata": {}, + "outputs": [], + "source": [ + "def prepare_and_learning_detection(num_classes, num_samples, path_dataset, model_name, config_name, model,selected_freq):\n", + " num_samples_per_class = num_samples // num_classes\n", + "\n", + " #----------Создаём папку для сохранения результатов обучения--------------\n", + " os.makedirs(\"models\", exist_ok=True)\n", + " ind = 1\n", + " while True:\n", + " if os.path.exists(\"models/\" + model_name + str(ind)):\n", + " ind += 1\n", + " else:\n", + " os.mkdir(\"models/\" + model_name + str(ind))\n", + " path_res = \"models/\" + model_name + str(ind) + '/'\n", + " break\n", + " \n", + " #----------Создаём файл dataset.csv для обучения--------------\n", + " \n", + " pd_columns = ['file_name']\n", + " df = pd.DataFrame(columns=pd_columns)\n", + " \n", + " subdirs = os.listdir(path_dataset)\n", + " \n", + " for subdir in subdirs:\n", + " freq_dir = os.path.join(path_dataset, subdir, str(selected_freq)+\"_jpg\")\n", + " if not os.path.isdir(freq_dir):\n", + " print(\"Error1\")\n", + " continue\n", + " \n", + " files_k=[f for f in os.listdir(freq_dir)]\n", + " print(len(files_k))\n", + " \n", + " files = [\n", + " f for f in os.listdir(freq_dir)\n", + " if os.path.isfile(os.path.join(freq_dir, f)) and f.endswith('imag.png')\n", + " ]\n", + " num_samples_per_class = min(num_samples_per_class, len(files))\n", + " print(f\"num_samples per class {subdir} is {num_samples_per_class}\")\n", + "\n", + " for subdir in subdirs:\n", + " freq_dir = os.path.join(path_dataset, subdir, str(selected_freq)+\"_jpg\")\n", + " if not os.path.isdir(freq_dir):\n", + " print(\"Error1\")\n", + " continue\n", + "\n", + " files = [\n", + " f for f in os.listdir(freq_dir)\n", + " if os.path.isfile(os.path.join(freq_dir, f)) and f.endswith('imag.png')\n", + " ]\n", + " random.shuffle(files)\n", + " files_to_process = files[:num_samples_per_class]\n", + "\n", + " for file in files_to_process:\n", + " row = pd.DataFrame({\n", + " pd_columns[0]: [str(os.path.join(freq_dir, file))]\n", + " })\n", + " df = pd.concat([df, row], ignore_index=True)\n", + "\n", + " dataset_csv_path = os.path.join(path_res, 'dataset.csv')\n", + " df.to_csv(dataset_csv_path, index=False)\n", + "\n", + " if not os.path.exists(dataset_csv_path):\n", + " raise RuntimeError(f'dataset.csv was not created: {dataset_csv_path}')\n", + " #----------Импортируем параметры для обучения--------------\n", + " \n", + " def load_function(attr):\n", + " module_, func = attr.rsplit('.', maxsplit=1)\n", + " return getattr(import_module(module_), func)\n", + " \n", + " config = mlconfig.load('config_' + config_name + '.yaml')\n", + " \n", + " #----------Создаём класс датасета--------------\n", + " \n", + " class MyDataset(Dataset):\n", + " def __init__(self, path_dataset, csv_file):\n", + " data=[]\n", + " with open(os.path.join(path_dataset, csv_file), newline='') as csvfile:\n", + " reader = csv.reader(csvfile, delimiter=' ', quotechar='|')\n", + " for row in list(reader)[1:]:\n", + " row = str(row)\n", + " data.append(row[2: len(row)-2])\n", + " self.sig_filenames = data\n", + " self.path_dataset = path_dataset\n", + " \n", + " def __len__(self):\n", + " return len(self.sig_filenames)\n", + " \n", + " def __getitem__(self, idx):\n", + " base = os.path.splitext(self.sig_filenames[idx])[0]\n", + " if base[-4:]==\"real\":\n", + " image_real = np.asarray(cv2.split(cv2.imread(base + '.png')), dtype=np.float32)\n", + " image_imag = np.asarray(cv2.split(cv2.imread(base[:-4] + 'imag.png')), dtype=np.float32)\n", + " if base[-4:]==\"imag\":\n", + " image_real = np.asarray(cv2.split(cv2.imread(base[:-4] + 'real.png')), dtype=np.float32)\n", + " image_imag = np.asarray(cv2.split(cv2.imread(base + '.png')), dtype=np.float32)\n", + " \n", + " \n", + " \n", + " if 'drone' in list(self.sig_filenames[idx].split('/')):\n", + " label = torch.tensor(0)\n", + " if 'noise' in list(self.sig_filenames[idx].split('/')):\n", + " label = torch.tensor(1)\n", + " return image_real, image_imag, label\n", + " \n", + " #----------Создаём датасет--------------\n", + " \n", + " dataset = MyDataset(path_dataset=path_res, csv_file='dataset.csv')\n", + " train_set, valid_set = torch.utils.data.random_split(dataset, [0.7, 0.3], generator=torch.Generator().manual_seed(42))\n", + " batch_size = config.batch_size\n", + " train_dataloader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True, drop_last=True)\n", + " valid_dataloader = torch.utils.data.DataLoader(valid_set, batch_size=batch_size, shuffle=True, drop_last=True)\n", + " \n", + " dataloaders = {}\n", + " dataloaders['train'] = train_dataloader\n", + " dataloaders['val'] = valid_dataloader\n", + " dataset_sizes = {}\n", + " dataset_sizes['train'] = len(train_set)\n", + " dataset_sizes['val'] = len(valid_set)\n", + "\n", + " #----------Обучаем модель--------------\n", + "\n", + " val_loss = []\n", + " val_acc = []\n", + " train_loss = []\n", + " train_acc = []\n", + " epochs = config.epoch\n", + " \n", + " best_acc = 0.0\n", + " best_model = copy.deepcopy(model.state_dict())\n", + " limit = config.limit\n", + " epoch_limit = epochs\n", + " \n", + " start = timeit.default_timer()\n", + " for epoch in range(1, epochs+1):\n", + " print(f\"Epoch : {epoch}\\n\")\n", + " dataloader = None\n", + " \n", + " for phase in ['train', 'val']:\n", + " running_loss = 0.0\n", + " running_corrects = 0\n", + " \n", + " for (img1, img2, label) in tqdm(dataloaders[phase]):\n", + " img1, img2, label = img1.to(device), img2.to(device), label.to(device)\n", + " optimizer.zero_grad()\n", + " \n", + " with torch.set_grad_enabled(phase == 'train'):\n", + " output = model([img1, img2])\n", + " _, pred = torch.max(output.data, 1)\n", + " loss = criterion(output, label)\n", + " if phase=='train' :\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " running_loss += loss.item() * 3 * img1.size(0)\n", + " running_corrects += torch.sum(pred == label.data)\n", + " \n", + " epoch_loss = running_loss / dataset_sizes[phase]\n", + " epoch_acc = running_corrects.double() / dataset_sizes[phase]\n", + " \n", + " print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))\n", + " \n", + " if phase=='train' :\n", + " train_loss.append(epoch_loss)\n", + " train_acc.append(epoch_acc)\n", + " else :\n", + " val_loss.append(epoch_loss)\n", + " val_acc.append(epoch_acc)\n", + " if val_acc[-1] > best_acc :\n", + " ind_limit = 0\n", + " best_acc = val_acc[-1]\n", + " best_model = copy.deepcopy(model.state_dict())\n", + " torch.save(best_model, path_res + model_name + '.pth')\n", + " else:\n", + " ind_limit += 1\n", + " \n", + " if ind_limit >= limit:\n", + " break\n", + " \n", + " if ind_limit >= limit:\n", + " epoch_limit = epoch\n", + " break\n", + " \n", + " print()\n", + " \n", + " end = timeit.default_timer()\n", + " print(f\"Total time elapsed = {end - start} seconds\")\n", + " epoch_limit += 1\n", + " \n", + " #----------Вывод графиков и сохранение результатов обучения--------------\n", + " \n", + " train_acc = np.asarray(list(map(lambda x: x.item(), train_acc)))\n", + " val_acc = np.asarray(list(map(lambda x: x.item(), val_acc)))\n", + " \n", + " np.save(path_res+'train_acc.npy', train_acc)\n", + " np.save(path_res+'val_acc.npy', val_acc)\n", + " np.save(path_res+'train_loss.npy', train_loss)\n", + " np.save(path_res+'val_loss.npy', val_loss)\n", + " \n", + " plt.figure()\n", + " plt.plot(range(1,epoch_limit), train_loss, color='blue')\n", + " plt.plot(range(1,epoch_limit), val_loss, color='red')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Loss') \n", + " \n", + " plt.title('Loss Curve')\n", + " plt.legend(['Train Loss', 'Validation Loss'])\n", + " plt.show()\n", + " plt.clf()\n", + " plt.cla()\n", + " plt.close()\n", + " \n", + " plt.figure()\n", + " plt.plot(range(1,epoch_limit), train_acc, color='blue')\n", + " plt.plot(range(1,epoch_limit), val_acc, color='red')\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Accuracy')\n", + " plt.title('Accuracy Curve')\n", + " plt.legend(['Train Accuracy', 'Validation Accuracy'])\n", + " plt.show()\n", + " \n", + " plt.clf()\n", + " plt.cla()\n", + " plt.close()\n", + " torch.cuda.empty_cache()\n", + " cv2.destroyAllWindows()\n", + " del model\n", + " gc.collect()\n", + "\n", + " return path_res, model_name" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "53717d63", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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", + "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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=None`.\n", + " warnings.warn(msg)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9520\n", + "num_samples per class noise is 2380\n", + "5060\n", + "num_samples per class drone is 1265\n", + "Epoch : 1\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████| 442/442 [01:44<00:00, 4.23it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.1155 Acc: 0.9870\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████| 189/189 [00:21<00:00, 8.83it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.0067 Acc: 0.9960\n", + "\n", + "Epoch : 2\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████| 442/442 [01:45<00:00, 4.17it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.0032 Acc: 0.9983\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████| 189/189 [00:22<00:00, 8.26it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.0027 Acc: 0.9960\n", + "\n", + "Epoch : 3\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████| 442/442 [01:45<00:00, 4.18it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.0014 Acc: 0.9983\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████| 189/189 [00:22<00:00, 8.24it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.0007 Acc: 0.9960\n", + "\n", + "Epoch : 4\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████| 442/442 [01:46<00:00, 4.17it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.0009 Acc: 0.9983\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████| 189/189 [00:22<00:00, 8.28it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.0007 Acc: 0.9960\n", + "\n", + "Epoch : 5\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████| 442/442 [01:46<00:00, 4.15it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.0005 Acc: 0.9983\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 189/189 [00:21<00:00, 8.62it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.0005 Acc: 0.9960\n", + "\n", + "Epoch : 6\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 442/442 [01:46<00:00, 4.17it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.0004 Acc: 0.9983\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 189/189 [00:22<00:00, 8.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.0003 Acc: 0.9960\n", + "Total time elapsed = 769.277186642983 seconds\n" + ] + }, + { + "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": { + "text/plain": [ + "67" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#----------Инициализируем модель и параметры обучения--------------\n", + "\n", + "torch.cuda.empty_cache()\n", + "cv2.destroyAllWindows()\n", + "gc.collect()\n", + "\n", + "config_name = \"ensemble\"\n", + " \n", + "def load_function(attr):\n", + " module_, func = attr.rsplit('.', maxsplit=1)\n", + " return getattr(import_module(module_), func)\n", + " \n", + "config = mlconfig.load('config_' + config_name + '.yaml')\n", + "\n", + "model1 = models.resnet18(pretrained=False)\n", + "model2 = models.resnet50(pretrained=False)\n", + "\n", + "num_classes = 2\n", + "\n", + "model1.fc = nn.Linear(model1.fc.in_features, num_classes)\n", + "model2.fc = nn.Linear(model2.fc.in_features, num_classes)\n", + "\n", + "class Ensemble(nn.Module):\n", + " def __init__(self, model1, model2):\n", + " super(Ensemble, self).__init__()\n", + " self.model1 = model1\n", + " self.model2 = model2\n", + " self.fc = nn.Linear(2 * num_classes, num_classes)\n", + "\n", + " def forward(self, x):\n", + " x1 = self.model1(x[0])\n", + " x2 = self.model2(x[1])\n", + " x = torch.cat((x1, x2), dim=1)\n", + " x = self.fc(x)\n", + " return x\n", + "model = Ensemble(model1, model2)\n", + "\n", + "optimizer = load_function(config.optimizer.name)(model.parameters(), lr=config.optimizer.lr)\n", + "criterion = load_function(config.loss_function.name)()\n", + "scheduler = load_function(config.scheduler.name)(optimizer, step_size=config.scheduler.step_size, gamma=config.scheduler.gamma)\n", + "\n", + "if device != 'cpu':\n", + " model = model.to(device)\n", + "\n", + "#----------Создания датасета и обучение модели--------------\n", + "\n", + "path_res, model_name = prepare_and_learning_detection(num_classes = num_classes, num_samples = 10000, path_dataset = \"/mnt/data/Dataset_img\", \n", + " selected_freq=2400,model_name = config_name+\"2400_\", config_name = config_name, model=model)\n", + "\n", + "\n", + "torch.cuda.empty_cache()\n", + "cv2.destroyAllWindows()\n", + "del model\n", + "gc.collect()" + ] + } + ], + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/train_scripts/create_dataset_overlay.py b/train_scripts/create_dataset_overlay.py new file mode 100755 index 0000000..6e44b1c --- /dev/null +++ b/train_scripts/create_dataset_overlay.py @@ -0,0 +1,217 @@ +#!/usr/bin/env python3 +import argparse +import csv +import os +import random +import shutil +from pathlib import Path + +import cv2 +import matplotlib +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import numpy as np +from tqdm import tqdm + + +DEFAULT_FREQS = (1200, 2400) +PNG_SUFFIXES = ("_real.png", "_imag.png", "_spec.png") + + +def parse_args(): + parser = argparse.ArgumentParser( + description=( + "Build a two-class image dataset with drone signatures overlaid on noise images. " + "The output is ready for Training_models2pic_val_loss.ipynb." + ) + ) + parser.add_argument("--drone-root", default="/mnt/data/Dataset/drone") + parser.add_argument("--noise-img-root", default="/mnt/data/Dataset_img/noise") + parser.add_argument("--output-root", default="/mnt/data/Dataset_overlay") + parser.add_argument("--freqs", default=",".join(str(v) for v in DEFAULT_FREQS)) + parser.add_argument("--alpha", type=float, default=1.0, help="Overlay strength: 1.0 keeps the darkest drone/noise pixels.") + parser.add_argument("--limit-per-freq", type=int, default=0, help="0 means use all available noise images per frequency.") + parser.add_argument("--seed", type=int, default=42) + parser.add_argument("--copy-noise", action="store_true", help="Copy noise files instead of hardlinking them.") + parser.add_argument("--overwrite", action="store_true") + parser.add_argument("--dry-run", action="store_true") + parser.add_argument("--no-progress", action="store_true", help="Disable tqdm progress bars.") + return parser.parse_args() + + +def parse_freqs(value): + return [int(item.strip()) for item in value.split(",") if item.strip()] + + +def collect_drone_npys(root, freq): + root = Path(root) + candidates = [] + candidates.extend((root / str(freq)).rglob("*.npy")) + candidates.extend((root / f"{freq}_jpg").glob("*.npy")) + return sorted({p for p in candidates if p.is_file()}) + + +def collect_noise_npys(root, freq): + root = Path(root) + candidates = [] + candidates.extend((root / f"{freq}_jpg").glob("*.npy")) + candidates.extend((root / str(freq)).rglob("*.npy")) + return sorted({p for p in candidates if p.is_file()}) + + +def load_image_tensor(path): + arr = np.load(path) + if arr.ndim == 2: + arr = np.stack([arr, arr, arr], axis=0) + if arr.ndim == 3 and arr.shape[-1] in (1, 3) and arr.shape[0] not in (1, 3): + arr = np.moveaxis(arr, -1, 0) + if arr.ndim != 3: + raise ValueError(f"expected 3D image tensor, got shape={arr.shape} path={path}") + if arr.shape[0] == 1: + arr = np.repeat(arr, 3, axis=0) + if arr.shape[0] < 3: + raise ValueError(f"expected at least 3 channels, got shape={arr.shape} path={path}") + return arr[:3].astype(np.float32, copy=False) + + +def resize_like(arr, shape): + if arr.shape == shape: + return arr + channels, height, width = shape + resized = [] + for channel in arr[:channels]: + resized.append(cv2.resize(channel, (width, height), interpolation=cv2.INTER_LINEAR)) + return np.asarray(resized, dtype=np.float32) + + +def overlay_tensors(noise, drone, alpha): + drone = resize_like(drone, noise.shape) + bright_overlay = np.minimum(noise, drone) + mixed = (1.0 - alpha) * noise + alpha * bright_overlay + return np.clip(mixed, 0, 255).astype(np.float32) + + +def to_uint8(channel): + arr = np.asarray(channel, dtype=np.float32) + finite = arr[np.isfinite(arr)] + if finite.size == 0: + return np.zeros(arr.shape, dtype=np.uint8) + min_v = float(finite.min()) + max_v = float(finite.max()) + if min_v >= 0.0 and max_v <= 255.0: + return np.clip(arr, 0, 255).astype(np.uint8) + if max_v == min_v: + return np.zeros(arr.shape, dtype=np.uint8) + norm = (arr - min_v) / (max_v - min_v) + return np.clip(norm * 255.0, 0, 255).astype(np.uint8) + + +def save_notebook_style_png(path, channel): + fig = plt.figure(figsize=(16, 16)) + plt.imshow(channel) + plt.savefig(path) + plt.clf() + plt.cla() + plt.close() + plt.close(fig) + + +def save_sample(base_path, tensor): + np.save(str(base_path) + ".npy", tensor.astype(np.float32)) + for idx, suffix in enumerate(PNG_SUFFIXES): + save_notebook_style_png(str(base_path) + suffix, tensor[idx]) + + +def link_or_copy(src, dst, copy_file): + dst.parent.mkdir(parents=True, exist_ok=True) + if dst.exists(): + return + if copy_file: + shutil.copy2(src, dst) + return + try: + os.link(src, dst) + except OSError: + shutil.copy2(src, dst) + + +def copy_noise_family(noise_npy, out_dir, copy_file): + base_name = noise_npy.name[:-4] if noise_npy.name.endswith(".npy") else noise_npy.name + link_or_copy(noise_npy, out_dir / noise_npy.name, copy_file) + for suffix in PNG_SUFFIXES: + sidecar = noise_npy.with_name(base_name + suffix) + if sidecar.exists(): + link_or_copy(sidecar, out_dir / sidecar.name, copy_file) + + +def main(): + args = parse_args() + random.seed(args.seed) + freqs = parse_freqs(args.freqs) + output_root = Path(args.output_root) + manifest_rows = [] + + if args.overwrite and output_root.exists() and not args.dry_run: + shutil.rmtree(output_root) + + for freq in freqs: + drone_files = collect_drone_npys(args.drone_root, freq) + noise_files = collect_noise_npys(args.noise_img_root, freq) + if not drone_files: + raise RuntimeError(f"no drone npy files found for freq={freq} under {args.drone_root}") + if not noise_files: + raise RuntimeError(f"no noise image npy files found for freq={freq} under {args.noise_img_root}") + + count = len(noise_files) if args.limit_per_freq <= 0 else min(args.limit_per_freq, len(noise_files)) + selected_noise = noise_files[:] + random.shuffle(selected_noise) + selected_noise = selected_noise[:count] + + out_drone_dir = output_root / "drone" / f"{freq}_jpg" + out_noise_dir = output_root / "noise" / f"{freq}_jpg" + + print(f"freq={freq}: drone_source={len(drone_files)} noise_source={len(noise_files)} output_per_class={count}") + if args.dry_run: + continue + + out_drone_dir.mkdir(parents=True, exist_ok=True) + out_noise_dir.mkdir(parents=True, exist_ok=True) + + iterator = tqdm( + enumerate(selected_noise), + total=count, + desc=f"overlay freq={freq}", + unit="sample", + disable=args.no_progress, + ) + for idx, noise_path in iterator: + drone_path = drone_files[idx % len(drone_files)] + noise_tensor = load_image_tensor(noise_path) + drone_tensor = load_image_tensor(drone_path) + mixed = overlay_tensors(noise_tensor, drone_tensor, args.alpha) + + out_base = out_drone_dir / f"overlay_{freq}_{idx:06d}" + save_sample(out_base, mixed) + copy_noise_family(noise_path, out_noise_dir, args.copy_noise) + + manifest_rows.append({ + "freq": freq, + "output": str(out_base) + ".npy", + "noise_source": str(noise_path), + "drone_source": str(drone_path), + "alpha": args.alpha, + }) + + if not args.dry_run: + manifest_path = output_root / "overlay_manifest.csv" + with manifest_path.open("w", newline="", encoding="utf-8") as fh: + writer = csv.DictWriter(fh, fieldnames=["freq", "output", "noise_source", "drone_source", "alpha"]) + writer.writeheader() + writer.writerows(manifest_rows) + print(f"wrote {len(manifest_rows)} overlay samples") + print(f"manifest: {manifest_path}") + print(f"dataset: {output_root}") + + +if __name__ == "__main__": + main() diff --git a/train_scripts/models/ensemble_1.2_jpg_10/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_10/dataset.csv deleted file mode 100644 index bc276d4..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_10/dataset.csv +++ /dev/null @@ -1,964 +0,0 @@ -file_name -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1261.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_333.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_53.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_933.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_81.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_193.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_419.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1440.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_501.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_475.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_981.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_837.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_880.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_150.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1802.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_363.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_360.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_161.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_199.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_43.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1275.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_54.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_833.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_459.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1814.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_338.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_451.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_414.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_968.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_328.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1243.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_64.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_8.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1826.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_444.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_842.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_779.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_847.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1250.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_903.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_455.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_406.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_778.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1341.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_751.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_44.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_511.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_743.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_888.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_497.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1805.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1821.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_194.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_875.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1279.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_25.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_366.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_885.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_912.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_473.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_828.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_740.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_492.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1455.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_97.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1357.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_135.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1292.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1778.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_483.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_493.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_21.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_498.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_973.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_373.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_907.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1380.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1329.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_958.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_860.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_179.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1818.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_49.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_780.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_314.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_951.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1427.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_756.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_400.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_307.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_99.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_89.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1255.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1378.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_389.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_770.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_446.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_437.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_937.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_369.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_883.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_499.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_515.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1372.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_128.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_476.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_915.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1286.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_959.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_61.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_832.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_836.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1823.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1807.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1409.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1245.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_929.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_336.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_433.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1320.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1825.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_935.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1801.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_500.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1309.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_480.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_442.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1267.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_965.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_412.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1405.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1343.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_416.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1411.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_417.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_384.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_116.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_491.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1434.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_733.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1448.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_471.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1780.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1340.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_144.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_126.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_140.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_859.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1333.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_784.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1824.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_5.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_4.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_36.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_908.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_477.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_801.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_466.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_109.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_824.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_825.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_16.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_771.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1373.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1314.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_900.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_404.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_808.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_441.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_435.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_881.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1235.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1306.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_797.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_851.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1307.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_130.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_330.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_826.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_159.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1244.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_149.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_66.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_760.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1812.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1797.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1226.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_308.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1330.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_465.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_753.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_931.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_821.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_205.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_69.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_90.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1442.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1392.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1410.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1456.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_35.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_168.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1257.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_479.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_869.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1384.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_458.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_754.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_984.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_979.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_735.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_325.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1272.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_985.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_834.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1280.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_85.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_884.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1241.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_42.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1274.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1349.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_827.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1396.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_502.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1789.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_899.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1297.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_142.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1352.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1772.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1435.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_844.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_153.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_70.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1777.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1326.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_909.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_157.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1438.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_349.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_204.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_403.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_347.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_861.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1385.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_20.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1822.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_310.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_505.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_858.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_344.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1322.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_445.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_134.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1381.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_852.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_391.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_341.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_960.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_901.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_758.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_831.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_507.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1429.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_486.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1783.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_878.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_132.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_450.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_164.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_320.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_434.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_197.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1369.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_350.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_854.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_12.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_358.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1779.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_313.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_790.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1315.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1360.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_795.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_469.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_764.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1334.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_916.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_38.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_440.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_383.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_180.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1398.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_169.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1449.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_773.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_430.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_806.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_815.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_729.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1236.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_864.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_346.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_944.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_72.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1366.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1246.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_156.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_22.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_182.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_68.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_882.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_106.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_186.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_810.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_436.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_27.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_478.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_848.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1231.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1337.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1324.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_845.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_387.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_438.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_129.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_814.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1239.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_332.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1294.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1444.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_902.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1224.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_18.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_28.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_474.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_971.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1412.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_23.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1262.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_335.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1785.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_898.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1356.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_362.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1443.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_396.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_381.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_13.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_58.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_408.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_51.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_811.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_393.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_65.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1281.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_407.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_490.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1273.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1424.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1269.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1259.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_983.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1790.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1339.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_9.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_113.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_425.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_146.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1225.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1445.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_356.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_399.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1287.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1342.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1382.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_829.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_772.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_865.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_187.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_46.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1348.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1303.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_203.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_911.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_122.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_482.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1419.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_942.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1408.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_820.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_105.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1828.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1436.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_120.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_736.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_429.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1403.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1452.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_467.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1251.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_422.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_319.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_495.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_956.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1776.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_83.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_966.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_781.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_428.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_452.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_37.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_755.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_757.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_30.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_155.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_786.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1389.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_78.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_111.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_809.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_131.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_361.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_782.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1371.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_962.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_928.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1407.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_930.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_463.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1361.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_424.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_394.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1390.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1377.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_472.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_411.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1454.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1238.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1282.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_886.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_812.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1256.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_862.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_787.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1794.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1325.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1432.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1363.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_67.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_76.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1800.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_410.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1816.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_817.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_785.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1304.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_2.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1283.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_59.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_950.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1817.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1295.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_379.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_374.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_192.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_342.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_974.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_73.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_800.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1317.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1383.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1331.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_167.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_891.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_3.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_160.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_201.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1347.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1323.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_513.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_481.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_162.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_896.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_439.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_367.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_506.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_166.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1827.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_206.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1387.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1299.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_910.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_395.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_124.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1451.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_352.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_29.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_857.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_94.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_747.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_202.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_62.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_165.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_955.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_40.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1417.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_10.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_200.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_863.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_151.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_462.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_39.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_976.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_895.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1811.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_55.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_110.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1351.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1300.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1426.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_485.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_34.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1254.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_893.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_191.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_849.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_431.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1242.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_121.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_101.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1420.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_60.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_207.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_119.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_783.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_92.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_748.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_823.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_334.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1370.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_957.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1284.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1365.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1368.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_329.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_514.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_98.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_830.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1804.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_954.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1264.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1414.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_376.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_775.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_388.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_163.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_324.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1327.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1318.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_917.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1290.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_972.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1437.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_26.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_876.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_759.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_918.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_835.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_850.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_32.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_802.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1277.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_74.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_734.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_742.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_977.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_923.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_108.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_327.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_807.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_114.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1319.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_91.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_198.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_813.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_368.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_461.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_796.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_426.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_326.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1421.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1311.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_749.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_19.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1379.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1397.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_453.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_96.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_33.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1271.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_402.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_311.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1345.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_970.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_93.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1815.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_88.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_371.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_767.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_975.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_372.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_938.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_853.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_894.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_79.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_752.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1404.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1353.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_732.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_184.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_323.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_961.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1258.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_792.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_777.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_765.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1316.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_107.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_147.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_804.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_304.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_978.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_762.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_840.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1228.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1232.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1302.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_148.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1792.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_351.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_154.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1313.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_949.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1268.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1781.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_185.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_731.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_741.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1293.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1233.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_138.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_737.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1346.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_488.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1394.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_7.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_927.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_871.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_943.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_941.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_868.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_45.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_468.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_774.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_48.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_919.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1820.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1431.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_504.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1796.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1810.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_353.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_738.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_322.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_82.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1237.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_136.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_87.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_380.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_897.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1400.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_17.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_95.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_143.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_791.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1799.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_924.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_343.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_867.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_872.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_370.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1375.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1247.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1344.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_123.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1406.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_139.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_24.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_874.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1782.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_822.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_102.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1386.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_302.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_0.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_71.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_856.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1321.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_421.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1775.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1430.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_460.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1332.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_873.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1355.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_409.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_397.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_905.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_727.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_117.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_805.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1788.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_398.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1359.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1301.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1252.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1362.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_57.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_420.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_382.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_793.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_127.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1803.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_103.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_879.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_945.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1308.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_798.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_789.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_359.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1358.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1374.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_63.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1376.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_510.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_969.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_494.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_11.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_50.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_375.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1266.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_77.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1447.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1441.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1336.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_443.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_390.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1270.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_803.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_385.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_321.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1439.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_354.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_470.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1401.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_337.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_746.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1248.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_305.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_115.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_75.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_904.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_769.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1457.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_183.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1263.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_331.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_345.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_952.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1249.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_6.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_889.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_31.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1305.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_315.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_750.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_301.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1422.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_137.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1298.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1253.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1230.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_866.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_982.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_364.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_763.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_418.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_348.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_449.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1354.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1388.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1819.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1415.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1291.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_340.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1791.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_925.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_14.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_15.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_41.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_766.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_892.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_788.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_312.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_355.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1829.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1278.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1260.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_946.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1350.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_84.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_306.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_100.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_118.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_52.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_196.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_303.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_181.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1786.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_739.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_309.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1798.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_508.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_152.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_489.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_887.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_794.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_86.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1806.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_843.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_457.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_819.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_768.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1402.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_934.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_838.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_339.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_378.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1335.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_914.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1453.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1425.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1240.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_940.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_846.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_456.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_920.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1423.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_906.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_744.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1793.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_145.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_936.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1310.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1229.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1446.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_487.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_405.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1338.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1393.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1413.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_503.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_730.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_454.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_377.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_728.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_818.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_415.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1328.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_980.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1265.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_447.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_496.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_855.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_745.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_316.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_401.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_816.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_932.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_509.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1296.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1433.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1774.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1809.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_158.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_464.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_761.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1288.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_922.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_413.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_392.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1289.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_141.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_133.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1450.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_967.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_877.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1773.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_125.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_365.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_318.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1367.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_841.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_776.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_178.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1813.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_512.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_953.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1787.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_47.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_926.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1808.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_317.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_484.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_357.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_947.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_839.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1285.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1234.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_799.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1784.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_432.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_56.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1395.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_104.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_870.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_963.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_427.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_423.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1428.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_386.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_913.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1364.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_939.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1416.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1418.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_948.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_112.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_195.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1391.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1795.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_921.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_80.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1312.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1276.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1227.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1399.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_448.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_964.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_890.npy.npy diff --git a/train_scripts/models/ensemble_1.2_jpg_11/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_11/dataset.csv deleted file mode 100644 index 4561abb..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_11/dataset.csv +++ /dev/null @@ -1,964 +0,0 @@ -file_name -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1258.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_890.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1780.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_362.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_166.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_754.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_780.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1401.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1811.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_854.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_178.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1804.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_818.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_441.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_372.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_333.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1304.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1799.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_428.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_506.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_163.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_497.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1411.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_425.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_459.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1358.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_482.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_968.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1337.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_496.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_842.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1353.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_808.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_90.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_961.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_128.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_32.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_474.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_918.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_738.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_964.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_135.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_744.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_883.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_162.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_316.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1395.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1280.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_764.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_866.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_835.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_479.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_783.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_151.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_838.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_779.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_909.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1237.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_943.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_156.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_311.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_8.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_806.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_402.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_481.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_962.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_50.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_819.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_421.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1447.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_200.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1362.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1446.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_805.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_832.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_14.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_13.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1373.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_371.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_515.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1444.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_797.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_326.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_929.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_180.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_917.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_955.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_827.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1805.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_184.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1386.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_21.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1440.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_420.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_795.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_345.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_504.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_114.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_375.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_383.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_954.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_355.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_849.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_817.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1292.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_386.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_191.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_467.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1414.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1404.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_824.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1775.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_946.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_739.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_36.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1308.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_382.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_462.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_123.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_390.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_387.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1807.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1406.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_353.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_446.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_912.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1423.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_951.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_429.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_887.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_937.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1824.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_830.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_348.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_424.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1431.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_380.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1393.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_131.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1230.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_411.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1227.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_320.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_899.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1416.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_67.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_182.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_907.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_765.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_406.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_939.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1425.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_352.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_126.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_15.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1343.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_407.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1409.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_748.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_72.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_106.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_816.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_511.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_392.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1823.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_360.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_404.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1389.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_92.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1275.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1364.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1336.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_882.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1298.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_31.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1817.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_510.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_144.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_314.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1347.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_330.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1344.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_760.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1787.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1399.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_306.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_388.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1369.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_44.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_729.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_340.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1809.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_98.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_80.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1352.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_847.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_139.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_401.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_47.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_860.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1436.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_821.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1428.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_397.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_449.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_329.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_845.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_99.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_39.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1786.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_303.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1357.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1360.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1264.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_447.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_746.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1410.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1330.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1814.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_75.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_958.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_349.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1417.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_494.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_53.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_960.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1225.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_86.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1795.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_919.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_37.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_452.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_498.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_859.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_341.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_57.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_444.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_136.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_507.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_508.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_374.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_395.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_898.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_980.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_485.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_42.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_851.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1327.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1350.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_470.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1276.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_204.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_321.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_758.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_920.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_83.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_34.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_186.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_776.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1248.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_751.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_207.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_130.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_502.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_38.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_361.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_736.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1260.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_886.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_196.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_367.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_158.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_319.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1412.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_179.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_843.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_796.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1351.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_74.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_430.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_893.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_500.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_159.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1813.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_801.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_873.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1374.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_152.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_51.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1449.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_343.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_62.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1290.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_30.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1398.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1456.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_941.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_9.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_458.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_59.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_837.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_435.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_307.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_120.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_793.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_60.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1257.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_185.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_457.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_503.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1403.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_804.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1437.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1310.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_85.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_305.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_150.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_137.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_863.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_985.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_2.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_836.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1300.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_164.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_813.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_768.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_865.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_913.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_318.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1778.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1287.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_914.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_923.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1822.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_756.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_488.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_512.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1796.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1321.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1777.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_111.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1311.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1421.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_761.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1808.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_16.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_869.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1328.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1326.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_398.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_461.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_23.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_875.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_168.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_433.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1251.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_921.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_165.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1812.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_928.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_335.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_133.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1235.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_342.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1245.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_456.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_489.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_115.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_463.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_143.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_149.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1323.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_206.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1791.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1241.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_978.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_325.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_877.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_472.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_774.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_902.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_938.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_377.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1246.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_358.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1265.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1453.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_740.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_499.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1319.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1450.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_925.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_426.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1256.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_922.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1429.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1296.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_789.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_142.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_187.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_45.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_413.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_916.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_49.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_391.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_0.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_181.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_91.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_344.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1339.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_61.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1826.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_731.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1402.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1806.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_769.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1281.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_192.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_28.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_116.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1259.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_312.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_417.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_811.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_369.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_767.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_448.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_932.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1232.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_743.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1371.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_895.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_434.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_878.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1419.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_427.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1819.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1262.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_466.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1366.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_905.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1438.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_778.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_455.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_880.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1427.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_927.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1242.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_495.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1443.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_953.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1375.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1789.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_112.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_834.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1279.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_96.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_803.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1293.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1228.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1354.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1334.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_867.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_831.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_442.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_464.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1377.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_966.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1372.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_889.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_897.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_40.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_900.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_101.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_825.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_436.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_22.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_408.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1829.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_965.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_117.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_65.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_840.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_812.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1324.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1783.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_122.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1305.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1793.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_393.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_844.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_105.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_205.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_41.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_826.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_766.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_940.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1828.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_981.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1779.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1396.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_141.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_302.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1384.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_87.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_203.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_876.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_104.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_734.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_870.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_460.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_25.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1413.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_107.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_926.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_815.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_450.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1773.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_437.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1782.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_931.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1294.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_351.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_947.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_888.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_728.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_422.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_118.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_157.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_147.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_901.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_95.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_792.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1355.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_416.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_19.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_791.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1238.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_892.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_17.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_759.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_983.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_93.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_509.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_109.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1239.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_800.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1309.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1359.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_755.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_957.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_322.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_952.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_84.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_129.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_119.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1333.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1307.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_323.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1397.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1253.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_451.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_752.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1381.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1435.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_100.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1442.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_194.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1340.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1301.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_338.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_195.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1229.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_378.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1394.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_486.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_833.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1408.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_385.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_346.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_747.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1289.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1451.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1233.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_336.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1356.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_948.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_20.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1269.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_959.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1317.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1341.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_807.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_58.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_52.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_432.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_839.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1422.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_782.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1801.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1810.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_313.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_33.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1297.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_443.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_331.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1378.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_125.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1342.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_27.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1430.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1790.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_862.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1338.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1254.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_477.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1426.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_492.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_872.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_820.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_110.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1236.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_868.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1348.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_772.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_108.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1303.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_737.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_405.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_423.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_794.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_394.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1313.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_970.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_77.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1452.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_790.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_483.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_82.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_490.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_121.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1800.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1792.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1325.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1306.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_359.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1277.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_484.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_468.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_410.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_160.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1231.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_473.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_493.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_809.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_858.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_373.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_788.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_969.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_911.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_802.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_975.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_846.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1434.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_94.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1244.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_950.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_505.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1240.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1424.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_69.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_379.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_749.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_885.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_71.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_10.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_350.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_376.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_810.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_967.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_347.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_785.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_370.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1314.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_140.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_852.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_848.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_487.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_54.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_24.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1266.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_148.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_763.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1252.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_798.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_29.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_97.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1335.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1415.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_88.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_841.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1827.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_183.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_514.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_963.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1433.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_727.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1295.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_202.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1255.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_735.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_786.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_480.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1250.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_366.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_414.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_103.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1349.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1261.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1391.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_364.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_363.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_56.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1286.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1267.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_879.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1785.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_864.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1821.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_12.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1263.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_5.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1322.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_770.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_412.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_368.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1400.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_757.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1802.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_935.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_155.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1302.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_43.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1316.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_742.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_339.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_146.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_18.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_198.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1270.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_134.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_73.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1818.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_857.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_979.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1383.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_933.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1272.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1284.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_903.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_357.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_945.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_465.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_356.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_400.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1291.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_419.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1772.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1388.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1318.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1346.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1370.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_773.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_891.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_332.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_127.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1788.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_750.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1382.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_384.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1420.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_753.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1249.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_102.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_7.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1278.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1361.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1455.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1784.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_781.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_822.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_469.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_762.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_874.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_324.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1243.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_984.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1224.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_775.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_396.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1407.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_942.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_310.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1331.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_513.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_501.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_894.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_930.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_491.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1797.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_169.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_476.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_977.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_46.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1815.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_777.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_944.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1441.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_973.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1798.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_881.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_850.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_915.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_853.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_787.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1376.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1320.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_6.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_956.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_55.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_328.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_855.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_784.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1445.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1803.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_949.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1329.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_884.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_403.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_138.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1345.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_68.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_389.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_445.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_934.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1282.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_301.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_936.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1439.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1283.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1781.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_478.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_828.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_733.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_365.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1271.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1299.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_418.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1363.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1457.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_3.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_317.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_315.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_475.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1454.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_76.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_193.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1268.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_337.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_976.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_908.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_48.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_124.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1332.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_26.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_896.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_910.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1387.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_439.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1367.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1226.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_145.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_167.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1448.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_354.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1390.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_70.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1273.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1288.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1405.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_201.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_982.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_829.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_906.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_64.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_304.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1825.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_161.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_741.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_924.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_113.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1432.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_399.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_4.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_454.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_814.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_972.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_861.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1774.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1368.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1315.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_199.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1794.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1274.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_89.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_381.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_153.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1380.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_81.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1385.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_440.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1816.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1418.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_904.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_823.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1379.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_799.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_732.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1285.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_308.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_154.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_11.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_438.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_309.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_415.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1365.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1247.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_856.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_453.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_971.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1820.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_431.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_471.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_197.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1776.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_409.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_327.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_66.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1234.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_771.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_35.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_132.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_974.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_871.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_334.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_78.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1312.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_745.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_79.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1392.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_730.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_63.npy.npy diff --git a/train_scripts/models/ensemble_1.2_jpg_11/ensemble_1.2_jpg_.pth b/train_scripts/models/ensemble_1.2_jpg_11/ensemble_1.2_jpg_.pth deleted file mode 100644 index e07b602..0000000 Binary files a/train_scripts/models/ensemble_1.2_jpg_11/ensemble_1.2_jpg_.pth and /dev/null differ diff --git a/train_scripts/models/ensemble_1.2_jpg_11/train_acc.npy b/train_scripts/models/ensemble_1.2_jpg_11/train_acc.npy deleted file mode 100644 index 3a49a34..0000000 Binary files a/train_scripts/models/ensemble_1.2_jpg_11/train_acc.npy and /dev/null differ diff --git a/train_scripts/models/ensemble_1.2_jpg_11/train_loss.npy b/train_scripts/models/ensemble_1.2_jpg_11/train_loss.npy deleted file mode 100644 index 15f34ac..0000000 Binary files a/train_scripts/models/ensemble_1.2_jpg_11/train_loss.npy and /dev/null differ diff --git a/train_scripts/models/ensemble_1.2_jpg_11/val_acc.npy b/train_scripts/models/ensemble_1.2_jpg_11/val_acc.npy deleted file mode 100644 index cc6612e..0000000 Binary files a/train_scripts/models/ensemble_1.2_jpg_11/val_acc.npy and /dev/null differ diff --git a/train_scripts/models/ensemble_1.2_jpg_11/val_loss.npy b/train_scripts/models/ensemble_1.2_jpg_11/val_loss.npy deleted file mode 100644 index 44d2935..0000000 Binary files a/train_scripts/models/ensemble_1.2_jpg_11/val_loss.npy and /dev/null differ diff --git a/train_scripts/models/ensemble_1.2_jpg_2/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_2/dataset.csv deleted file mode 100644 index 2b5147b..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_2/dataset.csv +++ /dev/null @@ -1 +0,0 @@ -file_name diff --git a/train_scripts/models/ensemble_1.2_jpg_3/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_3/dataset.csv deleted file mode 100644 index 2b5147b..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_3/dataset.csv +++ /dev/null @@ -1 +0,0 @@ -file_name diff --git a/train_scripts/models/ensemble_1.2_jpg_4/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_4/dataset.csv deleted file mode 100644 index 2b5147b..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_4/dataset.csv +++ /dev/null @@ -1 +0,0 @@ -file_name diff --git a/train_scripts/models/ensemble_1.2_jpg_5/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_5/dataset.csv deleted file mode 100644 index 2b5147b..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_5/dataset.csv +++ /dev/null @@ -1 +0,0 @@ -file_name diff --git a/train_scripts/models/ensemble_1.2_jpg_6/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_6/dataset.csv deleted file mode 100644 index 2b5147b..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_6/dataset.csv +++ /dev/null @@ -1 +0,0 @@ -file_name diff --git a/train_scripts/models/ensemble_1.2_jpg_7/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_7/dataset.csv deleted file mode 100644 index 2b5147b..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_7/dataset.csv +++ /dev/null @@ -1 +0,0 @@ -file_name diff --git a/train_scripts/models/ensemble_1.2_jpg_8/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_8/dataset.csv deleted file mode 100644 index 2b5147b..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_8/dataset.csv +++ /dev/null @@ -1 +0,0 @@ -file_name diff --git a/train_scripts/models/ensemble_1.2_jpg_9/dataset.csv b/train_scripts/models/ensemble_1.2_jpg_9/dataset.csv deleted file mode 100644 index 61c4412..0000000 --- a/train_scripts/models/ensemble_1.2_jpg_9/dataset.csv +++ /dev/null @@ -1,964 +0,0 @@ -file_name -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_443.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_183.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_403.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_163.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_349.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_922.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_830.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_893.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_386.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1774.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1224.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_780.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_482.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_38.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1301.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_503.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_848.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_881.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_195.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1431.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_793.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1808.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_819.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_484.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1392.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1324.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_2.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_890.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_974.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_395.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_91.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_43.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_151.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1288.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_917.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_382.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_814.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1383.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1275.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_125.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1351.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1449.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_847.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_131.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_414.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_868.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1293.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_448.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_312.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_795.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1294.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_486.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_182.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1243.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1791.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1323.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_978.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1785.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_970.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_192.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_872.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_100.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1304.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1415.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1309.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1245.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1322.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1816.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1442.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1367.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1260.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1452.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_411.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_843.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1377.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1412.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_962.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_185.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_308.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_383.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_729.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_773.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_870.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_52.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_417.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1432.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1292.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_54.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1819.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1378.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1315.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_318.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_108.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1249.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_439.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_864.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_80.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1800.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_451.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1405.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_373.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_378.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1346.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1335.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_849.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1799.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_730.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_0.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_740.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_950.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_968.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_836.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_809.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1368.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1451.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1433.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_311.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_502.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_113.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1790.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1350.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_14.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_24.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_951.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1289.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_415.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_902.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_426.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1341.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1826.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_757.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1406.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_133.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_11.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_831.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_167.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1359.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_70.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_76.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_48.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_943.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_110.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_820.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_8.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_731.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_846.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_481.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1328.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_980.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1361.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_60.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_138.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1330.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_910.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_148.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_733.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1334.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_10.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1435.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1313.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_472.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_877.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_908.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_901.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1266.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_315.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_84.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_776.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1332.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1354.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_940.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_401.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1329.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1804.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_63.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_181.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_891.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_37.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_932.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_322.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1455.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_61.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1797.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1331.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1262.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_926.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_959.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_127.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_40.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_385.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_826.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_31.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1296.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_973.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_480.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_865.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_966.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_958.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_343.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_827.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_744.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_434.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_77.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_119.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_894.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_909.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_436.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_369.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_497.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_126.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_29.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_418.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1318.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_420.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_874.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_205.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_811.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_858.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_20.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1272.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_323.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_45.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_327.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_357.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_845.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_916.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_953.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1298.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1299.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_783.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1306.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_307.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_69.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1823.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_356.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_348.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_155.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_412.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_316.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_821.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_756.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1775.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_326.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_147.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_930.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1815.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1443.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1440.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_918.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_90.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_186.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1801.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_850.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_180.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_961.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_98.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_317.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_828.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1430.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1286.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_504.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1233.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_812.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_483.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1307.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_179.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_474.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_46.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_4.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1278.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1393.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_361.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_882.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_166.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_99.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_198.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_306.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1402.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_899.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_907.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_863.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1254.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_861.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_202.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_490.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_377.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_409.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1300.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_897.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1250.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_912.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1454.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1409.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_808.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_7.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1240.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_204.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1407.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_71.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_768.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_765.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_952.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1287.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_905.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_25.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_461.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1283.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_117.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_946.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1226.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_68.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_491.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_458.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_353.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_338.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1339.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_772.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_860.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_83.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1348.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_732.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_360.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_141.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_364.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1347.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_487.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_366.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_388.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1234.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_466.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_320.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_109.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1338.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_118.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1434.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_787.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_337.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_515.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1295.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_379.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1410.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_421.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_358.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_62.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1271.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1242.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_825.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_324.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_920.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1413.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_450.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1411.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_302.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1794.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_914.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_906.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1382.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1357.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_470.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_50.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1356.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_876.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_835.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1389.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_840.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1265.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_784.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_87.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_816.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_494.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1362.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_479.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_896.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_507.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1388.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_67.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_498.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_866.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1380.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1305.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_747.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_977.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_106.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_132.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_346.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1387.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_146.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_428.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_755.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_342.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_32.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_365.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_471.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1239.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_339.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1230.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_423.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_786.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1811.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_880.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_929.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_65.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1227.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_921.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_938.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1337.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_154.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1438.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_791.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1238.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_945.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1371.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_161.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_329.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1384.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_473.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_788.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_95.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_129.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_469.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_394.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_855.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_944.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1798.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1813.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_200.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1369.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_404.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_936.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1400.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_981.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_303.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_44.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_82.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_781.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_782.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_355.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_738.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_55.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1822.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_513.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_112.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_124.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_856.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_749.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1342.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_465.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1394.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1439.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_207.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_785.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_325.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1437.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1404.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_751.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1302.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_64.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_734.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_904.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_511.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_889.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_424.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1776.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_122.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1386.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1817.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_468.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1333.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1399.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_442.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_802.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_832.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_397.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1788.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_430.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_145.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_767.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1320.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1277.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1803.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_960.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_984.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_937.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_96.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1810.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_115.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_508.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_867.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_341.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_375.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1436.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_105.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_197.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_778.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_965.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1379.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1235.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_892.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_413.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_362.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_396.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_815.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_301.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_963.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1316.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1786.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_898.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_78.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_399.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_829.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_144.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1343.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1818.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_86.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_883.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1425.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1241.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_967.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1358.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_759.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_805.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_330.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_432.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_89.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1448.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_387.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_851.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1228.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_381.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_380.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_114.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_56.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_16.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_485.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1787.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_26.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1418.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1268.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1267.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_931.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1420.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_763.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_478.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_752.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_168.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_107.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_505.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_956.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1336.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_496.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_332.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1276.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_199.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1772.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_463.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_139.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_390.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_728.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_495.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_367.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_822.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1773.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1261.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_878.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1229.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_790.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_433.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1258.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_441.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_939.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_328.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_493.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1403.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_467.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1809.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_879.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1423.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_903.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_979.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_873.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1802.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_392.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1363.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_823.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_152.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_975.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1447.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1280.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_331.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1821.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1327.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_304.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_352.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_19.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_319.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1303.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1284.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_875.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1398.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_410.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1456.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_169.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1370.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_22.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1257.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_350.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_347.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_871.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1419.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_794.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_72.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1353.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_81.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_427.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1256.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_102.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1395.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1312.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_862.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1344.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_806.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_93.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_143.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_810.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_735.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_23.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_919.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1795.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_345.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1248.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1269.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_184.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1780.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_39.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1251.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_47.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_770.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1824.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_727.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_391.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_985.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1784.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_475.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1807.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_976.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_85.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_813.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_21.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_398.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_746.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_120.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_771.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1263.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_736.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_111.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_887.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_158.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_18.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_393.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_512.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1317.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1390.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_969.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_745.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1308.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_17.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_49.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_196.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_59.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_447.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_964.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1397.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_134.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1427.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_789.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_454.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1225.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1340.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_305.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_431.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_748.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_954.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_800.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1781.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_79.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1777.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1273.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_807.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_462.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_101.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_775.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_933.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_499.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1792.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_123.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1385.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1806.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_971.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_492.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_41.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_799.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_74.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_66.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_948.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1376.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1457.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_798.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_947.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_949.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_309.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1424.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_28.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_750.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1396.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_340.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_9.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1453.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1365.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_359.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_488.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_455.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_335.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1325.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_869.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_453.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_927.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1319.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_444.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_983.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_333.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_178.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_165.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_310.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_164.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_501.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_446.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_376.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1231.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_818.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_895.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1391.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_506.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1416.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_162.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1375.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_384.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_27.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_838.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1779.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_452.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_737.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_853.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_884.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_854.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1783.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_739.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_193.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_187.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1279.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_476.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1812.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_935.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1326.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_34.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_30.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1429.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_754.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_792.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1252.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_885.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_94.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_58.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_456.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_500.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_859.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_489.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1311.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_766.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_344.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_140.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_834.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1796.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_206.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_801.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_201.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_363.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_15.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_191.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_389.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_408.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1366.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1414.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_422.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1782.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_762.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_955.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_130.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_435.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_924.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_440.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_934.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1445.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_160.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_6.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_128.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_97.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1450.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1349.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1247.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_760.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_841.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_203.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_459.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1820.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_370.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_445.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_769.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_817.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1829.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1274.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_402.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1444.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1352.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_844.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_925.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_742.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_804.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_354.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_753.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_464.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1236.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1441.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_368.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_336.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1793.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1253.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_774.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_406.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_351.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1814.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_797.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_35.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1381.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_371.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_407.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1373.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1259.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1401.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1255.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_824.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_194.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_941.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_923.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1408.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_915.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1428.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1310.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_833.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_157.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_457.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_13.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_57.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_886.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1446.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_116.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_972.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_321.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_156.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1372.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_314.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_839.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_416.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_12.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_928.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_313.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_372.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_438.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_104.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_419.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_425.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_137.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1426.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_477.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1291.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_449.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1321.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_88.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_842.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_857.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_53.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1270.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_374.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_837.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_405.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_779.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_913.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_852.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_777.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_460.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_51.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1778.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1360.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_957.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_153.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_42.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_136.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1825.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_803.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_510.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_150.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1789.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_982.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1290.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_73.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_911.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1417.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_741.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_437.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_900.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_888.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_36.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_400.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_92.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1232.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1285.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1422.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_942.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1281.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_159.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1364.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1421.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1282.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_761.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1244.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_758.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_75.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1827.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_103.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_764.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_5.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_3.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1246.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_334.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_429.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_796.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1264.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_509.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1237.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1297.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_142.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1374.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1355.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1314.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_33.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1828.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_135.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_514.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_121.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_149.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1345.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_1805.npy.npy -/mnt/nvme1/dataset_img/drone/1200/HackA5_1.2_743.npy.npy