diff --git a/.gitignore b/.gitignore index fdd0c6d..31b61bc 100644 --- a/.gitignore +++ b/.gitignore @@ -3,5 +3,25 @@ *.jpeg *.gif *.bmp +*.csv + + +*/.ipynb_checkpoints/* +profile/* +torch_profile/* +loss_history/* +loss_tracking/* +**/__pycache__/** +temp.txt + +# Plan files +*[Pp][Ll][Aa][Nn]*.md + +# C++ build and vcpkg manifest artifacts +cpp/build/ +cpp/build-xcode/ +cpp/build-coverage/ +cpp/vcpkg_installed/ +cpp/.vcpkg-root + -**/__pycache__/** \ No newline at end of file diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..dfc4ae8 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,16 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + + { + "name": "Python Debugger: Current File", + "type": "debugpy", + "request": "launch", + "program": "${file}", + "console": "integratedTerminal" + } + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..6adbc2b --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "python.defaultInterpreterPath": "/Library/Frameworks/Python.framework/Versions/3.11/bin/python3" +} diff --git a/README.md b/README.md index cf27bfb..6501a5b 100644 --- a/README.md +++ b/README.md @@ -41,20 +41,21 @@ We will review submissions on a rolling basis. 8 | Shashank Shriram | 0.0000 | 0.3312 | 11.32 | 🏎️💥 | | 9 | Gabriel Del Monte | 0.0000 | 0.3427 | 606.07 | | | 10 | Aleksey Valouev| 0.0000 | 0.3577 | 118.98 | | -| 11 | Mohul Shukla | 0.0000 | 0.5048 | 54.60s | | -| 12 | Ryan Hulke | 0.0000 | 0.5226 | 166.24 | | -| 13 | Neel Shah | 0.0000 | 0.5445 | 45.40 | Zero overlaps on all tests, adaptive schedule + early stop | -| 14 | Nawel Asgar | 0.0000 | 0.5675 | 81.49 | Adaptive penalty scaling with cubic gradients and design-size optimization -| 15 | Shiva Baghel | 0.0000 | 0.5885 | 491.00 | Stable zero-overlap with balanced optimization | -| 16 | Vansh Jain | 0.0000 | 0.9352 | 86.36 | | -| 17 | Akash Pai | 0.0006 | 0.4933 | 326.25s | | -| 18 | Zade Mahayni | 0.00665 | 0.5157 | 127.4 | Will try again tomorrow | -| 19 | Nithin Yanna | 0.0148 | 0.5034 | 247.30s | aggressive overlap penalty with quadratic scaling | -| 20 | Sean Ko | 0.0271 | .5138 | 31.83s | lr increase, decrease epoch, increase lambda overlap and decreased lambda wire_length + log penalty loss | -| 21 | Keya Gohil | 0.0155 | 0.4678 | 1513.07 | Still working | -| 22 | Prithvi Seran | 0.0499 | 0.4890 | 398.58 | | -| 23 | partcl example | 0.8 | 0.4 | 5 | example | -| 24 | Add Yours! | | | | | +| 11 | Green Table | 0.0000 | 0.476 | 57.35 | | +| 12 | Mohul Shukla | 0.0000 | 0.5048 | 54.60s | | +| 13 | Ryan Hulke | 0.0000 | 0.5226 | 166.24 | | +| 14 | Neel Shah | 0.0000 | 0.5445 | 45.40 | Zero overlaps on all tests, adaptive schedule + early stop | +| 15 | Nawel Asgar | 0.0000 | 0.5675 | 81.49 | Adaptive penalty scaling with cubic gradients and design-size optimization +| 16 | Shiva Baghel | 0.0000 | 0.5885 | 491.00 | Stable zero-overlap with balanced optimization | +| 17 | Vansh Jain | 0.0000 | 0.9352 | 86.36 | | +| 18 | Akash Pai | 0.0006 | 0.4933 | 326.25s | | +| 19 | Zade Mahayni | 0.00665 | 0.5157 | 127.4 | Will try again tomorrow | +| 20 | Nithin Yanna | 0.0148 | 0.5034 | 247.30s | aggressive overlap penalty with quadratic scaling | +| 21 | Sean Ko | 0.0271 | .5138 | 31.83s | lr increase, decrease epoch, increase lambda overlap and decreased lambda wire_length + log penalty loss | +| 22 | Keya Gohil | 0.0155 | 0.4678 | 1513.07 | Still working | +| 23 | Prithvi Seran | 0.0499 | 0.4890 | 398.58 | | +| 24 | partcl example | 0.8 | 0.4 | 5 | example | +| 25 | Add Yours! | | | | | > **To add your results:** > Insert a new row in the table above with your name, overlap, wirelength, and any notes. Ensure you sort by overlap. diff --git a/arg_parse_util.py b/arg_parse_util.py new file mode 100644 index 0000000..d8b8f3d --- /dev/null +++ b/arg_parse_util.py @@ -0,0 +1,245 @@ +import argparse + +from benchmark_test_cases import TEST_CASES_BY_ID +from learning_rate_scheduler_util import SCHEDULER_CHOICES + + +def _positive_int(value): + parsed_value = int(value) + if parsed_value < 1: + raise argparse.ArgumentTypeError("must be at least 1") + return parsed_value + + +def parse_args(): + """Parse command line arguments for optional profiling.""" + parser = argparse.ArgumentParser() + parser.add_argument( + "--profile", + action="store_true", + help="Enable cProfile and dump results to the profile directory.", + ) + parser.add_argument( + "--profile-tag", + default="", + help="Optional tag to include in the profile output filename.", + ) + parser.add_argument( + "--torch-profile", + action="store_true", + help="Enable torch.profiler trace capture during training.", + ) + parser.add_argument( + "--torch-profile-wait", + type=int, + default=1, + help="Number of initial training steps to skip before torch profiler warmup.", + ) + parser.add_argument( + "--torch-profile-warmup", + type=int, + default=1, + help="Number of warmup steps for torch profiler.", + ) + parser.add_argument( + "--torch-profile-active", + type=int, + default=3, + help="Number of active recording steps for torch profiler.", + ) + parser.add_argument( + "--torch-profile-repeat", + type=int, + default=1, + help="Number of wait/warmup/active cycles to record. Use 0 to repeat until the run ends.", + ) + parser.add_argument( + "--torch-profile-record-shapes", + action=argparse.BooleanOptionalAction, + default=True, + help="Enable or disable input-shape recording in torch profiler.", + ) + parser.add_argument( + "--torch-profile-memory", + action=argparse.BooleanOptionalAction, + default=True, + help="Enable or disable memory tracking in torch profiler.", + ) + parser.add_argument( + "--torch-profile-with-stack", + action=argparse.BooleanOptionalAction, + default=True, + help="Enable or disable stack trace capture in torch profiler.", + ) + parser.add_argument( + "--torch-profile-acc-events", + action=argparse.BooleanOptionalAction, + default=False, + help="Accumulate profiler events across schedule cycles to avoid cycle-reset warnings.", + ) + parser.add_argument( + "--num-epochs", + type=int, + default=1000, + help="Number of optimization epochs for a regular training run.", + ) + parser.add_argument( + "--num-macros", + type=int, + default=3, + help="Number of macro cells to generate for a placement run.", + ) + parser.add_argument( + "--num-std-cells", + type=int, + default=10, + help="Number of standard cells to generate for a placement run.", + ) + parser.add_argument( + "--seed", + type=int, + default=42, + help="Random seed used to generate and initialize the placement problem.", + ) + parser.add_argument( + "--device", + choices=("auto", "cpu", "cuda", "mps"), + default="auto", + help="Torch device to use. 'auto' selects cuda, then mps, then cpu.", + ) + parser.add_argument( + "--test-case-id", + type=int, + choices=sorted(TEST_CASES_BY_ID), + help="Optional benchmark test case to load. Overrides --num-macros, --num-std-cells, and --seed.", + ) + parser.add_argument( + "--lr", + type=float, + default=0.1, + help="Learning rate for the Adam optimizer.", + ) + parser.add_argument( + "--lambda-wirelength", + type=float, + default=3.0, + help="Weight applied to the wirelength term.", + ) + parser.add_argument( + "--lambda-overlap", + type=float, + default=1.0, + help="Weight applied to the overlap term.", + ) + parser.add_argument( + "--scheduler", + choices=SCHEDULER_CHOICES, + default="plateau", + help="Learning-rate scheduler to use during training.", + ) + parser.add_argument( + "--scheduler-patience", + type=int, + default=50, + help="Patience for ReduceLROnPlateau.", + ) + parser.add_argument( + "--scheduler-factor", + type=float, + default=0.5, + help="Decay factor for ReduceLROnPlateau.", + ) + parser.add_argument( + "--scheduler-eta-min", + type=float, + default=1e-4, + help="Minimum learning rate for cosine annealing.", + ) + parser.add_argument( + "--scheduler-step-size", + type=int, + default=100, + help="Step size in epochs for StepLR.", + ) + parser.add_argument( + "--scheduler-gamma", + type=float, + default=0.95, + help="Gamma decay used by StepLR and ExponentialLR.", + ) + parser.add_argument( + "--optuna", + action="store_true", + help="Run Optuna hyperparameter search instead of a single training run.", + ) + parser.add_argument( + "--optuna-trials", + type=int, + default=25, + help="Number of Optuna trials to execute.", + ) + parser.add_argument( + "--optuna-epochs", + type=int, + default=400, + help="Number of epochs per Optuna trial.", + ) + parser.add_argument( + "--optuna-study-name", + default="placement_hparam_search", + help="Study name used by Optuna.", + ) + parser.add_argument( + "--optuna-storage", + default="", + help="Optional Optuna storage URL, for example sqlite:///optuna.db.", + ) + parser.add_argument( + "--track-loss-history", + action=argparse.BooleanOptionalAction, + default=True, + help="Enable or disable loss-history collection and persistence.", + ) + parser.add_argument( + "--track-overlap-metrics", + action=argparse.BooleanOptionalAction, + default=False, + help="Enable or disable per-epoch overlap-metric collection for loss tracking.", + ) + parser.add_argument( + "--early-stop", + action=argparse.BooleanOptionalAction, + default=True, + help="Enable or disable overlap-first early stopping during training.", + ) + parser.add_argument( + "--early-stop-patience", + type=_positive_int, + default=75, + help="Patience before stopping when overlap stops improving.", + ) + parser.add_argument( + "--early-stop-min-delta", + type=float, + default=1e-4, + help="Minimum improvement required to reset early-stop patience.", + ) + parser.add_argument( + "--early-stop-overlap-threshold", + type=float, + default=1e-4, + help="Treat overlap below this value as effectively zero for early stopping.", + ) + parser.add_argument( + "--early-stop-zero-overlap-patience", + type=_positive_int, + default=25, + help="Extra patience after zero-overlap is reached to keep reducing wirelength.", + ) + parser.add_argument( + "--workers", + type=_positive_int, + default=4, + help="Number of worker processes for test.py. Use 1 to run serially.", + ) + return parser.parse_args() diff --git a/benchmark_test_cases.py b/benchmark_test_cases.py new file mode 100644 index 0000000..b1a57c1 --- /dev/null +++ b/benchmark_test_cases.py @@ -0,0 +1,35 @@ +"""Shared benchmark configurations for placement test cases.""" + +ACTIVE_TEST_CASES = [ + # Small designs + (1, 2, 20, 1001), + (2, 3, 25, 1002), + (3, 2, 30, 1003), + # Medium designs + (4, 3, 50, 1004), + (5, 4, 75, 1005), + (6, 5, 100, 1006), + # Large designs + (7, 5, 150, 1007), + (8, 7, 150, 1008), + (9, 8, 200, 1009), + (10, 10, 2000, 1010), +] + +OPTIONAL_TEST_CASES = [ + # Realistic designs + (11, 10, 10000, 1011), + (12, 10, 100000, 1012), +] + +TEST_CASES = ACTIVE_TEST_CASES + OPTIONAL_TEST_CASES + +TEST_CASES_BY_ID = { + test_id: { + "test_id": test_id, + "num_macros": num_macros, + "num_std_cells": num_std_cells, + "seed": seed, + } + for test_id, num_macros, num_std_cells, seed in TEST_CASES +} diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt new file mode 100644 index 0000000..78c6b35 --- /dev/null +++ b/cpp/CMakeLists.txt @@ -0,0 +1,199 @@ +cmake_minimum_required(VERSION 3.25) + +project(placement_cpp LANGUAGES CXX) + +include(CTest) + +option(PLACEMENT_ENABLE_COVERAGE "Enable LLVM source-based coverage for unit tests" OFF) + +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) + +if(PLACEMENT_ENABLE_COVERAGE) + if(NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang") + message(FATAL_ERROR "PLACEMENT_ENABLE_COVERAGE requires a Clang-compatible compiler") + endif() + + find_program(LLVM_PROFDATA_EXECUTABLE llvm-profdata) + if(NOT LLVM_PROFDATA_EXECUTABLE) + execute_process( + COMMAND xcrun -f llvm-profdata + OUTPUT_VARIABLE LLVM_PROFDATA_EXECUTABLE + OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE LLVM_PROFDATA_RESULT + ) + if(NOT LLVM_PROFDATA_RESULT EQUAL 0) + message(FATAL_ERROR "Unable to find llvm-profdata") + endif() + endif() + + find_program(LLVM_COV_EXECUTABLE llvm-cov) + if(NOT LLVM_COV_EXECUTABLE) + execute_process( + COMMAND xcrun -f llvm-cov + OUTPUT_VARIABLE LLVM_COV_EXECUTABLE + OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE LLVM_COV_RESULT + ) + if(NOT LLVM_COV_RESULT EQUAL 0) + message(FATAL_ERROR "Unable to find llvm-cov") + endif() + endif() +endif() + +function(enable_placement_coverage target_name) + if(PLACEMENT_ENABLE_COVERAGE) + target_compile_options( + ${target_name} + PRIVATE + -fprofile-instr-generate + -fcoverage-mapping + -O0 + -g + ) + target_link_options(${target_name} PRIVATE -fprofile-instr-generate) + endif() +endfunction() + +# LibTorch is provided by the active Python environment rather than vcpkg. +# Prefer the repo-local virtualenv when present, then ask Python where the +# installed torch package exposes its CMake config files. +set(_repo_venv_python "${CMAKE_CURRENT_LIST_DIR}/../.venv/bin/python") +if(NOT Python3_EXECUTABLE AND EXISTS "${_repo_venv_python}") + set(Python3_EXECUTABLE "${_repo_venv_python}" CACHE FILEPATH "Python interpreter") +endif() +if(NOT Python3_EXECUTABLE) + find_program(_path_python3 NAMES python3 python) + if(_path_python3) + execute_process( + COMMAND "${_path_python3}" -c "import torch" + RESULT_VARIABLE _path_python3_torch_result + OUTPUT_QUIET + ERROR_QUIET + ) + if(_path_python3_torch_result EQUAL 0) + set(Python3_EXECUTABLE "${_path_python3}" CACHE FILEPATH "Python interpreter") + endif() + endif() +endif() + +find_package(Python3 COMPONENTS Interpreter Development REQUIRED) +execute_process( + COMMAND "${Python3_EXECUTABLE}" -c "import torch; print(torch.utils.cmake_prefix_path)" + OUTPUT_VARIABLE TORCH_CMAKE_PREFIX_PATH + OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE TORCH_CMAKE_PREFIX_RESULT +) +if(NOT TORCH_CMAKE_PREFIX_RESULT EQUAL 0) + message(FATAL_ERROR "Unable to import torch from ${Python3_EXECUTABLE}. Install torch in .venv or set Python3_EXECUTABLE.") +endif() +execute_process( + COMMAND "${Python3_EXECUTABLE}" -c "import sysconfig; print(sysconfig.get_paths()['purelib'])" + OUTPUT_VARIABLE PYTHON_SITE_PACKAGES + OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE PYTHON_SITE_PACKAGES_RESULT +) +if(NOT PYTHON_SITE_PACKAGES_RESULT EQUAL 0 OR PYTHON_SITE_PACKAGES STREQUAL "") + message(FATAL_ERROR "Unable to detect Python site-packages from ${Python3_EXECUTABLE}.") +endif() +execute_process( + COMMAND "${Python3_EXECUTABLE}" -c "import matplotlib" + RESULT_VARIABLE MATPLOTLIB_IMPORT_RESULT + OUTPUT_QUIET + ERROR_QUIET +) +if(NOT MATPLOTLIB_IMPORT_RESULT EQUAL 0) + message(FATAL_ERROR "Unable to import matplotlib from ${Python3_EXECUTABLE}. Install matplotlib in the selected Python environment.") +endif() +list(PREPEND CMAKE_PREFIX_PATH "${TORCH_CMAKE_PREFIX_PATH}") + +find_package(Torch CONFIG REQUIRED) +find_package(CLI11 CONFIG REQUIRED) +find_package(SQLite3 REQUIRED) +find_path(MATPLOTLIB_CPP_INCLUDE_DIRS "matplotlibcpp.h" REQUIRED) + +add_library( + placement_core + benchmark.cpp + generation.cpp + losses.cpp + metrics.cpp + sqlite_utils.cpp + training.cpp + visualization.cpp +) +target_include_directories(placement_core PUBLIC "${CMAKE_CURRENT_LIST_DIR}/include") +target_include_directories(placement_core SYSTEM PRIVATE "${MATPLOTLIB_CPP_INCLUDE_DIRS}") +target_compile_definitions( + placement_core + PRIVATE + PLACEMENT_PYTHON_SITE_PACKAGES="${PYTHON_SITE_PACKAGES}" + PLACEMENT_REPO_ROOT="${CMAKE_CURRENT_LIST_DIR}/.." +) +target_link_libraries( + placement_core + PUBLIC "${TORCH_LIBRARIES}" Python3::Python + PRIVATE SQLite::SQLite3 +) +target_compile_features(placement_core PUBLIC cxx_std_20) +enable_placement_coverage(placement_core) + +add_executable(placement placement.cpp) +target_compile_definitions( + placement + PRIVATE + PLACEMENT_REPO_ROOT="${CMAKE_CURRENT_LIST_DIR}/.." +) +target_link_libraries(placement PRIVATE placement_core CLI11::CLI11) +target_compile_features(placement PRIVATE cxx_std_20) +enable_placement_coverage(placement) + +add_executable(placement_test test.cpp) +target_link_libraries(placement_test PRIVATE placement_core CLI11::CLI11) +target_compile_features(placement_test PRIVATE cxx_std_20) +enable_placement_coverage(placement_test) + +if(BUILD_TESTING) + add_executable( + placement_unit_tests + tests/metrics_tests.cpp + tests/visualization_tests.cpp + ) + target_link_libraries(placement_unit_tests PRIVATE placement_core) + target_compile_features(placement_unit_tests PRIVATE cxx_std_20) + enable_placement_coverage(placement_unit_tests) + add_test(NAME placement_unit_tests COMMAND placement_unit_tests) + + if(PLACEMENT_ENABLE_COVERAGE) + add_custom_target( + placement_coverage + COMMAND + "${CMAKE_COMMAND}" + -DTEST_EXECUTABLE=$ + -DLLVM_PROFDATA="${LLVM_PROFDATA_EXECUTABLE}" + -DLLVM_COV="${LLVM_COV_EXECUTABLE}" + -DSOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}" + -DCOVERAGE_DIR="${CMAKE_BINARY_DIR}/coverage" + -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/RunCoverage.cmake" + DEPENDS placement_unit_tests + USES_TERMINAL + ) + endif() +endif() + +if(MSVC) + target_compile_options(placement_core PRIVATE /W4) + target_compile_options(placement PRIVATE /W4) + target_compile_options(placement_test PRIVATE /W4) + if(TARGET placement_unit_tests) + target_compile_options(placement_unit_tests PRIVATE /W4) + endif() +else() + target_compile_options(placement_core PRIVATE -Wall -Wextra -Wpedantic) + target_compile_options(placement PRIVATE -Wall -Wextra -Wpedantic) + target_compile_options(placement_test PRIVATE -Wall -Wextra -Wpedantic) + if(TARGET placement_unit_tests) + target_compile_options(placement_unit_tests PRIVATE -Wall -Wextra -Wpedantic) + endif() +endif() diff --git a/cpp/CMakePresets.json b/cpp/CMakePresets.json new file mode 100644 index 0000000..33c0da5 --- /dev/null +++ b/cpp/CMakePresets.json @@ -0,0 +1,44 @@ +{ + "version": 6, + "configurePresets": [ + { + "name": "release", + "displayName": "Release", + "generator": "Ninja", + "binaryDir": "${sourceDir}/build", + "environment": { + "PATH": "/opt/homebrew/opt/libtool/libexec/gnubin:$penv{PATH}" + }, + "cacheVariables": { + "CMAKE_BUILD_TYPE": "Release", + "CMAKE_MAKE_PROGRAM": "/opt/homebrew/bin/ninja", + "CMAKE_TOOLCHAIN_FILE": "/Users/vrajpandya/vcpkg-shared/vcpkg/scripts/buildsystems/vcpkg.cmake" + } + }, + { + "name": "coverage", + "displayName": "Coverage", + "generator": "Ninja", + "binaryDir": "${sourceDir}/build-coverage", + "environment": { + "PATH": "/opt/homebrew/opt/libtool/libexec/gnubin:$penv{PATH}" + }, + "cacheVariables": { + "CMAKE_BUILD_TYPE": "Debug", + "CMAKE_MAKE_PROGRAM": "/opt/homebrew/bin/ninja", + "CMAKE_TOOLCHAIN_FILE": "/Users/vrajpandya/vcpkg-shared/vcpkg/scripts/buildsystems/vcpkg.cmake", + "PLACEMENT_ENABLE_COVERAGE": "ON" + } + } + ], + "buildPresets": [ + { + "name": "release", + "configurePreset": "release" + }, + { + "name": "coverage", + "configurePreset": "coverage" + } + ] +} diff --git a/cpp/PORT_PLAN.md b/cpp/PORT_PLAN.md new file mode 100644 index 0000000..3f4eeac --- /dev/null +++ b/cpp/PORT_PLAN.md @@ -0,0 +1,185 @@ +# C++ Port Coordination Plan + +## Summary + +This file is the shared recovery plan for porting the Python placement flow from +`placement.py` and `test.py` into the C++ implementation under `cpp/`. + +## Current Status + +- The C++ project builds. +- `cpp/generation.cpp` contains a real implementation for synthetic placement + input generation and initial cell placement. +- `cpp/metrics.cpp` now implements overlap metrics and normalized metrics to + match the Python metric behavior. +- `cpp/tests/metrics_tests.cpp` covers the metrics implementation with a + deterministic hand-authored placement, a generated-placement integration + smoke test, loss parity checks, loss edge cases, an autograd smoke test, and + focused training-loop and benchmark-runner checks. +- `cpp/tests/visualization_tests.cpp` covers SVG placement visualization output. +- `cpp/CMakeLists.txt` registers `placement_unit_tests` with CTest when + `BUILD_TESTING` is enabled. +- `cpp/CMakeLists.txt` also exposes opt-in LLVM source coverage through + `PLACEMENT_ENABLE_COVERAGE` and the `placement_coverage` target. +- `cpp/CMakeLists.txt` now prefers a PATH Python that can import `torch` when no + repo-local `.venv` exists, avoiding macOS CMake selecting a newer Python + without the required Torch package. +- `cpp/CMakePresets.json` includes a `coverage` preset that writes coverage + build artifacts to `cpp/build-coverage`. +- `cpp/losses.cpp` now implements `wirelengthAttractionLoss`, + `computePairwiseOverlapAreas`, and `overlapRepulsionLoss` to match the + Python formulas in `placement.py`. +- `cpp/training.cpp` now implements the core `train_placement` loop: Adam over + cell positions, weighted wirelength/overlap losses, gradient clipping, + supported learning-rate schedulers, best-position tracking, and early-stop + metadata. +- Tests and coverage were re-verified on 2026-04-26 after the graphing and + notebook artifact work. +- `cpp/benchmark.cpp` now implements active benchmark case metadata, single-case + execution using the configured device enum, serial multi-case execution, + ordered results, aggregate averages, total elapsed time, and pass/fail counts. +- `cpp/main.cpp` now implements the `placement` binary CLI for single placement + runs, ordered serial active benchmark runs, SVG visualization output, and + notebook-friendly CSV/JSON artifact files. +- `cpp/visualization.cpp` now emits a dependency-free SVG visualization with + side-by-side initial/final placements and overlap metrics. + +## Source Of Truth + +- `placement.py` is the source of truth for placement generation semantics, + loss formulas, overlap metrics, normalized metrics, training behavior, and the + single-run CLI flow. +- `test.py` is the source of truth for benchmark execution, per-case result + fields, aggregate metrics, and pass/fail reporting. +- `benchmark_test_cases.py` is the source of truth for active benchmark cases. +- C++ code should preserve the public struct fields already declared in + `cpp/include/placement/types.h` unless a later step explicitly approves an + interface change. + +## Working Protocol + +After each implementation step, stop and ask for explicit permission before +editing code for the next step. + +Use branch/worktree coordination for delegated work, and integrate branches into +`main` with fast-forward-only merges. + +Permission checkpoints: + +1. Write or update this plan file. +2. Ask permission before editing `cpp/metrics.cpp`. +3. Add unit coverage for features implemented so far before moving to the next + porting area. +4. Continue this pattern for training, benchmark runner, and CLI work. + +## Immediate Next Step + +The current scoped roadmap is complete. Optional deferred items remain for a +later scope decision: SQLite loss history, profiling, and multiprocessing. + +Recently verified commands from `cpp/`: + +```sh +cmake --build --preset release --target placement_unit_tests +cmake --build --preset release --target placement +ctest --test-dir build -R placement_unit_tests --output-on-failure +cmake --build --preset coverage --target placement_coverage +./build/placement --num-macros 0 --num-std-cells 1 --num-epochs 0 --scheduler none --quiet --write-output-files --output-dir +./build/placement --benchmark --num-epochs 0 --scheduler none --write-output-files --output-dir +``` + +The latest coverage run reported: + +- `benchmark.cpp`: 96.43% line coverage +- `generation.cpp`: 92.26% line coverage +- `losses.cpp`: 100.00% line coverage +- `metrics.cpp`: 93.89% line coverage +- `training.cpp`: 57.51% line coverage +- `visualization.cpp`: 88.53% line coverage +- Total: 83.63% line coverage + +The implemented metrics behavior is: + +- `calculateOverlapMetrics` computes overlap pair count, total overlap area, + max single-pair overlap area, overlap percentage, cells involved in at least + one overlap, and whether the placement has zero overlap. +- `calculateNormalizedMetrics` computes total cells, number of nets, number of + cells with overlaps, overlap ratio, and normalized wirelength. +- The normalized wirelength formula matches `calculate_normalized_metrics` in + `placement.py`: `(wirelength / num_nets) / sqrt(total_area)`, with zero + returned when there are no nets or total area is zero. +- `wirelengthAttractionLoss` matches Python's average smooth Manhattan + wirelength with `alpha = 0.1`. +- `computePairwiseOverlapAreas` returns the full pairwise overlap-area matrix, + including diagonal self areas. +- `overlapRepulsionLoss` matches Python's + `log1p(sum(upper_triangle_overlap_area)) * 200` formula. +- `trainPlacement` preserves the C++ result interface while porting the Python + optimizer behavior that affects placement quality and early-stop selection. +- `activeBenchmarkCases` matches `benchmark_test_cases.py` active cases. +- `runBenchmarkCase` mirrors the per-case benchmark flow from `test.py`: seed, + generate on the configured device enum, initialize, train with quiet logging, + calculate normalized metrics, record elapsed time, and mark pass/fail from + zero overlapping cells. +- `runBenchmarkCases` and `runActiveBenchmarkCases` provide ordered serial + benchmark execution and aggregate average overlap/wirelength reporting. +- The `placement` CLI supports the shared training hyperparameters, device + selection, single-run problem generation by size or test-case id, and active + benchmark reporting. +- `plotPlacement` writes an SVG with initial/final placement panels, cell + rectangles, grid lines, and overlap metrics. +- `--write-output-files` writes notebook-friendly artifacts: + `placement_result_summary.csv`, `placement_result_summary.json`, and + `placement_result.svg` for single runs; `placement_benchmark_cases.csv`, + `placement_benchmark_summary.csv`, and `placement_benchmark_summary.json` for + benchmark runs. +- SQLite loss history, profiling, and multiprocessing remain deferred. + +## Port Roadmap + +- [x] Metrics parity. +- [x] Loss function parity. +- [x] Training loop parity. +- [x] Benchmark/test runner parity. +- [x] CLI and output cleanup. +- [x] Add graphing parity. +- [x] Create output files that can be consumed by notebooks in the lab directory. + +## Recovery Notes + +If a future session resumes from scratch, inspect these files first: + +- `cpp/PORT_PLAN.md` +- `cpp/metrics.cpp` +- `cpp/losses.cpp` +- `cpp/training.cpp` +- `cpp/benchmark.cpp` +- `cpp/main.cpp` +- `cpp/visualization.cpp` +- `cpp/include/placement/visualization.h` +- `cpp/include/placement/types.h` +- `cpp/tests/metrics_tests.cpp` +- `cpp/tests/visualization_tests.cpp` +- `cpp/cmake/RunCoverage.cmake` +- `placement.py` +- `test.py` + +Useful read-only commands: + +```sh +rg -n "calculate_overlap|calculate_normalized|wirelength|overlap_repulsion|train_placement" placement.py test.py cpp +sed -n '1,220p' cpp/metrics.cpp +sed -n '1,220p' cpp/tests/metrics_tests.cpp +sed -n '829,995p' placement.py +sed -n '320,535p' placement.py +cmake --build cpp/build --target placement_unit_tests --config Release +ctest --test-dir cpp/build -R placement_unit_tests --output-on-failure +cmake --preset coverage +cmake --build --preset coverage --target placement_coverage +cat cpp/build-coverage/coverage/placement_unit_tests.txt +``` + +Coverage outputs: + +- Text summary: `cpp/build-coverage/coverage/placement_unit_tests.txt` +- HTML report: `cpp/build-coverage/coverage/html/index.html` diff --git a/cpp/benchmark.cpp b/cpp/benchmark.cpp new file mode 100644 index 0000000..b28dc90 --- /dev/null +++ b/cpp/benchmark.cpp @@ -0,0 +1,229 @@ +#include "placement/benchmark.h" + +#include "placement/generation.h" +#include "placement/metrics.h" +#include "placement/training.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace placement { + +namespace { + +PlacementProblem generateSeededProblem( + const BenchmarkCase& test_case, + const TrainingConfig& benchmark_config, + std::mutex* rng_mutex) { + const auto generate = [&]() { + if (test_case.seed != 0) { + torch::manual_seed(test_case.seed); + } + + const torch::Device device(benchmark_config.device); + PlacementProblem problem = generatePlacementInput( + test_case.num_macros, + test_case.num_std_cells, + device, + false); + initializeCellPositions(problem.cell_features); + return problem; + }; + + if (rng_mutex == nullptr) { + return generate(); + } + + std::lock_guard lock(*rng_mutex); + return generate(); +} + +BenchmarkResult runBenchmarkCaseImpl( + const BenchmarkCase& test_case, + const TrainingConfig& config, + std::mutex* rng_mutex) { + TrainingConfig benchmark_config = config; + benchmark_config.verbose = false; + + PlacementProblem problem = + generateSeededProblem(test_case, benchmark_config, rng_mutex); + + const auto start_time = std::chrono::steady_clock::now(); + const TrainingResult training_result = trainPlacement( + problem.cell_features, + problem.pin_features, + problem.edge_list, + benchmark_config); + const auto elapsed = std::chrono::steady_clock::now() - start_time; + + const Metrics metrics = calculateNormalizedMetrics( + training_result.final_cell_features, + problem.pin_features, + problem.edge_list); + + BenchmarkResult result; + result.test_id = test_case.test_id; + result.num_macros = test_case.num_macros; + result.num_std_cells = test_case.num_std_cells; + result.total_cells = metrics.total_cells; + result.total_pins = problem.pin_features.size(0); + result.num_nets = metrics.num_nets; + result.seed = test_case.seed; + result.device = benchmark_config.device; + result.elapsed_seconds = std::chrono::duration(elapsed).count(); + result.num_cells_with_overlaps = metrics.num_cells_with_overlaps; + result.overlap_ratio = metrics.overlap_ratio; + result.normalized_wl = metrics.normalized_wl; + result.passed = result.num_cells_with_overlaps == 0; + result.stopped_early = training_result.stopped_early; + result.stop_reason = training_result.stop_reason; + result.run_started_at = training_result.run_started_at; + result.best_epoch = training_result.best_epoch; + result.epochs_completed = training_result.epochs_completed; + result.loss_history = training_result.loss_history; + return result; +} + +void addResultToSummary(BenchmarkSummary& summary, BenchmarkResult result) { + if (result.passed) { + ++summary.passed_count; + } else { + ++summary.failed_count; + } + summary.results.push_back(std::move(result)); +} + +void finalizeSummary(BenchmarkSummary& summary) { + if (summary.results.empty()) { + return; + } + + double overlap_sum = 0.0; + double wirelength_sum = 0.0; + for (const BenchmarkResult& result : summary.results) { + overlap_sum += result.overlap_ratio; + wirelength_sum += result.normalized_wl; + } + + const double case_count = static_cast(summary.results.size()); + summary.average_overlap = overlap_sum / case_count; + summary.average_wirelength = wirelength_sum / case_count; +} + +} // namespace + +const std::vector& activeBenchmarkCases() { + static const std::vector cases = { + {1, 2, 20, 1001}, + {2, 3, 25, 1002}, + {3, 2, 30, 1003}, + {4, 3, 50, 1004}, + {5, 4, 75, 1005}, + {6, 5, 100, 1006}, + {7, 5, 150, 1007}, + {8, 7, 150, 1008}, + {9, 8, 200, 1009}, + {10, 10, 2000, 1010}, + }; + return cases; +} + +BenchmarkResult runBenchmarkCase( + const BenchmarkCase& test_case, + const TrainingConfig& config) { + return runBenchmarkCaseImpl(test_case, config, nullptr); +} + +BenchmarkSummary runBenchmarkCases( + const std::vector& test_cases, + const TrainingConfig& config, + int worker_count) { + if (worker_count <= 0) { + throw std::invalid_argument("Worker count must be positive"); + } + + BenchmarkSummary summary; + if (test_cases.empty()) { + return summary; + } + + summary.results.reserve(test_cases.size()); + const auto start_time = std::chrono::steady_clock::now(); + + if (worker_count == 1) { + for (const BenchmarkCase& test_case : test_cases) { + addResultToSummary( + summary, + runBenchmarkCaseImpl(test_case, config, nullptr)); + } + } else { + std::vector ordered_results(test_cases.size()); + std::atomic next_index{0}; + std::atomic should_stop{false}; + std::mutex rng_mutex; + std::mutex exception_mutex; + std::exception_ptr first_exception; + + std::vector workers; + workers.reserve(static_cast(worker_count)); + for (int worker_index = 0; worker_index < worker_count; ++worker_index) { + workers.emplace_back([&]() { + while (!should_stop.load()) { + const std::size_t index = next_index.fetch_add(1); + if (index >= test_cases.size()) { + return; + } + + try { + ordered_results[index] = runBenchmarkCaseImpl( + test_cases[index], + config, + &rng_mutex); + } catch (...) { + { + std::lock_guard lock(exception_mutex); + if (first_exception == nullptr) { + first_exception = std::current_exception(); + } + } + should_stop.store(true); + return; + } + } + }); + } + + for (std::thread& worker : workers) { + worker.join(); + } + + if (first_exception != nullptr) { + std::rethrow_exception(first_exception); + } + + for (BenchmarkResult& result : ordered_results) { + addResultToSummary(summary, std::move(result)); + } + } + + const auto elapsed = std::chrono::steady_clock::now() - start_time; + + finalizeSummary(summary); + summary.total_elapsed_seconds = std::chrono::duration(elapsed).count(); + + return summary; +} + +BenchmarkSummary runActiveBenchmarkCases( + const TrainingConfig& config, + int worker_count) { + return runBenchmarkCases(activeBenchmarkCases(), config, worker_count); +} + +} // namespace placement diff --git a/cpp/cmake/RunCoverage.cmake b/cpp/cmake/RunCoverage.cmake new file mode 100644 index 0000000..5f327f2 --- /dev/null +++ b/cpp/cmake/RunCoverage.cmake @@ -0,0 +1,73 @@ +foreach(required_var TEST_EXECUTABLE LLVM_PROFDATA LLVM_COV SOURCE_DIR COVERAGE_DIR) + if(NOT DEFINED ${required_var} OR "${${required_var}}" STREQUAL "") + message(FATAL_ERROR "Missing required coverage variable: ${required_var}") + endif() +endforeach() + +set(raw_profile "${COVERAGE_DIR}/placement_unit_tests.profraw") +set(profile_data "${COVERAGE_DIR}/placement_unit_tests.profdata") +set(report_file "${COVERAGE_DIR}/placement_unit_tests.txt") +set(html_dir "${COVERAGE_DIR}/html") + +file(REMOVE_RECURSE "${COVERAGE_DIR}") +file(MAKE_DIRECTORY "${COVERAGE_DIR}") + +execute_process( + COMMAND + "${CMAKE_COMMAND}" -E env + "LLVM_PROFILE_FILE=${raw_profile}" + "${TEST_EXECUTABLE}" + RESULT_VARIABLE test_result +) +if(NOT test_result EQUAL 0) + message(FATAL_ERROR "placement_unit_tests failed during coverage run") +endif() + +execute_process( + COMMAND "${LLVM_PROFDATA}" merge -sparse "${raw_profile}" -o "${profile_data}" + RESULT_VARIABLE profdata_result +) +if(NOT profdata_result EQUAL 0) + message(FATAL_ERROR "llvm-profdata failed") +endif() + +set(covered_sources + "${SOURCE_DIR}/benchmark.cpp" + "${SOURCE_DIR}/generation.cpp" + "${SOURCE_DIR}/losses.cpp" + "${SOURCE_DIR}/metrics.cpp" + "${SOURCE_DIR}/training.cpp" + "${SOURCE_DIR}/visualization.cpp" +) + +execute_process( + COMMAND + "${LLVM_COV}" report + "${TEST_EXECUTABLE}" + "-instr-profile=${profile_data}" + ${covered_sources} + OUTPUT_VARIABLE coverage_report + RESULT_VARIABLE report_result +) +if(NOT report_result EQUAL 0) + message(FATAL_ERROR "llvm-cov report failed") +endif() +file(WRITE "${report_file}" "${coverage_report}") + +execute_process( + COMMAND + "${LLVM_COV}" show + "${TEST_EXECUTABLE}" + "-instr-profile=${profile_data}" + "-format=html" + "-output-dir=${html_dir}" + ${covered_sources} + RESULT_VARIABLE html_result +) +if(NOT html_result EQUAL 0) + message(FATAL_ERROR "llvm-cov html report failed") +endif() + +message(STATUS "Coverage text report: ${report_file}") +message(STATUS "Coverage HTML report: ${html_dir}/index.html") +message("${coverage_report}") diff --git a/cpp/generation.cpp b/cpp/generation.cpp new file mode 100644 index 0000000..1260e81 --- /dev/null +++ b/cpp/generation.cpp @@ -0,0 +1,206 @@ +#include "placement/generation.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace { + +constexpr double kMinMacroArea = 100.0; +constexpr double kMaxMacroArea = 10000.0; +constexpr double kStandardCellHeight = 1.0; +constexpr int64_t kMinStandardCellPins = 3; +constexpr int64_t kMaxStandardCellPins = 6; +constexpr double kPinSize = 0.1; +constexpr double kTwoPi = 6.28318530717958647692; + +int64_t featureIndex(placement::CellFeatureIdx idx) { + return static_cast(idx); +} + +int64_t featureIndex(placement::PinFeatureIdx idx) { + return static_cast(idx); +} + +} // namespace + +namespace placement { + +using namespace torch::indexing; + +PlacementProblem generatePlacementInput( + int num_macros, + int num_std_cells, + const torch::Device& device, + bool verbose) { + const int64_t macro_count = num_macros; + const int64_t std_cell_count = num_std_cells; + const int64_t total_cells = macro_count + std_cell_count; + auto float_options = torch::TensorOptions().dtype(torch::kFloat32).device(device); + auto long_options = torch::TensorOptions().dtype(torch::kInt64).device(device); + + auto macro_areas = + torch::rand({macro_count}, float_options) * (kMaxMacroArea - kMinMacroArea) + + kMinMacroArea; + + const auto standard_areas = + torch::tensor({1.0F, 2.0F, 3.0F}, float_options); + const auto std_area_indices = + torch::randint(0, standard_areas.size(0), {std_cell_count}, long_options); + auto std_cell_areas = standard_areas.index_select(0, std_area_indices); + auto areas = torch::cat({macro_areas, std_cell_areas}); + + auto macro_widths = torch::sqrt(macro_areas); + auto macro_heights = torch::sqrt(macro_areas); + auto std_cell_widths = std_cell_areas / kStandardCellHeight; + auto std_cell_heights = + torch::full({std_cell_count}, kStandardCellHeight, float_options); + auto cell_widths = torch::cat({macro_widths, std_cell_widths}); + auto cell_heights = torch::cat({macro_heights, std_cell_heights}); + + auto num_pins_per_cell = torch::zeros({total_cells}, long_options); + for (int64_t i = 0; i < macro_count; ++i) { + const int64_t sqrt_area = + static_cast(std::sqrt(macro_areas[i].item())); + num_pins_per_cell.index_put_( + {i}, + torch::randint(sqrt_area, 2 * sqrt_area + 1, {1}, long_options)[0]); + } + if (std_cell_count > 0) { + num_pins_per_cell.index_put_( + {Slice(macro_count, total_cells)}, + torch::randint( + kMinStandardCellPins, + kMaxStandardCellPins + 1, + {std_cell_count}, + long_options)); + } + + auto cell_features = torch::zeros({total_cells, 6}, float_options); + cell_features.index_put_({Slice(), featureIndex(CellFeatureIdx::Area)}, areas); + cell_features.index_put_( + {Slice(), featureIndex(CellFeatureIdx::NumPins)}, + num_pins_per_cell.to(torch::kFloat32)); + cell_features.index_put_({Slice(), featureIndex(CellFeatureIdx::X)}, 0.0); + cell_features.index_put_({Slice(), featureIndex(CellFeatureIdx::Y)}, 0.0); + cell_features.index_put_( + {Slice(), featureIndex(CellFeatureIdx::Width)}, + cell_widths); + cell_features.index_put_( + {Slice(), featureIndex(CellFeatureIdx::Height)}, + cell_heights); + + const int64_t total_pins = num_pins_per_cell.sum().item(); + auto pin_features = torch::zeros({total_pins, 7}, float_options); + + int64_t pin_idx = 0; + for (int64_t cell_idx = 0; cell_idx < total_cells; ++cell_idx) { + const int64_t n_pins = num_pins_per_cell[cell_idx].item(); + const double cell_width = cell_widths[cell_idx].item(); + const double cell_height = cell_heights[cell_idx].item(); + const double margin = kPinSize / 2.0; + + torch::Tensor pin_x; + torch::Tensor pin_y; + if (cell_width > 2.0 * margin && cell_height > 2.0 * margin) { + pin_x = torch::rand({n_pins}, float_options) * (cell_width - 2.0 * margin) + + margin; + pin_y = torch::rand({n_pins}, float_options) * (cell_height - 2.0 * margin) + + margin; + } else { + pin_x = torch::full({n_pins}, cell_width / 2.0, float_options); + pin_y = torch::full({n_pins}, cell_height / 2.0, float_options); + } + + const auto rows = Slice(pin_idx, pin_idx + n_pins); + pin_features.index_put_({rows, featureIndex(PinFeatureIdx::CellIdx)}, cell_idx); + pin_features.index_put_({rows, featureIndex(PinFeatureIdx::PinX)}, pin_x); + pin_features.index_put_({rows, featureIndex(PinFeatureIdx::PinY)}, pin_y); + pin_features.index_put_({rows, featureIndex(PinFeatureIdx::X)}, pin_x); + pin_features.index_put_({rows, featureIndex(PinFeatureIdx::Y)}, pin_y); + pin_features.index_put_({rows, featureIndex(PinFeatureIdx::Width)}, kPinSize); + pin_features.index_put_({rows, featureIndex(PinFeatureIdx::Height)}, kPinSize); + + pin_idx += n_pins; + } + + auto pin_to_cell = torch::zeros({total_pins}, long_options); + pin_idx = 0; + for (int64_t cell_idx = 0; cell_idx < total_cells; ++cell_idx) { + const int64_t n_pins = num_pins_per_cell[cell_idx].item(); + pin_to_cell.index_put_({Slice(pin_idx, pin_idx + n_pins)}, cell_idx); + pin_idx += n_pins; + } + + std::vector> edges; + std::vector> adjacency(total_pins); + for (int64_t pin = 0; pin < total_pins; ++pin) { + const int64_t num_connections = torch::randint(1, 4, {1}, long_options)[0].item(); + for (int64_t connection = 0; connection < num_connections; ++connection) { + const int64_t other_pin = + torch::randint(0, total_pins, {1}, long_options)[0].item(); + if (other_pin == pin || adjacency[pin].contains(other_pin)) { + continue; + } + edges.emplace_back(std::min(pin, other_pin), std::max(pin, other_pin)); + adjacency[pin].insert(other_pin); + adjacency[other_pin].insert(pin); + } + } + + torch::Tensor edge_list; + if (edges.empty()) { + edge_list = torch::zeros({0, 2}, long_options); + } else { + std::vector flat_edges; + flat_edges.reserve(edges.size() * 2); + for (const auto& edge : edges) { + flat_edges.push_back(edge.first); + flat_edges.push_back(edge.second); + } + edge_list = torch::from_blob( + flat_edges.data(), + {static_cast(edges.size()), 2}, + torch::TensorOptions().dtype(torch::kInt64)) + .clone() + .to(device); + } + + if (verbose) { + std::cout << "\nGenerated placement data:\n"; + std::cout << " Total cells: " << total_cells << "\n"; + std::cout << " Total pins: " << total_pins << "\n"; + std::cout << " Total edges: " << edge_list.size(0) << "\n"; + const double avg_edges_per_pin = + total_pins == 0 ? 0.0 : 2.0 * static_cast(edge_list.size(0)) / total_pins; + std::cout << " Average edges per pin: " << avg_edges_per_pin << "\n"; + } + + return {cell_features, pin_features, edge_list}; +} + +void initializeCellPositions(torch::Tensor& cell_features, double spread_scale) { + const int64_t total_cells = cell_features.size(0); + const double total_area = + cell_features.index({Slice(), featureIndex(CellFeatureIdx::Area)}) + .sum() + .item(); + const double spread_radius = + std::max(std::sqrt(total_area) * spread_scale, 1.0); + const auto options = cell_features.options(); + + const auto angles = torch::rand({total_cells}, options) * kTwoPi; + const auto radii = torch::rand({total_cells}, options) * spread_radius; + cell_features.index_put_( + {Slice(), featureIndex(CellFeatureIdx::X)}, + radii * torch::cos(angles)); + cell_features.index_put_( + {Slice(), featureIndex(CellFeatureIdx::Y)}, + radii * torch::sin(angles)); +} + +} // namespace placement diff --git a/cpp/include/placement/benchmark.h b/cpp/include/placement/benchmark.h new file mode 100644 index 0000000..7443534 --- /dev/null +++ b/cpp/include/placement/benchmark.h @@ -0,0 +1,24 @@ +#pragma once + +#include "placement/types.h" + +#include + +namespace placement { + +const std::vector& activeBenchmarkCases(); + +BenchmarkResult runBenchmarkCase( + const BenchmarkCase& test_case, + const TrainingConfig& config = {}); + +BenchmarkSummary runBenchmarkCases( + const std::vector& test_cases, + const TrainingConfig& config = {}, + int worker_count = 1); + +BenchmarkSummary runActiveBenchmarkCases( + const TrainingConfig& config = {}, + int worker_count = 1); + +} // namespace placement diff --git a/cpp/include/placement/generation.h b/cpp/include/placement/generation.h new file mode 100644 index 0000000..e5fa1eb --- /dev/null +++ b/cpp/include/placement/generation.h @@ -0,0 +1,15 @@ +#pragma once + +#include "placement/types.h" + +namespace placement { + +PlacementProblem generatePlacementInput( + int num_macros, + int num_std_cells, + const torch::Device& device = torch::kCPU, + bool verbose = true); + +void initializeCellPositions(torch::Tensor& cell_features, double spread_scale = 0.6); + +} // namespace placement diff --git a/cpp/include/placement/losses.h b/cpp/include/placement/losses.h new file mode 100644 index 0000000..326cfc5 --- /dev/null +++ b/cpp/include/placement/losses.h @@ -0,0 +1,19 @@ +#pragma once + +#include "placement/types.h" + +namespace placement { + +torch::Tensor computePairwiseOverlapAreas(const torch::Tensor& cell_features); + +torch::Tensor wirelengthAttractionLoss( + const torch::Tensor& cell_features, + const torch::Tensor& pin_features, + const torch::Tensor& edge_list); + +torch::Tensor overlapRepulsionLoss( + const torch::Tensor& cell_features, + const torch::Tensor& pin_features, + const torch::Tensor& edge_list); + +} // namespace placement diff --git a/cpp/include/placement/metrics.h b/cpp/include/placement/metrics.h new file mode 100644 index 0000000..e9e7ff7 --- /dev/null +++ b/cpp/include/placement/metrics.h @@ -0,0 +1,14 @@ +#pragma once + +#include "placement/types.h" + +namespace placement { + +OverlapMetrics calculateOverlapMetrics(const torch::Tensor& cell_features); + +Metrics calculateNormalizedMetrics( + const torch::Tensor& cell_features, + const torch::Tensor& pin_features, + const torch::Tensor& edge_list); + +} // namespace placement diff --git a/cpp/include/placement/sqlite_utils.hpp b/cpp/include/placement/sqlite_utils.hpp new file mode 100644 index 0000000..a1baa6b --- /dev/null +++ b/cpp/include/placement/sqlite_utils.hpp @@ -0,0 +1,104 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +struct sqlite3; +struct sqlite3_stmt; + +namespace placement { + +struct LossHistory; + +struct LossHistoryRunMetadata { + std::optional test_id; + std::string runner; + std::string run_label = "train_placement"; + std::string run_started_at; + int seed = 0; + int num_macros = 0; + int num_std_cells = 0; + int num_epochs = 0; + double lr = 0.0; + double lambda_wirelength = 0.0; + double lambda_overlap = 0.0; + int log_interval = 0; + bool verbose = false; + int64_t total_cells = 0; + int64_t total_pins = 0; + int64_t total_edges = 0; +}; + +std::string sqliteError(sqlite3* db); + +[[noreturn]] void throwSqliteError(sqlite3* db, std::string_view context); + +void checkSqliteResult( + sqlite3* db, + int result_code, + std::string_view context); + +void executeSql(sqlite3* db, std::string_view sql, std::string_view context); + +class SqliteConnection { +public: + explicit SqliteConnection(const std::filesystem::path& db_path); + + SqliteConnection(const SqliteConnection&) = delete; + SqliteConnection& operator=(const SqliteConnection&) = delete; + + ~SqliteConnection(); + + sqlite3* get() const; + +private: + sqlite3* db_ = nullptr; +}; + +class SqliteStatement { +public: + SqliteStatement(sqlite3* db, std::string_view sql); + + SqliteStatement(const SqliteStatement&) = delete; + SqliteStatement& operator=(const SqliteStatement&) = delete; + + ~SqliteStatement(); + + sqlite3_stmt* get() const; + bool stepRow(); + void stepDone(); + void reset(); + +private: + sqlite3* db_ = nullptr; + sqlite3_stmt* stmt_ = nullptr; +}; + +void bindNull(sqlite3_stmt* stmt, int index); +void bindText(sqlite3_stmt* stmt, int index, std::string_view value); +void bindInt64(sqlite3_stmt* stmt, int index, int64_t value); +void bindBool(sqlite3_stmt* stmt, int index, bool value); +void bindDouble(sqlite3_stmt* stmt, int index, double value); +void bindOptionalInt64( + sqlite3_stmt* stmt, + int index, + const std::optional& value); + +void ensureColumns( + sqlite3* db, + std::string_view table_name, + const std::vector>& columns); + +std::filesystem::path createLossTrackingDb(); + +std::filesystem::path saveLossHistorySqlite( + const LossHistory& history, + const std::filesystem::path& db_path, + const LossHistoryRunMetadata& metadata); + +} // namespace placement diff --git a/cpp/include/placement/training.h b/cpp/include/placement/training.h new file mode 100644 index 0000000..f54853d --- /dev/null +++ b/cpp/include/placement/training.h @@ -0,0 +1,13 @@ +#pragma once + +#include "placement/types.h" + +namespace placement { + +TrainingResult trainPlacement( + const torch::Tensor& cell_features, + const torch::Tensor& pin_features, + const torch::Tensor& edge_list, + const TrainingConfig& config = {}); + +} // namespace placement diff --git a/cpp/include/placement/types.h b/cpp/include/placement/types.h new file mode 100644 index 0000000..7deed89 --- /dev/null +++ b/cpp/include/placement/types.h @@ -0,0 +1,135 @@ +#pragma once + +#include + +#include +#include +#include + +namespace placement { + +enum class CellFeatureIdx : int64_t { + Area = 0, + NumPins = 1, + X = 2, + Y = 3, + Width = 4, + Height = 5, +}; + +enum class PinFeatureIdx : int64_t { + CellIdx = 0, + PinX = 1, + PinY = 2, + X = 3, + Y = 4, + Width = 5, + Height = 6, +}; + +struct PlacementProblem { + torch::Tensor cell_features; + torch::Tensor pin_features; + torch::Tensor edge_list; +}; + +struct TrainingConfig { + c10::DeviceType device = torch::kCPU; + int num_epochs = 1000; + double lr = 0.1; + double lambda_wirelength = 3.0; + double lambda_overlap = 1.0; + std::string scheduler_name = "plateau"; + int scheduler_patience = 50; + double scheduler_factor = 0.5; + double scheduler_eta_min = 1e-4; + int scheduler_step_size = 100; + double scheduler_gamma = 0.95; + bool track_loss_history = false; + bool track_overlap_metrics = false; + bool early_stop_enabled = true; + int early_stop_patience = 75; + double early_stop_min_delta = 1e-4; + double early_stop_overlap_threshold = 1e-4; + int early_stop_zero_overlap_patience = 25; + bool verbose = true; + int log_interval = 100; +}; + +struct LossHistory { + std::vector total_loss; + std::vector wirelength_loss; + std::vector overlap_loss; + std::vector learning_rate; + std::vector overlap_count; + std::vector total_overlap_area; + std::vector max_overlap_area; +}; + +struct TrainingResult { + torch::Tensor final_cell_features; + torch::Tensor initial_cell_features; + bool stopped_early = false; + std::string stop_reason; + std::string run_started_at; + int best_epoch = -1; + int epochs_completed = 0; + LossHistory loss_history; +}; + +struct OverlapMetrics { + int overlap_count = 0; + double total_overlap_area = 0.0; + double max_overlap_area = 0.0; + double overlap_percentage = 0.0; + int cells_with_overlap = 0; + bool has_zero_overlap = true; +}; + +struct Metrics { + double overlap_ratio = 0.0; + double normalized_wl = 0.0; + int num_cells_with_overlaps = 0; + int64_t total_cells = 0; + int64_t num_nets = 0; +}; + +struct BenchmarkCase { + int test_id = 0; + int num_macros = 0; + int num_std_cells = 0; + int seed = 0; +}; + +struct BenchmarkResult { + int test_id = 0; + int num_macros = 0; + int num_std_cells = 0; + int64_t total_cells = 0; + int64_t total_pins = 0; + int64_t num_nets = 0; + int seed = 0; + c10::DeviceType device = torch::kCPU; + double elapsed_seconds = 0.0; + int num_cells_with_overlaps = 0; + double overlap_ratio = 0.0; + double normalized_wl = 0.0; + bool passed = false; + bool stopped_early = false; + std::string stop_reason; + std::string run_started_at; + int best_epoch = -1; + int epochs_completed = 0; + LossHistory loss_history; +}; + +struct BenchmarkSummary { + std::vector results; + double average_overlap = 0.0; + double average_wirelength = 0.0; + double total_elapsed_seconds = 0.0; + int passed_count = 0; + int failed_count = 0; +}; + +} // namespace placement diff --git a/cpp/include/placement/visualization.h b/cpp/include/placement/visualization.h new file mode 100644 index 0000000..c30c4da --- /dev/null +++ b/cpp/include/placement/visualization.h @@ -0,0 +1,14 @@ +#pragma once + +#include + +#include + +namespace placement { + +void plotPlacement( + const torch::Tensor& initial_cell_features, + const torch::Tensor& final_cell_features, + const std::filesystem::path& output_path); + +} // namespace placement diff --git a/cpp/losses.cpp b/cpp/losses.cpp new file mode 100644 index 0000000..e77a506 --- /dev/null +++ b/cpp/losses.cpp @@ -0,0 +1,114 @@ +#include "placement/losses.h" + +#include + +namespace { + +using namespace torch::indexing; + +int64_t featureIndex(placement::CellFeatureIdx idx) { + return static_cast(idx); +} + +int64_t featureIndex(placement::PinFeatureIdx idx) { + return static_cast(idx); +} + +torch::Tensor differentiableZero(const torch::Tensor& like) { + auto zero = torch::zeros({}, like.options()); + zero.set_requires_grad(true); + return zero; +} + +} // namespace + +namespace placement { + +torch::Tensor computePairwiseOverlapAreas(const torch::Tensor& cell_features) { + const int64_t num_cells = cell_features.size(0); + if (num_cells <= 1) { + return torch::zeros({num_cells, num_cells}, cell_features.options()); + } + + const auto x_col = + cell_features.index({Slice(), featureIndex(CellFeatureIdx::X)}); + const auto y_col = + cell_features.index({Slice(), featureIndex(CellFeatureIdx::Y)}); + const auto widths = + cell_features.index({Slice(), featureIndex(CellFeatureIdx::Width)}); + const auto heights = + cell_features.index({Slice(), featureIndex(CellFeatureIdx::Height)}); + + const auto x_delta = torch::abs(x_col.unsqueeze(1) - x_col.unsqueeze(0)); + const auto y_delta = torch::abs(y_col.unsqueeze(1) - y_col.unsqueeze(0)); + const auto x_span = (widths.unsqueeze(1) + widths.unsqueeze(0)) / 2.0; + const auto y_span = (heights.unsqueeze(1) + heights.unsqueeze(0)) / 2.0; + + const auto overlap_x = torch::relu(x_span - x_delta); + const auto overlap_y = torch::relu(y_span - y_delta); + return overlap_x * overlap_y; +} + +torch::Tensor wirelengthAttractionLoss( + const torch::Tensor& cell_features, + const torch::Tensor& pin_features, + const torch::Tensor& edge_list) { + const int64_t num_edges = edge_list.size(0); + if (num_edges == 0) { + return differentiableZero(cell_features); + } + + const auto cell_positions = cell_features.index( + {Slice(), + Slice( + featureIndex(CellFeatureIdx::X), + featureIndex(CellFeatureIdx::Y) + 1)}); + const auto cell_indices = + pin_features.index({Slice(), featureIndex(PinFeatureIdx::CellIdx)}) + .to(torch::kInt64); + + const auto pin_cell_positions = cell_positions.index_select(0, cell_indices); + const auto pin_absolute_x = + pin_cell_positions.index({Slice(), 0}) + + pin_features.index({Slice(), featureIndex(PinFeatureIdx::PinX)}); + const auto pin_absolute_y = + pin_cell_positions.index({Slice(), 1}) + + pin_features.index({Slice(), featureIndex(PinFeatureIdx::PinY)}); + + const auto src_pins = edge_list.index({Slice(), 0}).to(torch::kInt64); + const auto tgt_pins = edge_list.index({Slice(), 1}).to(torch::kInt64); + + const auto src_x = pin_absolute_x.index_select(0, src_pins); + const auto src_y = pin_absolute_y.index_select(0, src_pins); + const auto tgt_x = pin_absolute_x.index_select(0, tgt_pins); + const auto tgt_y = pin_absolute_y.index_select(0, tgt_pins); + + constexpr double kAlpha = 0.1; + const auto dx = torch::abs(src_x - tgt_x); + const auto dy = torch::abs(src_y - tgt_y); + const auto smooth_manhattan = + kAlpha * torch::logsumexp(torch::stack({dx / kAlpha, dy / kAlpha}, 0), 0); + + return smooth_manhattan.sum() / static_cast(num_edges); +} + +torch::Tensor overlapRepulsionLoss( + const torch::Tensor& cell_features, + const torch::Tensor& pin_features, + const torch::Tensor& edge_list) { + (void)pin_features; + (void)edge_list; + + const int64_t num_cells = cell_features.size(0); + if (num_cells <= 1) { + return differentiableZero(cell_features); + } + + const auto pairwise_overlap_area = computePairwiseOverlapAreas(cell_features); + const auto mask = torch::triu(torch::ones_like(pairwise_overlap_area), 1); + + constexpr double kOverlapScalar = 200.0; + return torch::log1p(torch::sum(pairwise_overlap_area * mask)) * kOverlapScalar; +} + +} // namespace placement diff --git a/cpp/metrics.cpp b/cpp/metrics.cpp new file mode 100644 index 0000000..3fad55b --- /dev/null +++ b/cpp/metrics.cpp @@ -0,0 +1,179 @@ +#include "placement/metrics.h" + +#include +#include +#include +#include + +namespace { + +using namespace torch::indexing; + +int64_t featureIndex(placement::CellFeatureIdx idx) { + return static_cast(idx); +} + +int64_t featureIndex(placement::PinFeatureIdx idx) { + return static_cast(idx); +} + +int toMetricInt(int64_t value) { + return static_cast( + std::min(value, std::numeric_limits::max())); +} + +torch::Tensor upperTriangleMask(int64_t size, const torch::Device& device) { + const auto options = torch::TensorOptions().dtype(torch::kInt64).device(device); + const auto indices = torch::arange(size, options); + return indices.unsqueeze(1) < indices.unsqueeze(0); +} + +torch::Tensor computePairwiseOverlapAreasForMetrics( + const torch::Tensor& cell_features) { + const int64_t num_cells = cell_features.size(0); + if (num_cells <= 1) { + return torch::zeros({num_cells, num_cells}, cell_features.options()); + } + + const auto x_col = + cell_features.index({Slice(), featureIndex(placement::CellFeatureIdx::X)}); + const auto y_col = + cell_features.index({Slice(), featureIndex(placement::CellFeatureIdx::Y)}); + const auto widths = + cell_features.index({Slice(), featureIndex(placement::CellFeatureIdx::Width)}); + const auto heights = + cell_features.index({Slice(), featureIndex(placement::CellFeatureIdx::Height)}); + + const auto x_delta = torch::abs(x_col.unsqueeze(1) - x_col.unsqueeze(0)); + const auto y_delta = torch::abs(y_col.unsqueeze(1) - y_col.unsqueeze(0)); + const auto x_span = (widths.unsqueeze(1) + widths.unsqueeze(0)) / 2.0; + const auto y_span = (heights.unsqueeze(1) + heights.unsqueeze(0)) / 2.0; + + const auto overlap_x = torch::relu(x_span - x_delta); + const auto overlap_y = torch::relu(y_span - y_delta); + return overlap_x * overlap_y; +} + +double calculateAverageSmoothWirelength( + const torch::Tensor& cell_features, + const torch::Tensor& pin_features, + const torch::Tensor& edge_list) { + const int64_t num_edges = edge_list.size(0); + if (num_edges == 0) { + return 0.0; + } + + const auto cell_positions = cell_features.index( + {Slice(), + Slice( + featureIndex(placement::CellFeatureIdx::X), + featureIndex(placement::CellFeatureIdx::Y) + 1)}); + const auto cell_indices = + pin_features.index({Slice(), featureIndex(placement::PinFeatureIdx::CellIdx)}) + .to(torch::kInt64); + const auto pin_cell_positions = cell_positions.index_select(0, cell_indices); + + const auto pin_absolute_x = + pin_cell_positions.index({Slice(), 0}) + + pin_features.index({Slice(), featureIndex(placement::PinFeatureIdx::PinX)}); + const auto pin_absolute_y = + pin_cell_positions.index({Slice(), 1}) + + pin_features.index({Slice(), featureIndex(placement::PinFeatureIdx::PinY)}); + + const auto src_pins = edge_list.index({Slice(), 0}).to(torch::kInt64); + const auto tgt_pins = edge_list.index({Slice(), 1}).to(torch::kInt64); + + const auto dx = torch::abs( + pin_absolute_x.index_select(0, src_pins) - + pin_absolute_x.index_select(0, tgt_pins)); + const auto dy = torch::abs( + pin_absolute_y.index_select(0, src_pins) - + pin_absolute_y.index_select(0, tgt_pins)); + + constexpr double kAlpha = 0.1; + const auto smooth_manhattan = + kAlpha * torch::logsumexp(torch::stack({dx / kAlpha, dy / kAlpha}, 0), 0); + + return smooth_manhattan.mean().item(); +} + +} // namespace + +namespace placement { + +OverlapMetrics calculateOverlapMetrics(const torch::Tensor& cell_features) { + OverlapMetrics metrics; + const int64_t num_cells = cell_features.size(0); + if (num_cells <= 1) { + return metrics; + } + + const auto pairwise_overlap_area = + computePairwiseOverlapAreasForMetrics(cell_features); + const auto mask = upperTriangleMask(num_cells, cell_features.device()); + const auto active_overlap_areas = pairwise_overlap_area.masked_select(mask); + const auto overlapping_pairs = active_overlap_areas > 0; + + const int64_t overlap_count = overlapping_pairs.sum().item(); + metrics.overlap_count = toMetricInt(overlap_count); + metrics.total_overlap_area = active_overlap_areas.sum().item(); + metrics.max_overlap_area = + active_overlap_areas.numel() == 0 + ? 0.0 + : active_overlap_areas.max().item(); + + const auto upper_overlap_matrix = + torch::logical_and(pairwise_overlap_area > 0, mask); + const auto overlap_matrix = + torch::logical_or(upper_overlap_matrix, upper_overlap_matrix.transpose(0, 1)); + metrics.cells_with_overlap = + toMetricInt(overlap_matrix.any(0).sum().item()); + + const double total_area = + cell_features.index({Slice(), featureIndex(CellFeatureIdx::Area)}) + .sum() + .item(); + metrics.overlap_percentage = + total_area > 0.0 + ? static_cast(overlap_count) / static_cast(num_cells) * + 100.0 + : 0.0; + metrics.has_zero_overlap = metrics.overlap_count == 0; + return metrics; +} + +Metrics calculateNormalizedMetrics( + const torch::Tensor& cell_features, + const torch::Tensor& pin_features, + const torch::Tensor& edge_list) { + Metrics metrics; + metrics.total_cells = cell_features.size(0); + metrics.num_nets = edge_list.size(0); + + const OverlapMetrics overlap_metrics = calculateOverlapMetrics(cell_features); + metrics.num_cells_with_overlaps = overlap_metrics.cells_with_overlap; + metrics.overlap_ratio = + metrics.total_cells > 0 + ? static_cast(metrics.num_cells_with_overlaps) / + static_cast(metrics.total_cells) + : 0.0; + + if (metrics.num_nets == 0) { + return metrics; + } + + const double total_area = + cell_features.index({Slice(), featureIndex(CellFeatureIdx::Area)}) + .sum() + .item(); + if (total_area <= 0.0) { + return metrics; + } + + metrics.normalized_wl = + calculateAverageSmoothWirelength(cell_features, pin_features, edge_list) / + std::sqrt(total_area); + return metrics; +} + +} // namespace placement diff --git a/cpp/placement.cpp b/cpp/placement.cpp new file mode 100644 index 0000000..1c462c8 --- /dev/null +++ b/cpp/placement.cpp @@ -0,0 +1,1119 @@ +#include "placement/benchmark.h" +#include "placement/generation.h" +#include "placement/metrics.h" +#include "placement/sqlite_utils.hpp" +#include "placement/training.h" +#include "placement/types.h" +#include "placement/visualization.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { + +using placement::LossHistoryRunMetadata; +using placement::createLossTrackingDb; +using placement::saveLossHistorySqlite; + +struct CliOptions { + bool run_benchmark = false; + std::string device = "auto"; + int test_case_id = 0; + int num_macros = 3; + int num_std_cells = 10; + int seed = 42; + bool write_output_files = false; + std::string output_dir = ".."; +}; + +std::string deviceTypeName(c10::DeviceType device) { + switch (device) { + case c10::DeviceType::CPU: + return "cpu"; + case c10::DeviceType::CUDA: + return "cuda"; + case c10::DeviceType::MPS: + return "mps"; + default: + return "unknown"; + } +} + +c10::DeviceType resolveDeviceType(const std::string& device) { + if (device == "auto") { + if (torch::cuda::is_available()) { + return torch::kCUDA; + } + if (torch::mps::is_available()) { + return torch::kMPS; + } + return torch::kCPU; + } + if (device == "cpu") { + return torch::kCPU; + } + if (device == "cuda") { + if (!torch::cuda::is_available()) { + throw std::invalid_argument("CUDA device requested but unavailable"); + } + return torch::kCUDA; + } + if (device == "mps") { + if (!torch::mps::is_available()) { + throw std::invalid_argument("MPS device requested but unavailable"); + } + return torch::kMPS; + } + throw std::invalid_argument("Unsupported device: " + device); +} + +void seedTorch(int seed) { + torch::manual_seed(static_cast(seed)); + if (torch::cuda::is_available()) { + torch::cuda::manual_seed_all(static_cast(seed)); + } + if (torch::mps::is_available()) { + torch::mps::manual_seed(static_cast(seed)); + } +} + +std::vector allKnownBenchmarkCases() { + std::vector cases( + placement::activeBenchmarkCases().begin(), + placement::activeBenchmarkCases().end()); + cases.push_back({11, 10, 10000, 1011}); + cases.push_back({12, 10, 100000, 1012}); + return cases; +} + +std::optional findBenchmarkCase(int test_case_id) { + for (const placement::BenchmarkCase& test_case : allKnownBenchmarkCases()) { + if (test_case.test_id == test_case_id) { + return test_case; + } + } + return std::nullopt; +} + +std::string formatDouble(double value) { + std::ostringstream stream; + stream << std::setprecision(17) << value; + return stream.str(); +} + +std::string boolText(bool value) { + return value ? "true" : "false"; +} + +std::string csvEscape(std::string_view value) { + if (value.find_first_of("\",\n\r") == std::string_view::npos) { + return std::string(value); + } + + std::string escaped; + escaped.reserve(value.size() + 2); + escaped.push_back('"'); + for (char ch : value) { + if (ch == '"') { + escaped.push_back('"'); + } + escaped.push_back(ch); + } + escaped.push_back('"'); + return escaped; +} + +std::string jsonEscape(std::string_view value) { + std::ostringstream escaped; + for (unsigned char ch : value) { + switch (ch) { + case '"': + escaped << "\\\""; + break; + case '\\': + escaped << "\\\\"; + break; + case '\b': + escaped << "\\b"; + break; + case '\f': + escaped << "\\f"; + break; + case '\n': + escaped << "\\n"; + break; + case '\r': + escaped << "\\r"; + break; + case '\t': + escaped << "\\t"; + break; + default: + if (ch < 0x20) { + escaped << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << static_cast(ch) + << std::dec << std::setfill(' '); + } else { + escaped << static_cast(ch); + } + break; + } + } + return escaped.str(); +} + +std::string jsonString(std::string_view value) { + std::string quoted = "\""; + quoted += jsonEscape(value); + quoted += "\""; + return quoted; +} + +std::string jsonDouble(double value) { + if (!std::isfinite(value)) { + return "null"; + } + return formatDouble(value); +} + +std::string jsonBool(bool value) { + return boolText(value); +} + +std::filesystem::path outputFilePath( + const CliOptions& options, + std::string_view file_name) { + const std::filesystem::path output_dir = + options.output_dir.empty() ? std::filesystem::path(".") + : std::filesystem::path(options.output_dir); + return output_dir / std::string(file_name); +} + +void writeTextFile( + const std::filesystem::path& file_path, + const std::string& contents) { + const std::filesystem::path parent_path = file_path.parent_path(); + if (!parent_path.empty()) { + std::filesystem::create_directories(parent_path); + } + + std::ofstream output(file_path, std::ios::out | std::ios::trunc); + if (!output) { + throw std::runtime_error( + "Unable to open output file: " + file_path.string()); + } + output << contents; + if (!output) { + throw std::runtime_error( + "Unable to write output file: " + file_path.string()); + } +} + +void appendCsvRow( + std::ostringstream& output, + const std::vector& fields) { + for (std::size_t index = 0; index < fields.size(); ++index) { + if (index > 0) { + output << ","; + } + output << csvEscape(fields[index]); + } + output << "\n"; +} + +void writeCsvFile( + const std::filesystem::path& file_path, + const std::vector& header, + const std::vector>& rows) { + std::ostringstream output; + appendCsvRow(output, header); + for (const std::vector& row : rows) { + appendCsvRow(output, row); + } + writeTextFile(file_path, output.str()); +} + +void appendJsonField( + std::ostringstream& output, + int indent, + std::string_view key, + const std::string& value, + bool trailing_comma) { + output << std::string(indent, ' ') << jsonString(key) << ": " << value; + if (trailing_comma) { + output << ","; + } + output << "\n"; +} + +using JsonField = std::pair; + +void appendJsonObject( + std::ostringstream& output, + const std::vector& fields, + int indent) { + output << std::string(indent, ' ') << "{\n"; + for (std::size_t index = 0; index < fields.size(); ++index) { + appendJsonField( + output, + indent + 2, + fields[index].first, + fields[index].second, + index + 1 < fields.size()); + } + output << std::string(indent, ' ') << "}"; +} + +std::vector benchmarkResultHeader() { + return { + "test_id", + "num_macros", + "num_std_cells", + "total_cells", + "num_nets", + "seed", + "device", + "elapsed_seconds", + "num_cells_with_overlaps", + "overlap_ratio", + "normalized_wl", + "passed", + "stopped_early", + "stop_reason", + "best_epoch", + "epochs_completed", + }; +} + +std::vector benchmarkResultRow( + const placement::BenchmarkResult& result) { + return { + std::to_string(result.test_id), + std::to_string(result.num_macros), + std::to_string(result.num_std_cells), + std::to_string(result.total_cells), + std::to_string(result.num_nets), + std::to_string(result.seed), + deviceTypeName(result.device), + formatDouble(result.elapsed_seconds), + std::to_string(result.num_cells_with_overlaps), + formatDouble(result.overlap_ratio), + formatDouble(result.normalized_wl), + boolText(result.passed), + boolText(result.stopped_early), + result.stop_reason, + std::to_string(result.best_epoch), + std::to_string(result.epochs_completed), + }; +} + +std::vector benchmarkResultJsonFields( + const placement::BenchmarkResult& result) { + return { + {"test_id", std::to_string(result.test_id)}, + {"num_macros", std::to_string(result.num_macros)}, + {"num_std_cells", std::to_string(result.num_std_cells)}, + {"total_cells", std::to_string(result.total_cells)}, + {"num_nets", std::to_string(result.num_nets)}, + {"seed", std::to_string(result.seed)}, + {"device", jsonString(deviceTypeName(result.device))}, + {"elapsed_seconds", jsonDouble(result.elapsed_seconds)}, + {"num_cells_with_overlaps", + std::to_string(result.num_cells_with_overlaps)}, + {"overlap_ratio", jsonDouble(result.overlap_ratio)}, + {"normalized_wl", jsonDouble(result.normalized_wl)}, + {"passed", jsonBool(result.passed)}, + {"stopped_early", jsonBool(result.stopped_early)}, + {"stop_reason", jsonString(result.stop_reason)}, + {"best_epoch", std::to_string(result.best_epoch)}, + {"epochs_completed", std::to_string(result.epochs_completed)}, + }; +} + +std::vector singlePlacementHeader() { + return { + "run_type", + "test_case_id", + "seed", + "device", + "num_macros", + "num_std_cells", + "total_cells", + "num_nets", + "initial_overlap_count", + "initial_total_overlap_area", + "initial_max_overlap_area", + "initial_overlap_percentage", + "initial_cells_with_overlap", + "initial_has_zero_overlap", + "final_overlap_count", + "final_total_overlap_area", + "final_max_overlap_area", + "final_overlap_percentage", + "final_cells_with_overlap", + "final_has_zero_overlap", + "normalized_overlap_ratio", + "normalized_wl", + "normalized_num_cells_with_overlaps", + "normalized_total_cells", + "normalized_num_nets", + "passed", + "stopped_early", + "stop_reason", + "best_epoch", + "epochs_completed", + "num_epochs", + "early_stop_enabled", + "early_stop_patience", + "early_stop_min_delta", + "early_stop_overlap_threshold", + "early_stop_zero_overlap_patience", + "visualization_path", + }; +} + +std::vector singlePlacementRow( + const placement::BenchmarkCase& selected_case, + const placement::TrainingConfig& config, + const placement::OverlapMetrics& initial_metrics, + const placement::OverlapMetrics& final_metrics, + const placement::Metrics& normalized_metrics, + const placement::TrainingResult& training_result, + bool passed, + const std::filesystem::path& visualization_path) { + return { + "single", + std::to_string(selected_case.test_id), + std::to_string(selected_case.seed), + deviceTypeName(config.device), + std::to_string(selected_case.num_macros), + std::to_string(selected_case.num_std_cells), + std::to_string(normalized_metrics.total_cells), + std::to_string(normalized_metrics.num_nets), + std::to_string(initial_metrics.overlap_count), + formatDouble(initial_metrics.total_overlap_area), + formatDouble(initial_metrics.max_overlap_area), + formatDouble(initial_metrics.overlap_percentage), + std::to_string(initial_metrics.cells_with_overlap), + boolText(initial_metrics.has_zero_overlap), + std::to_string(final_metrics.overlap_count), + formatDouble(final_metrics.total_overlap_area), + formatDouble(final_metrics.max_overlap_area), + formatDouble(final_metrics.overlap_percentage), + std::to_string(final_metrics.cells_with_overlap), + boolText(final_metrics.has_zero_overlap), + formatDouble(normalized_metrics.overlap_ratio), + formatDouble(normalized_metrics.normalized_wl), + std::to_string(normalized_metrics.num_cells_with_overlaps), + std::to_string(normalized_metrics.total_cells), + std::to_string(normalized_metrics.num_nets), + boolText(passed), + boolText(training_result.stopped_early), + training_result.stop_reason, + std::to_string(training_result.best_epoch), + std::to_string(training_result.epochs_completed), + std::to_string(config.num_epochs), + boolText(config.early_stop_enabled), + std::to_string(config.early_stop_patience), + formatDouble(config.early_stop_min_delta), + formatDouble(config.early_stop_overlap_threshold), + std::to_string(config.early_stop_zero_overlap_patience), + visualization_path.string(), + }; +} + +std::vector singlePlacementJsonFields( + const placement::BenchmarkCase& selected_case, + const placement::TrainingConfig& config, + const placement::OverlapMetrics& initial_metrics, + const placement::OverlapMetrics& final_metrics, + const placement::Metrics& normalized_metrics, + const placement::TrainingResult& training_result, + bool passed, + const std::filesystem::path& visualization_path) { + return { + {"run_type", jsonString("single")}, + {"test_case_id", std::to_string(selected_case.test_id)}, + {"seed", std::to_string(selected_case.seed)}, + {"device", jsonString(deviceTypeName(config.device))}, + {"num_macros", std::to_string(selected_case.num_macros)}, + {"num_std_cells", std::to_string(selected_case.num_std_cells)}, + {"total_cells", std::to_string(normalized_metrics.total_cells)}, + {"num_nets", std::to_string(normalized_metrics.num_nets)}, + {"initial_overlap_count", + std::to_string(initial_metrics.overlap_count)}, + {"initial_total_overlap_area", + jsonDouble(initial_metrics.total_overlap_area)}, + {"initial_max_overlap_area", + jsonDouble(initial_metrics.max_overlap_area)}, + {"initial_overlap_percentage", + jsonDouble(initial_metrics.overlap_percentage)}, + {"initial_cells_with_overlap", + std::to_string(initial_metrics.cells_with_overlap)}, + {"initial_has_zero_overlap", + jsonBool(initial_metrics.has_zero_overlap)}, + {"final_overlap_count", std::to_string(final_metrics.overlap_count)}, + {"final_total_overlap_area", + jsonDouble(final_metrics.total_overlap_area)}, + {"final_max_overlap_area", jsonDouble(final_metrics.max_overlap_area)}, + {"final_overlap_percentage", + jsonDouble(final_metrics.overlap_percentage)}, + {"final_cells_with_overlap", + std::to_string(final_metrics.cells_with_overlap)}, + {"final_has_zero_overlap", jsonBool(final_metrics.has_zero_overlap)}, + {"normalized_overlap_ratio", + jsonDouble(normalized_metrics.overlap_ratio)}, + {"normalized_wl", jsonDouble(normalized_metrics.normalized_wl)}, + {"normalized_num_cells_with_overlaps", + std::to_string(normalized_metrics.num_cells_with_overlaps)}, + {"normalized_total_cells", + std::to_string(normalized_metrics.total_cells)}, + {"normalized_num_nets", std::to_string(normalized_metrics.num_nets)}, + {"passed", jsonBool(passed)}, + {"stopped_early", jsonBool(training_result.stopped_early)}, + {"stop_reason", jsonString(training_result.stop_reason)}, + {"best_epoch", std::to_string(training_result.best_epoch)}, + {"epochs_completed", std::to_string(training_result.epochs_completed)}, + {"num_epochs", std::to_string(config.num_epochs)}, + {"early_stop_enabled", jsonBool(config.early_stop_enabled)}, + {"early_stop_patience", std::to_string(config.early_stop_patience)}, + {"early_stop_min_delta", jsonDouble(config.early_stop_min_delta)}, + {"early_stop_overlap_threshold", + jsonDouble(config.early_stop_overlap_threshold)}, + {"early_stop_zero_overlap_patience", + std::to_string(config.early_stop_zero_overlap_patience)}, + {"visualization_path", jsonString(visualization_path.string())}, + }; +} + +void writeSinglePlacementArtifacts( + const CliOptions& options, + const placement::BenchmarkCase& selected_case, + const placement::TrainingConfig& config, + const placement::OverlapMetrics& initial_metrics, + const placement::OverlapMetrics& final_metrics, + const placement::Metrics& normalized_metrics, + const placement::TrainingResult& training_result, + bool passed) { + const std::filesystem::path visualization_path = + outputFilePath(options, "placement_result.png"); + placement::plotPlacement( + training_result.initial_cell_features, + training_result.final_cell_features, + visualization_path); + + writeCsvFile( + outputFilePath(options, "placement_result_summary.csv"), + singlePlacementHeader(), + {singlePlacementRow( + selected_case, + config, + initial_metrics, + final_metrics, + normalized_metrics, + training_result, + passed, + visualization_path)}); + + std::ostringstream json; + appendJsonObject( + json, + singlePlacementJsonFields( + selected_case, + config, + initial_metrics, + final_metrics, + normalized_metrics, + training_result, + passed, + visualization_path), + 0); + json << "\n"; + writeTextFile(outputFilePath(options, "placement_result_summary.json"), json.str()); +} + +void writeBenchmarkArtifacts( + const CliOptions& options, + const placement::BenchmarkSummary& summary) { + std::vector> case_rows; + case_rows.reserve(summary.results.size()); + for (const placement::BenchmarkResult& result : summary.results) { + case_rows.push_back(benchmarkResultRow(result)); + } + writeCsvFile( + outputFilePath(options, "placement_benchmark_cases.csv"), + benchmarkResultHeader(), + case_rows); + + writeCsvFile( + outputFilePath(options, "placement_benchmark_summary.csv"), + {"total_cases", + "average_overlap", + "average_wirelength", + "total_elapsed_seconds", + "passed_count", + "failed_count"}, + {{std::to_string(summary.results.size()), + formatDouble(summary.average_overlap), + formatDouble(summary.average_wirelength), + formatDouble(summary.total_elapsed_seconds), + std::to_string(summary.passed_count), + std::to_string(summary.failed_count)}}); + + std::ostringstream json; + json << "{\n"; + appendJsonField( + json, + 2, + "total_cases", + std::to_string(summary.results.size()), + true); + appendJsonField( + json, + 2, + "average_overlap", + jsonDouble(summary.average_overlap), + true); + appendJsonField( + json, + 2, + "average_wirelength", + jsonDouble(summary.average_wirelength), + true); + appendJsonField( + json, + 2, + "total_elapsed_seconds", + jsonDouble(summary.total_elapsed_seconds), + true); + appendJsonField( + json, + 2, + "passed_count", + std::to_string(summary.passed_count), + true); + appendJsonField( + json, + 2, + "failed_count", + std::to_string(summary.failed_count), + true); + json << " \"cases\": [\n"; + for (std::size_t index = 0; index < summary.results.size(); ++index) { + appendJsonObject(json, benchmarkResultJsonFields(summary.results[index]), 4); + if (index + 1 < summary.results.size()) { + json << ","; + } + json << "\n"; + } + json << " ]\n"; + json << "}\n"; + writeTextFile(outputFilePath(options, "placement_benchmark_summary.json"), json.str()); +} + +void printRule(char c = '=') { + std::cout << std::string(70, c) << "\n"; +} + +void printTrainingConfig(const placement::TrainingConfig& config) { + std::cout << "Using hyperparameters:\n"; + std::cout << " num_epochs: " << config.num_epochs << "\n"; + std::cout << " lr: " << config.lr << "\n"; + std::cout << " lambda_wirelength: " << config.lambda_wirelength << "\n"; + std::cout << " lambda_overlap: " << config.lambda_overlap << "\n"; + std::cout << " scheduler: " << config.scheduler_name << "\n"; + std::cout << " scheduler_patience: " << config.scheduler_patience << "\n"; + std::cout << " scheduler_factor: " << config.scheduler_factor << "\n"; + std::cout << " scheduler_eta_min: " << config.scheduler_eta_min << "\n"; + std::cout << " scheduler_step_size: " << config.scheduler_step_size << "\n"; + std::cout << " scheduler_gamma: " << config.scheduler_gamma << "\n"; + std::cout << " track_loss_history: " + << (config.track_loss_history ? "true" : "false") << "\n"; + std::cout << " track_overlap_metrics: " + << (config.track_overlap_metrics ? "true" : "false") << "\n"; + std::cout << " early_stop_enabled: " + << (config.early_stop_enabled ? "true" : "false") << "\n"; + std::cout << " early_stop_patience: " << config.early_stop_patience << "\n"; + std::cout << " early_stop_min_delta: " << config.early_stop_min_delta << "\n"; + std::cout << " early_stop_overlap_threshold: " + << config.early_stop_overlap_threshold << "\n"; + std::cout << " early_stop_zero_overlap_patience: " + << config.early_stop_zero_overlap_patience << "\n"; +} + +void printBenchmarkResult(const placement::BenchmarkResult& result) { + const char* status = result.passed ? "PASS" : "FAIL"; + std::cout << "Completed test " << result.test_id << ":\n"; + std::cout << " Device: " << deviceTypeName(result.device) << "\n"; + std::cout << " Overlap Ratio: " << std::fixed << std::setprecision(4) + << result.overlap_ratio << " (" << result.num_cells_with_overlaps + << "/" << result.total_cells << " cells)\n"; + std::cout << " Normalized WL: " << std::fixed << std::setprecision(4) + << result.normalized_wl << "\n"; + std::cout << " Epochs Completed: " << result.epochs_completed << "\n"; + if (result.stopped_early) { + std::cout << " Stopped Early: " << result.stop_reason + << " at best epoch " << result.best_epoch << "\n"; + } + std::cout << " Time: " << std::fixed << std::setprecision(2) + << result.elapsed_seconds << "s\n"; + std::cout << " Status: " << status << "\n\n"; +} + +int runBenchmark( + const CliOptions& options, + const placement::TrainingConfig& config) { + printRule(); + std::cout << "PLACEMENT CHALLENGE TEST SUITE\n"; + printRule(); + std::cout << "\nRunning " << placement::activeBenchmarkCases().size() + << " active test cases serially.\n"; + printTrainingConfig(config); + std::cout << "\n"; + + std::optional loss_tracking_db_path; + if (config.track_loss_history) { + loss_tracking_db_path = createLossTrackingDb(); + std::cout << "Writing loss history to: " + << loss_tracking_db_path->string() << "\n\n"; + } else { + std::cout << "Loss history tracking disabled.\n\n"; + } + + int case_index = 1; + for (const placement::BenchmarkCase& test_case : + placement::activeBenchmarkCases()) { + const char* size_category = + test_case.num_std_cells <= 30 + ? "Small" + : test_case.num_std_cells <= 100 ? "Medium" : "Large"; + std::cout << "Test " << case_index++ << "/" + << placement::activeBenchmarkCases().size() << ": " + << size_category << " (" << test_case.num_macros + << " macros, " << test_case.num_std_cells << " std cells)\n"; + std::cout << " Seed: " << test_case.seed << "\n"; + } + std::cout << "\n"; + + const placement::BenchmarkSummary summary = + placement::runActiveBenchmarkCases(config); + for (const placement::BenchmarkResult& result : summary.results) { + printBenchmarkResult(result); + } + + if (loss_tracking_db_path.has_value()) { + for (const placement::BenchmarkResult& result : summary.results) { + saveLossHistorySqlite( + result.loss_history, + *loss_tracking_db_path, + LossHistoryRunMetadata{ + .test_id = result.test_id, + .runner = "placement.cpp --benchmark", + .run_label = "train_placement", + .run_started_at = result.run_started_at, + .seed = result.seed, + .num_macros = result.num_macros, + .num_std_cells = result.num_std_cells, + .num_epochs = config.num_epochs, + .lr = config.lr, + .lambda_wirelength = config.lambda_wirelength, + .lambda_overlap = config.lambda_overlap, + .log_interval = config.log_interval, + .verbose = config.verbose, + .total_cells = result.total_cells, + .total_pins = result.total_pins, + .total_edges = result.num_nets, + }); + } + std::cout << "Loss history saved to: " + << loss_tracking_db_path->string() << "\n\n"; + } + + printRule(); + std::cout << "FINAL RESULTS\n"; + printRule(); + std::cout << "Average Overlap: " << std::fixed << std::setprecision(4) + << summary.average_overlap << "\n"; + std::cout << "Average Wirelength: " << std::fixed << std::setprecision(4) + << summary.average_wirelength << "\n"; + std::cout << "Total Runtime: " << std::fixed << std::setprecision(2) + << summary.total_elapsed_seconds << "s\n"; + std::cout << "Passed: " << summary.passed_count << "\n"; + std::cout << "Failed: " << summary.failed_count << "\n"; + if (options.write_output_files) { + writeBenchmarkArtifacts(options, summary); + } + return 0; +} + +int runSinglePlacement( + const CliOptions& options, + const placement::TrainingConfig& config) { + placement::BenchmarkCase selected_case{ + 0, + options.num_macros, + options.num_std_cells, + options.seed, + }; + if (options.test_case_id != 0) { + const std::optional test_case = + findBenchmarkCase(options.test_case_id); + if (!test_case.has_value()) { + throw std::invalid_argument( + "Unknown benchmark test case id: " + + std::to_string(options.test_case_id)); + } + selected_case = *test_case; + } + + printRule(); + std::cout << "VLSI CELL PLACEMENT OPTIMIZATION\n"; + printRule(); + std::cout << "\nGenerating placement problem:\n"; + if (selected_case.test_id != 0) { + std::cout << " - benchmark test case: " << selected_case.test_id << "\n"; + } + std::cout << " - " << selected_case.num_macros << " macros\n"; + std::cout << " - " << selected_case.num_std_cells << " standard cells\n"; + std::cout << " - seed: " << selected_case.seed << "\n"; + std::cout << " - device: " << deviceTypeName(config.device) << "\n"; + + seedTorch(selected_case.seed); + const torch::Device device(config.device); + placement::PlacementProblem problem = placement::generatePlacementInput( + selected_case.num_macros, + selected_case.num_std_cells, + device); + placement::initializeCellPositions(problem.cell_features); + + std::cout << "\n"; + printRule(); + std::cout << "INITIAL STATE\n"; + printRule(); + const placement::OverlapMetrics initial_metrics = + placement::calculateOverlapMetrics(problem.cell_features); + std::cout << "Overlap count: " << initial_metrics.overlap_count << "\n"; + std::cout << "Total overlap area: " << std::fixed << std::setprecision(2) + << initial_metrics.total_overlap_area << "\n"; + std::cout << "Max overlap area: " << std::fixed << std::setprecision(2) + << initial_metrics.max_overlap_area << "\n"; + std::cout << "Overlap percentage: " << std::fixed << std::setprecision(2) + << initial_metrics.overlap_percentage << "%\n"; + + std::cout << "\n"; + printRule(); + std::cout << "RUNNING OPTIMIZATION\n"; + printRule(); + std::optional loss_tracking_db_path; + if (config.track_loss_history) { + loss_tracking_db_path = createLossTrackingDb(); + std::cout << "Writing loss history to: " + << loss_tracking_db_path->string() << "\n"; + } else { + std::cout << "Loss history tracking disabled.\n"; + } + + placement::TrainingResult training_result = placement::trainPlacement( + problem.cell_features, + problem.pin_features, + problem.edge_list, + config); + if (loss_tracking_db_path.has_value()) { + const std::filesystem::path saved_path = saveLossHistorySqlite( + training_result.loss_history, + *loss_tracking_db_path, + LossHistoryRunMetadata{ + .test_id = selected_case.test_id == 0 + ? std::optional() + : std::optional(selected_case.test_id), + .runner = "placement.cpp", + .run_label = "train_placement", + .run_started_at = training_result.run_started_at, + .seed = selected_case.seed, + .num_macros = selected_case.num_macros, + .num_std_cells = selected_case.num_std_cells, + .num_epochs = config.num_epochs, + .lr = config.lr, + .lambda_wirelength = config.lambda_wirelength, + .lambda_overlap = config.lambda_overlap, + .log_interval = config.log_interval, + .verbose = config.verbose, + .total_cells = problem.cell_features.size(0), + .total_pins = problem.pin_features.size(0), + .total_edges = problem.edge_list.size(0), + }); + std::cout << "Loss history saved to: " << saved_path.string() << "\n"; + } + + std::cout << "\n"; + printRule(); + std::cout << "FINAL RESULTS\n"; + printRule(); + const placement::OverlapMetrics final_overlap_metrics = + placement::calculateOverlapMetrics(training_result.final_cell_features); + std::cout << "Overlap count (pairs): " + << final_overlap_metrics.overlap_count << "\n"; + std::cout << "Total overlap area: " << std::fixed << std::setprecision(2) + << final_overlap_metrics.total_overlap_area << "\n"; + std::cout << "Max overlap area: " << std::fixed << std::setprecision(2) + << final_overlap_metrics.max_overlap_area << "\n"; + + std::cout << "\n"; + printRule('-'); + std::cout << "TEST SUITE METRICS\n"; + printRule('-'); + const placement::Metrics normalized_metrics = + placement::calculateNormalizedMetrics( + training_result.final_cell_features, + problem.pin_features, + problem.edge_list); + std::cout << "Overlap Ratio: " << std::fixed << std::setprecision(4) + << normalized_metrics.overlap_ratio << " (" + << normalized_metrics.num_cells_with_overlaps << "/" + << normalized_metrics.total_cells << " cells)\n"; + std::cout << "Normalized Wirelength: " << std::fixed << std::setprecision(4) + << normalized_metrics.normalized_wl << "\n"; + std::cout << "Epochs Completed: " << training_result.epochs_completed << "\n"; + if (training_result.stopped_early) { + std::cout << "Stopped Early: " << training_result.stop_reason + << " at best epoch " << training_result.best_epoch << "\n"; + } + + std::cout << "\n"; + printRule(); + std::cout << "SUCCESS CRITERIA\n"; + printRule(); + const bool passed = normalized_metrics.num_cells_with_overlaps == 0; + if (passed) { + std::cout << "PASS: No overlapping cells.\n"; + } else { + std::cout << "FAIL: Overlaps remain in " + << normalized_metrics.num_cells_with_overlaps << " cells.\n"; + } + + if (options.write_output_files) { + writeSinglePlacementArtifacts( + options, + selected_case, + config, + initial_metrics, + final_overlap_metrics, + normalized_metrics, + training_result, + passed); + } + + return 0; +} + +void configureCli( + CLI::App& app, + CliOptions& options, + placement::TrainingConfig& config) { + app.add_flag( + "--benchmark", + options.run_benchmark, + "Run the active benchmark suite instead of a single placement."); + app.add_option( + "--device", + options.device, + "Device to run on: auto, cpu, cuda, or mps.") + ->check(CLI::IsMember({"auto", "cpu", "cuda", "mps"})); + app.add_option( + "--test-case-id", + options.test_case_id, + "Optional benchmark test case id for a single placement run."); + app.add_option( + "--num-macros", + options.num_macros, + "Number of macro cells for a single placement run."); + app.add_option( + "--num-std-cells", + options.num_std_cells, + "Number of standard cells for a single placement run."); + app.add_option("--seed", options.seed, "Random seed for a single placement run."); + app.add_flag( + "--write-output-files", + options.write_output_files, + "Write notebook-friendly CSV and JSON output artifacts."); + app.add_option( + "--output-dir", + options.output_dir, + "Directory for output artifacts when --write-output-files is set."); + + app.add_option( + "--num-epochs", + config.num_epochs, + "Number of optimization epochs."); + app.add_option("--lr", config.lr, "Learning rate for Adam."); + app.add_option( + "--lambda-wirelength", + config.lambda_wirelength, + "Weight applied to the wirelength loss."); + app.add_option( + "--lambda-overlap", + config.lambda_overlap, + "Weight applied to the overlap loss."); + app.add_option("--scheduler", config.scheduler_name, "Learning-rate scheduler.") + ->check(CLI::IsMember( + {"plateau", "cosine", "step", "exponential", "none"})); + app.add_option( + "--scheduler-patience", + config.scheduler_patience, + "Patience for ReduceLROnPlateau."); + app.add_option( + "--scheduler-factor", + config.scheduler_factor, + "Decay factor for ReduceLROnPlateau."); + app.add_option( + "--scheduler-eta-min", + config.scheduler_eta_min, + "Minimum learning rate for cosine annealing."); + app.add_option( + "--scheduler-step-size", + config.scheduler_step_size, + "Step size in epochs for StepLR."); + app.add_option( + "--scheduler-gamma", + config.scheduler_gamma, + "Gamma decay for step and exponential schedulers."); + app.add_flag( + "--track-loss-history", + [&config](int64_t count) { + if (count > 0) { + config.track_loss_history = true; + } + }, + "Collect and persist per-epoch loss history to SQLite."); + app.add_flag( + "--no-track-loss-history", + [&config](int64_t count) { + if (count > 0) { + config.track_loss_history = false; + } + }, + "Disable per-epoch loss-history persistence."); + app.add_flag( + "--track-overlap-metrics", + [&config](int64_t count) { + if (count > 0) { + config.track_overlap_metrics = true; + } + }, + "Compute overlap metrics every epoch."); + app.add_flag( + "--no-track-overlap-metrics", + [&config](int64_t count) { + if (count > 0) { + config.track_overlap_metrics = false; + } + }, + "Disable per-epoch overlap-metric tracking."); + app.add_flag( + "--no-early-stop", + [&config](int64_t count) { + if (count > 0) { + config.early_stop_enabled = false; + } + }, + "Disable overlap-first early stopping."); + app.add_option( + "--early-stop-patience", + config.early_stop_patience, + "Patience before stopping when overlap stops improving."); + app.add_option( + "--early-stop-min-delta", + config.early_stop_min_delta, + "Minimum improvement required to reset early-stop patience."); + app.add_option( + "--early-stop-overlap-threshold", + config.early_stop_overlap_threshold, + "Overlap threshold treated as effectively zero."); + app.add_option( + "--early-stop-zero-overlap-patience", + config.early_stop_zero_overlap_patience, + "Extra patience after zero overlap is reached."); + app.add_flag("--quiet", [&config](int64_t count) { + if (count > 0) { + config.verbose = false; + } + }, "Suppress per-epoch output for a single placement run."); + app.add_option( + "--log-interval", + config.log_interval, + "Epoch interval for verbose training logs."); +} + +void validateOptions( + const CliOptions& options, + const placement::TrainingConfig& config) { + if (options.num_macros < 0 || options.num_std_cells < 0) { + throw std::invalid_argument("Cell counts must be nonnegative"); + } + if (options.num_macros + options.num_std_cells < 0) { + throw std::invalid_argument("Cell counts overflowed"); + } + if (config.num_epochs < 0) { + throw std::invalid_argument("Number of epochs must be nonnegative"); + } + if (config.lr <= 0.0) { + throw std::invalid_argument("Learning rate must be positive"); + } + if (config.scheduler_patience < 0) { + throw std::invalid_argument("Scheduler patience must be nonnegative"); + } + if (config.scheduler_factor <= 0.0) { + throw std::invalid_argument("Scheduler factor must be positive"); + } + if (config.scheduler_step_size <= 0) { + throw std::invalid_argument("Scheduler step size must be positive"); + } + if (config.early_stop_patience <= 0 || + config.early_stop_zero_overlap_patience <= 0) { + throw std::invalid_argument("Early-stop patience values must be positive"); + } +} + +} // namespace + +int main(int argc, char** argv) { + CliOptions options; + placement::TrainingConfig config; + config.log_interval = 200; + + CLI::App app{"Placement C++ runner"}; + configureCli(app, options, config); + CLI11_PARSE(app, argc, argv); + + try { + validateOptions(options, config); + config.device = resolveDeviceType(options.device); + + if (options.run_benchmark) { + config.verbose = false; + return runBenchmark(options, config); + } + return runSinglePlacement(options, config); + } catch (const c10::Error& error) { + std::cerr << "LibTorch error: " << error.what_without_backtrace() << "\n"; + } catch (const std::exception& error) { + std::cerr << "Error: " << error.what() << "\n"; + } + return 1; +} diff --git a/cpp/sqlite_utils.cpp b/cpp/sqlite_utils.cpp new file mode 100644 index 0000000..f498929 --- /dev/null +++ b/cpp/sqlite_utils.cpp @@ -0,0 +1,534 @@ +#include "placement/sqlite_utils.hpp" + +#include "placement/types.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace placement { + +std::string sqliteError(sqlite3* db) { + const char* message = db == nullptr ? nullptr : sqlite3_errmsg(db); + return message == nullptr ? "unknown sqlite error" : std::string(message); +} + +[[noreturn]] void throwSqliteError(sqlite3* db, std::string_view context) { + throw std::runtime_error(std::string(context) + ": " + sqliteError(db)); +} + +void checkSqliteResult( + sqlite3* db, + int result_code, + std::string_view context) { + if (result_code != SQLITE_OK) { + throwSqliteError(db, context); + } +} + +void executeSql(sqlite3* db, std::string_view sql, std::string_view context) { + char* error_message = nullptr; + const std::string sql_text(sql); + const int result_code = + sqlite3_exec(db, sql_text.c_str(), nullptr, nullptr, &error_message); + if (result_code != SQLITE_OK) { + const std::string message = + error_message == nullptr ? sqliteError(db) : std::string(error_message); + sqlite3_free(error_message); + throw std::runtime_error(std::string(context) + ": " + message); + } +} + +SqliteConnection::SqliteConnection(const std::filesystem::path& db_path) { + sqlite3* opened_db = nullptr; + const int result_code = sqlite3_open(db_path.string().c_str(), &opened_db); + db_ = opened_db; + if (result_code != SQLITE_OK) { + const std::string message = sqliteError(db_); + if (db_ != nullptr) { + sqlite3_close(db_); + db_ = nullptr; + } + throw std::runtime_error( + "Unable to open SQLite database " + db_path.string() + ": " + + message); + } + executeSql(db_, "PRAGMA foreign_keys = ON", "Enable SQLite foreign keys"); + checkSqliteResult( + db_, + sqlite3_busy_timeout(db_, 30000), + "Set SQLite busy timeout"); + executeSql( + db_, + "PRAGMA journal_mode = WAL", + "Enable SQLite WAL journal mode"); +} + +SqliteConnection::~SqliteConnection() { + if (db_ != nullptr) { + sqlite3_close(db_); + } +} + +sqlite3* SqliteConnection::get() const { + return db_; +} + +SqliteStatement::SqliteStatement(sqlite3* db, std::string_view sql) : db_(db) { + const std::string sql_text(sql); + const int result_code = + sqlite3_prepare_v2(db_, sql_text.c_str(), -1, &stmt_, nullptr); + checkSqliteResult(db_, result_code, "Prepare SQLite statement"); +} + +SqliteStatement::~SqliteStatement() { + if (stmt_ != nullptr) { + sqlite3_finalize(stmt_); + } +} + +sqlite3_stmt* SqliteStatement::get() const { + return stmt_; +} + +bool SqliteStatement::stepRow() { + const int result_code = sqlite3_step(stmt_); + if (result_code == SQLITE_ROW) { + return true; + } + if (result_code == SQLITE_DONE) { + return false; + } + throwSqliteError(db_, "Step SQLite row statement"); +} + +void SqliteStatement::stepDone() { + const int result_code = sqlite3_step(stmt_); + if (result_code != SQLITE_DONE) { + throwSqliteError(db_, "Step SQLite write statement"); + } +} + +void SqliteStatement::reset() { + checkSqliteResult(db_, sqlite3_reset(stmt_), "Reset SQLite statement"); + checkSqliteResult( + db_, + sqlite3_clear_bindings(stmt_), + "Clear SQLite statement bindings"); +} + +void bindNull(sqlite3_stmt* stmt, int index) { + checkSqliteResult( + sqlite3_db_handle(stmt), + sqlite3_bind_null(stmt, index), + "Bind SQLite null"); +} + +void bindText(sqlite3_stmt* stmt, int index, std::string_view value) { + const std::string value_text(value); + checkSqliteResult( + sqlite3_db_handle(stmt), + sqlite3_bind_text( + stmt, + index, + value_text.c_str(), + -1, + SQLITE_TRANSIENT), + "Bind SQLite text"); +} + +void bindInt64(sqlite3_stmt* stmt, int index, int64_t value) { + checkSqliteResult( + sqlite3_db_handle(stmt), + sqlite3_bind_int64(stmt, index, static_cast(value)), + "Bind SQLite integer"); +} + +void bindBool(sqlite3_stmt* stmt, int index, bool value) { + bindInt64(stmt, index, value ? 1 : 0); +} + +void bindDouble(sqlite3_stmt* stmt, int index, double value) { + if (!std::isfinite(value)) { + bindNull(stmt, index); + return; + } + checkSqliteResult( + sqlite3_db_handle(stmt), + sqlite3_bind_double(stmt, index, value), + "Bind SQLite double"); +} + +void bindOptionalInt64( + sqlite3_stmt* stmt, + int index, + const std::optional& value) { + if (value.has_value()) { + bindInt64(stmt, index, *value); + } else { + bindNull(stmt, index); + } +} + +void ensureColumns( + sqlite3* db, + std::string_view table_name, + const std::vector>& columns) { + std::vector existing_columns; + SqliteStatement statement( + db, + "PRAGMA table_info(" + std::string(table_name) + ")"); + while (statement.stepRow()) { + const unsigned char* column_text = + sqlite3_column_text(statement.get(), 1); + if (column_text != nullptr) { + existing_columns.emplace_back( + reinterpret_cast(column_text)); + } + } + + for (const auto& [column_name, column_type] : columns) { + if (std::find( + existing_columns.begin(), + existing_columns.end(), + column_name) == existing_columns.end()) { + executeSql( + db, + "ALTER TABLE " + std::string(table_name) + " ADD COLUMN " + + column_name + " " + column_type, + "Add SQLite schema column"); + } + } +} + +namespace { + +std::tm localTime(std::time_t time) { + std::tm local_time{}; +#if defined(_WIN32) + localtime_s(&local_time, &time); +#else + localtime_r(&time, &local_time); +#endif + return local_time; +} + +std::string compactTimestamp(std::chrono::system_clock::time_point timestamp) { + const std::time_t now_time = + std::chrono::system_clock::to_time_t(timestamp); + const std::tm local_time = localTime(now_time); + const auto micros = std::chrono::duration_cast( + timestamp.time_since_epoch()) % + std::chrono::seconds(1); + + std::ostringstream output; + output << std::put_time(&local_time, "%Y%m%d_%H%M%S_") + << std::setw(6) << std::setfill('0') << micros.count(); + return output.str(); +} + +std::string isoTimestampSeconds( + std::chrono::system_clock::time_point timestamp) { + const std::time_t now_time = + std::chrono::system_clock::to_time_t(timestamp); + const std::tm local_time = localTime(now_time); + + std::ostringstream output; + output << std::put_time(&local_time, "%Y-%m-%dT%H:%M:%S"); + return output.str(); +} + +std::filesystem::path repoRootPath() { +#if defined(PLACEMENT_REPO_ROOT) + return std::filesystem::path(PLACEMENT_REPO_ROOT).lexically_normal(); +#else + return std::filesystem::path(__FILE__).parent_path().parent_path(); +#endif +} + +std::filesystem::path lossTrackingDbDir() { + return repoRootPath() / "loss_tracking"; +} + +std::mutex& lossTrackingMutex() { + static std::mutex mutex; + return mutex; +} + +void bindLossDouble( + sqlite3_stmt* stmt, + int index, + const std::vector& values, + std::size_t epoch) { + if (epoch < values.size()) { + bindDouble(stmt, index, values[epoch]); + } else { + bindNull(stmt, index); + } +} + +void bindLossInt( + sqlite3_stmt* stmt, + int index, + const std::vector& values, + std::size_t epoch) { + if (epoch < values.size()) { + bindInt64(stmt, index, values[epoch]); + } else { + bindNull(stmt, index); + } +} + +void initializeLossTrackingSchema(sqlite3* db) { + executeSql( + db, + R"sql( + CREATE TABLE IF NOT EXISTS test_cases ( + test_id INTEGER PRIMARY KEY, + num_macros INTEGER, + num_std_cells INTEGER, + seed INTEGER, + updated_at TEXT NOT NULL + ); + + CREATE TABLE IF NOT EXISTS runs ( + run_id TEXT PRIMARY KEY, + test_id INTEGER REFERENCES test_cases(test_id) ON DELETE SET NULL, + runner TEXT, + run_label TEXT, + run_started_at TEXT, + saved_at TEXT NOT NULL, + seed INTEGER, + num_macros INTEGER, + num_std_cells INTEGER, + num_epochs INTEGER, + lr REAL, + lambda_wirelength REAL, + lambda_overlap REAL, + log_interval INTEGER, + verbose INTEGER, + total_cells INTEGER, + total_pins INTEGER, + total_edges INTEGER + ); + + CREATE TABLE IF NOT EXISTS loss_history ( + run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE, + epoch INTEGER NOT NULL, + total_loss REAL, + wirelength_loss REAL, + overlap_loss REAL, + learning_rate REAL, + overlap_count INTEGER, + total_overlap_area REAL, + max_overlap_area REAL, + PRIMARY KEY (run_id, epoch) + ); + )sql", + "Initialize loss-tracking schema"); + + ensureColumns( + db, + "runs", + { + {"seed", "INTEGER"}, + {"num_macros", "INTEGER"}, + {"num_std_cells", "INTEGER"}, + }); + ensureColumns( + db, + "loss_history", + { + {"learning_rate", "REAL"}, + {"overlap_count", "INTEGER"}, + {"total_overlap_area", "REAL"}, + {"max_overlap_area", "REAL"}, + }); +} + +std::size_t lossHistoryRowCount(const LossHistory& history) { + return std::max( + {history.total_loss.size(), + history.wirelength_loss.size(), + history.overlap_loss.size(), + history.learning_rate.size(), + history.overlap_count.size(), + history.total_overlap_area.size(), + history.max_overlap_area.size()}); +} + +} // namespace + +std::filesystem::path createLossTrackingDb() { + const std::filesystem::path db_dir = lossTrackingDbDir(); + std::filesystem::create_directories(db_dir); + const auto now = std::chrono::system_clock::now(); + const std::filesystem::path db_path = + db_dir / ("loss_tracking_" + compactTimestamp(now) + ".sqlite3"); + + SqliteConnection connection(db_path); + initializeLossTrackingSchema(connection.get()); + return db_path; +} + +std::filesystem::path saveLossHistorySqlite( + const LossHistory& history, + const std::filesystem::path& db_path, + const LossHistoryRunMetadata& metadata) { + std::lock_guard lock(lossTrackingMutex()); + std::filesystem::create_directories(db_path.parent_path()); + + const auto now = std::chrono::system_clock::now(); + const std::string saved_at = isoTimestampSeconds(now); + const std::string run_id = compactTimestamp(now); + const std::string run_started_at = + metadata.run_started_at.empty() ? saved_at : metadata.run_started_at; + + SqliteConnection connection(db_path); + sqlite3* db = connection.get(); + initializeLossTrackingSchema(db); + + executeSql(db, "BEGIN IMMEDIATE", "Begin loss-history transaction"); + try { + if (metadata.test_id.has_value()) { + SqliteStatement test_case_statement( + db, + R"sql( + INSERT INTO test_cases ( + test_id, + num_macros, + num_std_cells, + seed, + updated_at + ) + VALUES (?, ?, ?, ?, ?) + ON CONFLICT(test_id) DO UPDATE SET + num_macros = excluded.num_macros, + num_std_cells = excluded.num_std_cells, + seed = excluded.seed, + updated_at = excluded.updated_at + )sql"); + bindInt64(test_case_statement.get(), 1, *metadata.test_id); + bindInt64(test_case_statement.get(), 2, metadata.num_macros); + bindInt64(test_case_statement.get(), 3, metadata.num_std_cells); + bindInt64(test_case_statement.get(), 4, metadata.seed); + bindText(test_case_statement.get(), 5, saved_at); + test_case_statement.stepDone(); + } + + SqliteStatement run_statement( + db, + R"sql( + INSERT OR REPLACE INTO runs ( + run_id, + test_id, + runner, + run_label, + run_started_at, + saved_at, + seed, + num_macros, + num_std_cells, + num_epochs, + lr, + lambda_wirelength, + lambda_overlap, + log_interval, + verbose, + total_cells, + total_pins, + total_edges + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + )sql"); + bindText(run_statement.get(), 1, run_id); + bindOptionalInt64( + run_statement.get(), + 2, + metadata.test_id.has_value() + ? std::optional(*metadata.test_id) + : std::nullopt); + bindText(run_statement.get(), 3, metadata.runner); + bindText(run_statement.get(), 4, metadata.run_label); + bindText(run_statement.get(), 5, run_started_at); + bindText(run_statement.get(), 6, saved_at); + bindInt64(run_statement.get(), 7, metadata.seed); + bindInt64(run_statement.get(), 8, metadata.num_macros); + bindInt64(run_statement.get(), 9, metadata.num_std_cells); + bindInt64(run_statement.get(), 10, metadata.num_epochs); + bindDouble(run_statement.get(), 11, metadata.lr); + bindDouble(run_statement.get(), 12, metadata.lambda_wirelength); + bindDouble(run_statement.get(), 13, metadata.lambda_overlap); + bindInt64(run_statement.get(), 14, metadata.log_interval); + bindBool(run_statement.get(), 15, metadata.verbose); + bindInt64(run_statement.get(), 16, metadata.total_cells); + bindInt64(run_statement.get(), 17, metadata.total_pins); + bindInt64(run_statement.get(), 18, metadata.total_edges); + run_statement.stepDone(); + + SqliteStatement delete_statement( + db, + "DELETE FROM loss_history WHERE run_id = ?"); + bindText(delete_statement.get(), 1, run_id); + delete_statement.stepDone(); + + SqliteStatement history_statement( + db, + R"sql( + INSERT INTO loss_history ( + run_id, + epoch, + total_loss, + wirelength_loss, + overlap_loss, + learning_rate, + overlap_count, + total_overlap_area, + max_overlap_area + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + )sql"); + const std::size_t row_count = lossHistoryRowCount(history); + for (std::size_t epoch = 0; epoch < row_count; ++epoch) { + history_statement.reset(); + bindText(history_statement.get(), 1, run_id); + bindInt64(history_statement.get(), 2, static_cast(epoch)); + bindLossDouble(history_statement.get(), 3, history.total_loss, epoch); + bindLossDouble( + history_statement.get(), + 4, + history.wirelength_loss, + epoch); + bindLossDouble(history_statement.get(), 5, history.overlap_loss, epoch); + bindLossDouble(history_statement.get(), 6, history.learning_rate, epoch); + bindLossInt(history_statement.get(), 7, history.overlap_count, epoch); + bindLossDouble( + history_statement.get(), + 8, + history.total_overlap_area, + epoch); + bindLossDouble( + history_statement.get(), + 9, + history.max_overlap_area, + epoch); + history_statement.stepDone(); + } + + executeSql(db, "COMMIT", "Commit loss-history transaction"); + } catch (...) { + executeSql(db, "ROLLBACK", "Rollback loss-history transaction"); + throw; + } + + return db_path; +} + +} // namespace placement diff --git a/cpp/test.cpp b/cpp/test.cpp new file mode 100644 index 0000000..9e80805 --- /dev/null +++ b/cpp/test.cpp @@ -0,0 +1,298 @@ +#include "placement/benchmark.h" +#include "placement/types.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace { + +struct TestOptions { + std::string device = "auto"; + int workers = 1; +}; + +std::string deviceTypeName(c10::DeviceType device) { + switch (device) { + case c10::DeviceType::CPU: + return "cpu"; + case c10::DeviceType::CUDA: + return "cuda"; + case c10::DeviceType::MPS: + return "mps"; + default: + return "unknown"; + } +} + +c10::DeviceType resolveDeviceType(const std::string& device) { + if (device == "auto") { + if (torch::cuda::is_available()) { + return torch::kCUDA; + } + if (torch::mps::is_available()) { + return torch::kMPS; + } + return torch::kCPU; + } + if (device == "cpu") { + return torch::kCPU; + } + if (device == "cuda") { + if (!torch::cuda::is_available()) { + throw std::invalid_argument("CUDA device requested but unavailable"); + } + return torch::kCUDA; + } + if (device == "mps") { + if (!torch::mps::is_available()) { + throw std::invalid_argument("MPS device requested but unavailable"); + } + return torch::kMPS; + } + throw std::invalid_argument("Unsupported device: " + device); +} + +void printRule() { + std::cout << std::string(70, '=') << "\n"; +} + +void printTrainingConfig(const placement::TrainingConfig& config, int workers) { + std::cout << "Using hyperparameters:\n"; + std::cout << " num_epochs: " << config.num_epochs << "\n"; + std::cout << " lr: " << config.lr << "\n"; + std::cout << " lambda_wirelength: " << config.lambda_wirelength << "\n"; + std::cout << " lambda_overlap: " << config.lambda_overlap << "\n"; + std::cout << " scheduler: " << config.scheduler_name << "\n"; + std::cout << " scheduler_patience: " << config.scheduler_patience << "\n"; + std::cout << " scheduler_factor: " << config.scheduler_factor << "\n"; + std::cout << " scheduler_eta_min: " << config.scheduler_eta_min << "\n"; + std::cout << " scheduler_step_size: " << config.scheduler_step_size << "\n"; + std::cout << " scheduler_gamma: " << config.scheduler_gamma << "\n"; + std::cout << " track_overlap_metrics: " + << (config.track_overlap_metrics ? "true" : "false") << "\n"; + std::cout << " early_stop_enabled: " + << (config.early_stop_enabled ? "true" : "false") << "\n"; + std::cout << " early_stop_patience: " << config.early_stop_patience << "\n"; + std::cout << " early_stop_min_delta: " << config.early_stop_min_delta << "\n"; + std::cout << " early_stop_overlap_threshold: " + << config.early_stop_overlap_threshold << "\n"; + std::cout << " early_stop_zero_overlap_patience: " + << config.early_stop_zero_overlap_patience << "\n"; + std::cout << " workers: " << workers << "\n"; +} + +const char* sizeCategory(const placement::BenchmarkCase& test_case) { + if (test_case.num_std_cells <= 30) { + return "Small"; + } + if (test_case.num_std_cells <= 100) { + return "Medium"; + } + return "Large"; +} + +void printCaseList() { + int case_index = 1; + const std::vector& cases = + placement::activeBenchmarkCases(); + for (const placement::BenchmarkCase& test_case : cases) { + std::cout << "Test " << case_index++ << "/" << cases.size() << ": " + << sizeCategory(test_case) << " (" << test_case.num_macros + << " macros, " << test_case.num_std_cells << " std cells)\n"; + std::cout << " Seed: " << test_case.seed << "\n"; + } +} + +void printBenchmarkResult(const placement::BenchmarkResult& result) { + const char* status = result.passed ? "PASS" : "FAIL"; + std::cout << "Completed test " << result.test_id << ":\n"; + std::cout << " Device: " << deviceTypeName(result.device) << "\n"; + std::cout << " Overlap Ratio: " << std::fixed << std::setprecision(4) + << result.overlap_ratio << " (" << result.num_cells_with_overlaps + << "/" << result.total_cells << " cells)\n"; + std::cout << " Normalized WL: " << std::fixed << std::setprecision(4) + << result.normalized_wl << "\n"; + std::cout << " Epochs Completed: " << result.epochs_completed << "\n"; + if (result.stopped_early) { + std::cout << " Stopped Early: " << result.stop_reason + << " at best epoch " << result.best_epoch << "\n"; + } + std::cout << " Time: " << std::fixed << std::setprecision(2) + << result.elapsed_seconds << "s\n"; + std::cout << " Status: " << status << "\n\n"; +} + +void configureCli( + CLI::App& app, + TestOptions& options, + placement::TrainingConfig& config) { + app.add_option( + "--device", + options.device, + "Device to run on: auto, cpu, cuda, or mps.") + ->check(CLI::IsMember({"auto", "cpu", "cuda", "mps"})); + app.add_option( + "--workers", + options.workers, + "Number of worker threads for benchmark cases."); + app.add_option( + "--num-epochs", + config.num_epochs, + "Number of optimization epochs."); + app.add_option("--lr", config.lr, "Learning rate for Adam."); + app.add_option( + "--lambda-wirelength", + config.lambda_wirelength, + "Weight applied to the wirelength loss."); + app.add_option( + "--lambda-overlap", + config.lambda_overlap, + "Weight applied to the overlap loss."); + app.add_option("--scheduler", config.scheduler_name, "Learning-rate scheduler.") + ->check(CLI::IsMember( + {"plateau", "cosine", "step", "exponential", "none"})); + app.add_option( + "--scheduler-patience", + config.scheduler_patience, + "Patience for ReduceLROnPlateau."); + app.add_option( + "--scheduler-factor", + config.scheduler_factor, + "Decay factor for ReduceLROnPlateau."); + app.add_option( + "--scheduler-eta-min", + config.scheduler_eta_min, + "Minimum learning rate for cosine annealing."); + app.add_option( + "--scheduler-step-size", + config.scheduler_step_size, + "Step size in epochs for StepLR."); + app.add_option( + "--scheduler-gamma", + config.scheduler_gamma, + "Gamma decay for step and exponential schedulers."); + app.add_flag( + "--track-overlap-metrics", + config.track_overlap_metrics, + "Compute overlap metrics every epoch."); + app.add_flag( + "--no-early-stop", + [&config](int64_t count) { + if (count > 0) { + config.early_stop_enabled = false; + } + }, + "Disable overlap-first early stopping."); + app.add_option( + "--early-stop-patience", + config.early_stop_patience, + "Patience before stopping when overlap stops improving."); + app.add_option( + "--early-stop-min-delta", + config.early_stop_min_delta, + "Minimum improvement required to reset early-stop patience."); + app.add_option( + "--early-stop-overlap-threshold", + config.early_stop_overlap_threshold, + "Overlap threshold treated as effectively zero."); + app.add_option( + "--early-stop-zero-overlap-patience", + config.early_stop_zero_overlap_patience, + "Extra patience after zero overlap is reached."); +} + +void validateOptions( + const TestOptions& options, + const placement::TrainingConfig& config) { + if (options.workers <= 0) { + throw std::invalid_argument("Worker count must be positive"); + } + if (config.num_epochs < 0) { + throw std::invalid_argument("Number of epochs must be nonnegative"); + } + if (config.lr <= 0.0) { + throw std::invalid_argument("Learning rate must be positive"); + } + if (config.scheduler_patience < 0) { + throw std::invalid_argument("Scheduler patience must be nonnegative"); + } + if (config.scheduler_factor <= 0.0) { + throw std::invalid_argument("Scheduler factor must be positive"); + } + if (config.scheduler_step_size <= 0) { + throw std::invalid_argument("Scheduler step size must be positive"); + } + if (config.early_stop_patience <= 0 || + config.early_stop_zero_overlap_patience <= 0) { + throw std::invalid_argument("Early-stop patience values must be positive"); + } +} + +int runTestSuite( + const TestOptions& options, + const placement::TrainingConfig& config, + const char* binary_path) { + printRule(); + std::cout << "PLACEMENT CHALLENGE TEST SUITE\n"; + printRule(); + std::cout << "\nBinary: " << std::filesystem::absolute(binary_path).string() + << "\n"; + std::cout << "\nRunning " << placement::activeBenchmarkCases().size() + << " test cases with various netlist sizes...\n"; + printTrainingConfig(config, options.workers); + std::cout << "\nLoss history tracking disabled.\n\n"; + printCaseList(); + if (options.workers == 1) { + std::cout << "Running serially\n\n"; + } else { + std::cout << "Running with " << options.workers << " workers\n\n"; + } + + const placement::BenchmarkSummary summary = + placement::runActiveBenchmarkCases(config, options.workers); + for (const placement::BenchmarkResult& result : summary.results) { + printBenchmarkResult(result); + } + + printRule(); + std::cout << "FINAL RESULTS\n"; + printRule(); + std::cout << "Average Overlap: " << std::fixed << std::setprecision(4) + << summary.average_overlap << "\n"; + std::cout << "Average Wirelength: " << std::fixed << std::setprecision(4) + << summary.average_wirelength << "\n"; + std::cout << "Total Runtime: " << std::fixed << std::setprecision(2) + << summary.total_elapsed_seconds << "s\n"; + return 0; +} + +} // namespace + +int main(int argc, char** argv) { + TestOptions options; + placement::TrainingConfig config; + config.verbose = false; + + CLI::App app{"Placement C++ test suite runner"}; + configureCli(app, options, config); + CLI11_PARSE(app, argc, argv); + + try { + validateOptions(options, config); + config.device = resolveDeviceType(options.device); + return runTestSuite(options, config, argv[0]); + } catch (const c10::Error& error) { + std::cerr << "LibTorch error: " << error.what_without_backtrace() << "\n"; + } catch (const std::exception& error) { + std::cerr << "Error: " << error.what() << "\n"; + } + return 1; +} diff --git a/cpp/tests/metrics_tests.cpp b/cpp/tests/metrics_tests.cpp new file mode 100644 index 0000000..0a6fab3 --- /dev/null +++ b/cpp/tests/metrics_tests.cpp @@ -0,0 +1,578 @@ +#include "placement/benchmark.h" +#include "placement/generation.h" +#include "placement/losses.h" +#include "placement/metrics.h" +#include "placement/training.h" + +#include + +#include +#include +#include +#include +#include + +void visualizationWritesPngWithExpectedContent(); + +namespace { + +void expect(bool condition, const std::string& message) { + if (!condition) { + throw std::runtime_error(message); + } +} + +void expectNear( + double actual, + double expected, + double tolerance, + const std::string& message) { + if (std::abs(actual - expected) > tolerance) { + throw std::runtime_error( + message + ": actual=" + std::to_string(actual) + + " expected=" + std::to_string(expected)); + } +} + +placement::TrainingConfig fastBenchmarkConfig() { + placement::TrainingConfig config; + config.device = torch::kCPU; + config.num_epochs = 0; + config.scheduler_name = "none"; + config.early_stop_enabled = false; + config.verbose = false; + return config; +} + +void deterministicMetricsMatchPythonReference() { + const auto float_options = torch::TensorOptions().dtype(torch::kFloat32); + const auto long_options = torch::TensorOptions().dtype(torch::kInt64); + + const auto cell_features = torch::tensor( + { + {4.0F, 1.0F, 0.0F, 0.0F, 2.0F, 2.0F}, + {4.0F, 1.0F, 1.0F, 0.0F, 2.0F, 2.0F}, + {1.0F, 1.0F, 10.0F, 10.0F, 1.0F, 1.0F}, + }, + float_options); + const auto pin_features = torch::tensor( + { + {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + {1.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + {2.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + }, + float_options); + const auto edge_list = torch::tensor({{0LL, 2LL}}, long_options); + + const placement::OverlapMetrics overlap = + placement::calculateOverlapMetrics(cell_features); + expect(overlap.overlap_count == 1, "expected one overlapping pair"); + expectNear(overlap.total_overlap_area, 2.0, 1e-5, "total overlap area"); + expectNear(overlap.max_overlap_area, 2.0, 1e-5, "max overlap area"); + expectNear(overlap.overlap_percentage, 100.0 / 3.0, 1e-5, "overlap percentage"); + expect(overlap.cells_with_overlap == 2, "expected two cells with overlap"); + expect(!overlap.has_zero_overlap, "expected nonzero overlap flag"); + + const placement::Metrics metrics = + placement::calculateNormalizedMetrics(cell_features, pin_features, edge_list); + expect(metrics.total_cells == 3, "expected three total cells"); + expect(metrics.num_nets == 1, "expected one net"); + expect(metrics.num_cells_with_overlaps == 2, "expected two overlapping cells"); + expectNear(metrics.overlap_ratio, 2.0 / 3.0, 1e-6, "overlap ratio"); + + const double smooth_wirelength = 10.0 + 0.1 * std::log(2.0); + expectNear( + metrics.normalized_wl, + smooth_wirelength / 3.0, + 1e-5, + "normalized wirelength"); + + const auto no_edges = torch::zeros({0, 2}, long_options); + const placement::Metrics no_edge_metrics = + placement::calculateNormalizedMetrics(cell_features, pin_features, no_edges); + expectNear(no_edge_metrics.normalized_wl, 0.0, 1e-12, "zero-edge wirelength"); +} + +void generatedProblemCanBeMeasured() { + torch::manual_seed(66); + placement::PlacementProblem problem = + placement::generatePlacementInput(2, 5, torch::kCPU, false); + + expect(problem.cell_features.size(0) == 7, "generated cell count"); + expect(problem.cell_features.size(1) == 6, "generated cell feature width"); + expect(problem.pin_features.size(1) == 7, "generated pin feature width"); + expect(problem.edge_list.size(1) == 2, "generated edge width"); + + placement::initializeCellPositions(problem.cell_features); + const placement::Metrics metrics = placement::calculateNormalizedMetrics( + problem.cell_features, + problem.pin_features, + problem.edge_list); + + expect(metrics.total_cells == 7, "metrics total cell count"); + expect(metrics.num_nets == problem.edge_list.size(0), "metrics net count"); + expect( + metrics.num_cells_with_overlaps >= 0 && + metrics.num_cells_with_overlaps <= metrics.total_cells, + "overlapping cell count range"); + expect( + metrics.overlap_ratio >= 0.0 && metrics.overlap_ratio <= 1.0, + "overlap ratio range"); + expect(std::isfinite(metrics.normalized_wl), "finite normalized wirelength"); + expect(metrics.normalized_wl >= 0.0, "nonnegative normalized wirelength"); +} + +void deterministicLossesMatchPythonReference() { + const auto float_options = torch::TensorOptions().dtype(torch::kFloat32); + const auto long_options = torch::TensorOptions().dtype(torch::kInt64); + + const auto cell_features = torch::tensor( + { + {4.0F, 1.0F, 0.0F, 0.0F, 2.0F, 2.0F}, + {4.0F, 1.0F, 1.0F, 0.0F, 2.0F, 2.0F}, + {1.0F, 1.0F, 10.0F, 10.0F, 1.0F, 1.0F}, + }, + float_options); + const auto pin_features = torch::tensor( + { + {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + {1.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + {2.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + }, + float_options); + const auto edge_list = torch::tensor({{0LL, 2LL}}, long_options); + + const auto pairwise_overlap = + placement::computePairwiseOverlapAreas(cell_features); + const auto expected_pairwise_overlap = torch::tensor( + { + {4.0F, 2.0F, 0.0F}, + {2.0F, 4.0F, 0.0F}, + {0.0F, 0.0F, 1.0F}, + }, + float_options); + expect( + torch::allclose(pairwise_overlap, expected_pairwise_overlap), + "pairwise overlap areas"); + + const double smooth_wirelength = 10.0 + 0.1 * std::log(2.0); + expectNear( + placement::wirelengthAttractionLoss(cell_features, pin_features, edge_list) + .item(), + smooth_wirelength, + 1e-5, + "wirelength attraction loss"); + + expectNear( + placement::overlapRepulsionLoss(cell_features, pin_features, edge_list) + .item(), + std::log1p(2.0) * 200.0, + 1e-4, + "overlap repulsion loss"); +} + +void lossEdgeCasesStayFinite() { + const auto float_options = torch::TensorOptions().dtype(torch::kFloat32); + const auto long_options = torch::TensorOptions().dtype(torch::kInt64); + + const auto single_cell = torch::tensor( + {{4.0F, 1.0F, 0.0F, 0.0F, 2.0F, 2.0F}}, + float_options); + const auto single_pin = torch::tensor( + {{0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}}, + float_options); + const auto no_edges = torch::zeros({0, 2}, long_options); + + const auto single_overlap = + placement::computePairwiseOverlapAreas(single_cell); + expect(single_overlap.size(0) == 1, "single-cell overlap row count"); + expect(single_overlap.size(1) == 1, "single-cell overlap column count"); + expectNear( + placement::wirelengthAttractionLoss(single_cell, single_pin, no_edges) + .item(), + 0.0, + 1e-12, + "zero-edge wirelength loss"); + expectNear( + placement::overlapRepulsionLoss(single_cell, single_pin, no_edges) + .item(), + 0.0, + 1e-12, + "single-cell overlap loss"); +} + +void lossesBackpropagateThroughCellPositions() { + const auto float_options = torch::TensorOptions().dtype(torch::kFloat32); + const auto long_options = torch::TensorOptions().dtype(torch::kInt64); + + const auto cell_static_prefix = torch::tensor( + { + {4.0F, 1.0F}, + {4.0F, 1.0F}, + }, + float_options); + auto positions = torch::tensor( + { + {0.0F, 0.0F}, + {1.0F, 0.0F}, + }, + float_options.requires_grad(true)); + const auto cell_static_suffix = torch::tensor( + { + {2.0F, 2.0F}, + {2.0F, 2.0F}, + }, + float_options); + const auto cell_features = + torch::cat({cell_static_prefix, positions, cell_static_suffix}, 1); + const auto pin_features = torch::tensor( + { + {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + {1.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + }, + float_options); + const auto edge_list = torch::tensor({{0LL, 1LL}}, long_options); + + const auto loss = + placement::wirelengthAttractionLoss(cell_features, pin_features, edge_list) + + placement::overlapRepulsionLoss(cell_features, pin_features, edge_list); + loss.backward(); + + expect(positions.grad().defined(), "positions gradient is defined"); + expect(torch::all(torch::isfinite(positions.grad())).item(), "finite gradients"); + expect(positions.grad().abs().sum().item() > 0.0, "nonzero gradients"); +} + +void trainingWithNoEpochsReturnsInitialPlacement() { + const auto float_options = torch::TensorOptions().dtype(torch::kFloat32); + const auto long_options = torch::TensorOptions().dtype(torch::kInt64); + + const auto cell_features = torch::tensor( + { + {1.0F, 1.0F, 0.0F, 0.0F, 1.0F, 1.0F}, + {1.0F, 1.0F, 4.0F, 0.0F, 1.0F, 1.0F}, + }, + float_options); + const auto pin_features = torch::tensor( + { + {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + {1.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + }, + float_options); + const auto edge_list = torch::tensor({{0LL, 1LL}}, long_options); + + placement::TrainingConfig config; + config.num_epochs = 0; + config.verbose = false; + + const placement::TrainingResult result = + placement::trainPlacement(cell_features, pin_features, edge_list, config); + expect( + torch::allclose(result.initial_cell_features, cell_features), + "zero-epoch initial features"); + expect( + torch::allclose(result.final_cell_features, cell_features), + "zero-epoch final features"); + expect(!result.stopped_early, "zero-epoch does not stop early"); + expect(result.best_epoch == -1, "zero-epoch best epoch"); + expect(result.epochs_completed == 0, "zero-epoch epochs completed"); +} + +void trainingReducesOverlapLoss() { + const auto float_options = torch::TensorOptions().dtype(torch::kFloat32); + const auto long_options = torch::TensorOptions().dtype(torch::kInt64); + + const auto cell_features = torch::tensor( + { + {4.0F, 1.0F, 0.0F, 0.0F, 2.0F, 2.0F}, + {4.0F, 1.0F, 1.0F, 0.0F, 2.0F, 2.0F}, + }, + float_options); + const auto pin_features = torch::zeros({0, 7}, float_options); + const auto edge_list = torch::zeros({0, 2}, long_options); + + placement::TrainingConfig config; + config.num_epochs = 40; + config.lr = 0.1; + config.lambda_wirelength = 0.0; + config.lambda_overlap = 1.0; + config.scheduler_name = "none"; + config.early_stop_enabled = false; + config.verbose = false; + + const double initial_overlap = + placement::calculateOverlapMetrics(cell_features).total_overlap_area; + const placement::TrainingResult result = + placement::trainPlacement(cell_features, pin_features, edge_list, config); + const double final_overlap = + placement::calculateOverlapMetrics(result.final_cell_features) + .total_overlap_area; + + expect(final_overlap < initial_overlap, "training reduces overlap area"); + expect( + torch::allclose(result.initial_cell_features, cell_features), + "training preserves initial features"); + expect(!result.stopped_early, "overlap-only training no early stop"); + expect( + result.epochs_completed == config.num_epochs, + "overlap-only training epochs completed"); +} + +void trainingReducesWirelengthLoss() { + const auto float_options = torch::TensorOptions().dtype(torch::kFloat32); + const auto long_options = torch::TensorOptions().dtype(torch::kInt64); + + const auto cell_features = torch::tensor( + { + {1.0F, 1.0F, 0.0F, 0.0F, 1.0F, 1.0F}, + {1.0F, 1.0F, 10.0F, 0.0F, 1.0F, 1.0F}, + }, + float_options); + const auto pin_features = torch::tensor( + { + {0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + {1.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.1F, 0.1F}, + }, + float_options); + const auto edge_list = torch::tensor({{0LL, 1LL}}, long_options); + + placement::TrainingConfig config; + config.num_epochs = 20; + config.lr = 0.1; + config.lambda_wirelength = 1.0; + config.lambda_overlap = 0.0; + config.scheduler_name = "none"; + config.early_stop_enabled = false; + config.verbose = false; + + const double initial_wl = + placement::wirelengthAttractionLoss(cell_features, pin_features, edge_list) + .item(); + const placement::TrainingResult result = + placement::trainPlacement(cell_features, pin_features, edge_list, config); + const double final_wl = placement::wirelengthAttractionLoss( + result.final_cell_features, + pin_features, + edge_list) + .item(); + + expect(final_wl < initial_wl, "training reduces wirelength"); + expect( + result.epochs_completed == config.num_epochs, + "wirelength training epochs completed"); +} + +void trainingReportsEarlyStopMetadata() { + const auto float_options = torch::TensorOptions().dtype(torch::kFloat32); + const auto long_options = torch::TensorOptions().dtype(torch::kInt64); + + const auto cell_features = torch::tensor( + { + {1.0F, 1.0F, 0.0F, 0.0F, 1.0F, 1.0F}, + {1.0F, 1.0F, 4.0F, 0.0F, 1.0F, 1.0F}, + }, + float_options); + const auto pin_features = torch::zeros({0, 7}, float_options); + const auto edge_list = torch::zeros({0, 2}, long_options); + + placement::TrainingConfig config; + config.num_epochs = 5; + config.lr = 0.1; + config.lambda_wirelength = 0.0; + config.lambda_overlap = 1.0; + config.scheduler_name = "none"; + config.early_stop_enabled = true; + config.early_stop_zero_overlap_patience = 1; + config.verbose = false; + + const placement::TrainingResult result = + placement::trainPlacement(cell_features, pin_features, edge_list, config); + + expect(result.stopped_early, "training reports early stop"); + expect( + result.stop_reason == "zero_overlap_plateau", + "training early stop reason"); + expect(result.best_epoch == 0, "training best epoch"); + expect(result.epochs_completed == 2, "early-stop epochs completed"); +} + +void activeBenchmarkCasesMatchPythonReference() { + const std::vector expected = { + {1, 2, 20, 1001}, + {2, 3, 25, 1002}, + {3, 2, 30, 1003}, + {4, 3, 50, 1004}, + {5, 4, 75, 1005}, + {6, 5, 100, 1006}, + {7, 5, 150, 1007}, + {8, 7, 150, 1008}, + {9, 8, 200, 1009}, + {10, 10, 2000, 1010}, + }; + + const std::vector& actual = + placement::activeBenchmarkCases(); + expect(actual.size() == expected.size(), "active benchmark case count"); + + for (std::size_t i = 0; i < expected.size(); ++i) { + expect(actual[i].test_id == expected[i].test_id, "benchmark test id"); + expect(actual[i].num_macros == expected[i].num_macros, "benchmark macros"); + expect( + actual[i].num_std_cells == expected[i].num_std_cells, + "benchmark standard cells"); + expect(actual[i].seed == expected[i].seed, "benchmark seed"); + } +} + +void benchmarkCasePopulatesMetricsAndUsesSeed() { + placement::TrainingConfig config = fastBenchmarkConfig(); + + const placement::BenchmarkCase test_case{42, 1, 4, 4242}; + const placement::BenchmarkResult first = + placement::runBenchmarkCase(test_case, config); + const placement::BenchmarkResult second = + placement::runBenchmarkCase(test_case, config); + + expect(first.test_id == test_case.test_id, "benchmark result test id"); + expect(first.num_macros == test_case.num_macros, "benchmark result macros"); + expect( + first.num_std_cells == test_case.num_std_cells, + "benchmark result standard cells"); + expect(first.seed == test_case.seed, "benchmark result seed"); + expect(first.device == config.device, "benchmark result device"); + expect(first.total_cells == 5, "benchmark result total cells"); + expect(first.num_nets >= 0, "benchmark result net count"); + expect(first.elapsed_seconds >= 0.0, "benchmark result elapsed time"); + expect(first.num_cells_with_overlaps >= 0, "benchmark overlap cell lower bound"); + expect( + first.num_cells_with_overlaps <= first.total_cells, + "benchmark overlap cell upper bound"); + expect( + first.overlap_ratio >= 0.0 && first.overlap_ratio <= 1.0, + "benchmark overlap ratio range"); + expect(std::isfinite(first.normalized_wl), "benchmark finite wirelength"); + expect(first.normalized_wl >= 0.0, "benchmark nonnegative wirelength"); + expect( + first.passed == (first.num_cells_with_overlaps == 0), + "benchmark pass flag"); + expect(first.epochs_completed == config.num_epochs, "benchmark epochs completed"); + expect(first.stopped_early == false, "benchmark early stop flag"); + expect(first.best_epoch == -1, "benchmark best epoch"); + + expect(first.num_nets == second.num_nets, "benchmark seeded net count"); + expectNear( + first.overlap_ratio, + second.overlap_ratio, + 1e-12, + "benchmark seeded overlap ratio"); + expectNear( + first.normalized_wl, + second.normalized_wl, + 1e-12, + "benchmark seeded normalized wirelength"); +} + +void benchmarkSummaryAggregatesOrderedResults() { + placement::TrainingConfig config = fastBenchmarkConfig(); + + const std::vector cases = { + {101, 0, 2, 1101}, + {102, 0, 3, 1102}, + }; + + const placement::BenchmarkSummary summary = + placement::runBenchmarkCases(cases, config); + + expect(summary.results.size() == cases.size(), "benchmark summary result count"); + expect(summary.results[0].test_id == 101, "benchmark summary preserves first id"); + expect(summary.results[1].test_id == 102, "benchmark summary preserves second id"); + + const double expected_average_overlap = + (summary.results[0].overlap_ratio + summary.results[1].overlap_ratio) / + 2.0; + const double expected_average_wirelength = + (summary.results[0].normalized_wl + summary.results[1].normalized_wl) / + 2.0; + expectNear( + summary.average_overlap, + expected_average_overlap, + 1e-12, + "benchmark average overlap"); + expectNear( + summary.average_wirelength, + expected_average_wirelength, + 1e-12, + "benchmark average wirelength"); + + const int expected_passed = + (summary.results[0].passed ? 1 : 0) + (summary.results[1].passed ? 1 : 0); + expect(summary.passed_count == expected_passed, "benchmark passed count"); + expect( + summary.failed_count == + static_cast(summary.results.size()) - expected_passed, + "benchmark failed count"); + expect( + std::isfinite(summary.total_elapsed_seconds) && + summary.total_elapsed_seconds >= 0.0, + "benchmark finite total elapsed time"); + + const placement::BenchmarkSummary parallel_summary = + placement::runBenchmarkCases(cases, config, 2); + expect( + parallel_summary.results.size() == cases.size(), + "parallel benchmark summary result count"); + expect( + parallel_summary.results[0].test_id == summary.results[0].test_id, + "parallel benchmark preserves first id"); + expect( + parallel_summary.results[1].test_id == summary.results[1].test_id, + "parallel benchmark preserves second id"); + expectNear( + parallel_summary.average_overlap, + summary.average_overlap, + 1e-12, + "parallel benchmark average overlap"); + expectNear( + parallel_summary.average_wirelength, + summary.average_wirelength, + 1e-12, + "parallel benchmark average wirelength"); +} + +void emptyBenchmarkSummaryIsZeroed() { + const placement::BenchmarkSummary summary = placement::runBenchmarkCases({}); + + expect(summary.results.empty(), "empty benchmark result list"); + expectNear(summary.average_overlap, 0.0, 1e-12, "empty average overlap"); + expectNear(summary.average_wirelength, 0.0, 1e-12, "empty average wirelength"); + expectNear(summary.total_elapsed_seconds, 0.0, 1e-12, "empty elapsed time"); + expect(summary.passed_count == 0, "empty passed count"); + expect(summary.failed_count == 0, "empty failed count"); +} + +} // namespace + +int main() { + try { + deterministicMetricsMatchPythonReference(); + generatedProblemCanBeMeasured(); + deterministicLossesMatchPythonReference(); + lossEdgeCasesStayFinite(); + lossesBackpropagateThroughCellPositions(); + trainingWithNoEpochsReturnsInitialPlacement(); + trainingReducesOverlapLoss(); + trainingReducesWirelengthLoss(); + trainingReportsEarlyStopMetadata(); + activeBenchmarkCasesMatchPythonReference(); + benchmarkCasePopulatesMetricsAndUsesSeed(); + benchmarkSummaryAggregatesOrderedResults(); + emptyBenchmarkSummaryIsZeroed(); + visualizationWritesPngWithExpectedContent(); + } catch (const std::exception& error) { + std::cerr << "placement_unit_tests failed: " << error.what() << '\n'; + return 1; + } + + std::cout << "placement_unit_tests passed\n"; + return 0; +} diff --git a/cpp/tests/visualization_tests.cpp b/cpp/tests/visualization_tests.cpp new file mode 100644 index 0000000..0f03afc --- /dev/null +++ b/cpp/tests/visualization_tests.cpp @@ -0,0 +1,63 @@ +#include "placement/visualization.h" + +#include + +#include +#include +#include +#include +#include + +namespace { + +void expect(bool condition, const std::string& message) { + if (!condition) { + throw std::runtime_error(message); + } +} + +std::string readFile(const std::filesystem::path& path) { + std::ifstream input(path, std::ios::binary); + if (!input) { + throw std::runtime_error("unable to read visualization output"); + } + + std::ostringstream buffer; + buffer << input.rdbuf(); + return buffer.str(); +} + +} // namespace + +void visualizationWritesPngWithExpectedContent() { + const auto float_options = torch::TensorOptions().dtype(torch::kFloat32); + + const auto initial_cell_features = torch::tensor( + { + {4.0F, 1.0F, 0.0F, 0.0F, 2.0F, 2.0F}, + {4.0F, 1.0F, 1.0F, 0.0F, 2.0F, 2.0F}, + }, + float_options); + const auto final_cell_features = torch::tensor( + { + {4.0F, 1.0F, 0.0F, 0.0F, 2.0F, 2.0F}, + {4.0F, 1.0F, 5.0F, 0.0F, 2.0F, 2.0F}, + }, + float_options); + + const std::filesystem::path output_path = + std::filesystem::temp_directory_path() / "placement_cpp_visualization_tests" / + "nested" / "tiny_placement.png"; + std::filesystem::remove(output_path); + + placement::plotPlacement(initial_cell_features, final_cell_features, output_path); + + expect(std::filesystem::exists(output_path), "visualization output exists"); + expect(std::filesystem::file_size(output_path) > 0, "visualization output is nonempty"); + + const std::string content = readFile(output_path); + expect(content.size() > 8, "visualization output has png header bytes"); + expect( + static_cast(content[0]) == 0x89 && content.substr(1, 3) == "PNG", + "visualization output is a png"); +} diff --git a/cpp/training.cpp b/cpp/training.cpp new file mode 100644 index 0000000..8b8f0b0 --- /dev/null +++ b/cpp/training.cpp @@ -0,0 +1,347 @@ +#include "placement/training.h" + +#include "placement/losses.h" +#include "placement/metrics.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { + +using namespace torch::indexing; + +int64_t featureIndex(placement::CellFeatureIdx idx) { + return static_cast(idx); +} + +torch::Tensor makeCellFeaturesWithPositions( + const torch::Tensor& cell_features, + const torch::Tensor& cell_positions) { + const auto prefix = cell_features.index( + {Slice(), Slice(0, featureIndex(placement::CellFeatureIdx::X))}); + const auto suffix = cell_features.index( + {Slice(), Slice(featureIndex(placement::CellFeatureIdx::Width), None)}); + return torch::cat({prefix, cell_positions, suffix}, 1); +} + +double optimizerLearningRate(torch::optim::Adam& optimizer) { + return static_cast( + optimizer.param_groups().front().options()) + .lr(); +} + +void setOptimizerLearningRate(torch::optim::Adam& optimizer, double lr) { + for (auto& group : optimizer.param_groups()) { + static_cast(group.options()).lr(lr); + } +} + +void clipGradientNorm(const torch::Tensor& tensor, double max_norm) { + if (!tensor.grad().defined()) { + return; + } + + const double grad_norm = tensor.grad().norm().item(); + if (std::isfinite(grad_norm) && grad_norm > max_norm) { + const double scale = max_norm / (grad_norm + 1e-12); + tensor.grad().mul_(scale); + } +} + +std::tm localTime(std::time_t time) { + std::tm local_time{}; +#if defined(_WIN32) + localtime_s(&local_time, &time); +#else + localtime_r(&time, &local_time); +#endif + return local_time; +} + +std::string isoTimestampSeconds( + std::chrono::system_clock::time_point timestamp) { + const std::time_t now_time = + std::chrono::system_clock::to_time_t(timestamp); + const std::tm local_time = localTime(now_time); + + std::ostringstream output; + output << std::put_time(&local_time, "%Y-%m-%dT%H:%M:%S"); + return output.str(); +} + +class LearningRateScheduler { +public: + LearningRateScheduler(const placement::TrainingConfig& config, double base_lr) + : config_(config), base_lr_(base_lr), current_lr_(base_lr) { + if (config_.scheduler_name != "none" && + config_.scheduler_name != "plateau" && + config_.scheduler_name != "cosine" && + config_.scheduler_name != "step" && + config_.scheduler_name != "exponential") { + throw std::invalid_argument( + "Unsupported scheduler: " + config_.scheduler_name); + } + } + + void step(torch::optim::Adam& optimizer, double metric) { + if (config_.scheduler_name == "none") { + return; + } + + ++epoch_; + if (config_.scheduler_name == "plateau") { + stepPlateau(metric); + } else if (config_.scheduler_name == "cosine") { + stepCosine(); + } else if (config_.scheduler_name == "step") { + stepStep(); + } else if (config_.scheduler_name == "exponential") { + current_lr_ *= config_.scheduler_gamma; + } + + setOptimizerLearningRate(optimizer, current_lr_); + } + +private: + void stepPlateau(double metric) { + if (metric < best_metric_) { + best_metric_ = metric; + bad_epochs_ = 0; + return; + } + + ++bad_epochs_; + if (bad_epochs_ > config_.scheduler_patience) { + current_lr_ *= config_.scheduler_factor; + bad_epochs_ = 0; + } + } + + void stepCosine() { + const int t_max = std::max(1, config_.num_epochs); + const double progress = + static_cast(std::min(epoch_, t_max)) / static_cast(t_max); + current_lr_ = + config_.scheduler_eta_min + + (base_lr_ - config_.scheduler_eta_min) * + (1.0 + std::cos(std::acos(-1.0) * progress)) / 2.0; + } + + void stepStep() { + const int step_size = std::max(1, config_.scheduler_step_size); + if (epoch_ % step_size == 0) { + current_lr_ *= config_.scheduler_gamma; + } + } + + const placement::TrainingConfig& config_; + double base_lr_ = 0.0; + double current_lr_ = 0.0; + double best_metric_ = std::numeric_limits::infinity(); + int bad_epochs_ = 0; + int epoch_ = 0; +}; + +} // namespace + +namespace placement { + +TrainingResult trainPlacement( + const torch::Tensor& cell_features, + const torch::Tensor& pin_features, + const torch::Tensor& edge_list, + const TrainingConfig& config) { + TrainingResult result; + result.run_started_at = + isoTimestampSeconds(std::chrono::system_clock::now()); + auto working_cell_features = cell_features.clone(); + auto working_pin_features = pin_features.to(working_cell_features.device()); + auto working_edge_list = edge_list.to(working_cell_features.device()); + + result.initial_cell_features = working_cell_features.clone(); + if (config.num_epochs <= 0 || working_cell_features.size(0) == 0) { + result.final_cell_features = working_cell_features.clone(); + return result; + } + + auto cell_positions = + working_cell_features + .index({Slice(), + Slice( + featureIndex(CellFeatureIdx::X), + featureIndex(CellFeatureIdx::Y) + 1)}) + .clone() + .detach(); + cell_positions.set_requires_grad(true); + + torch::optim::Adam optimizer( + {cell_positions}, + torch::optim::AdamOptions(config.lr)); + LearningRateScheduler scheduler(config, config.lr); + + auto best_cell_positions = cell_positions.detach().clone(); + double best_overlap_score = std::numeric_limits::infinity(); + double best_zero_overlap_wl = std::numeric_limits::infinity(); + int epochs_without_improvement = 0; + int zero_overlap_epochs_without_improvement = 0; + bool zero_overlap_reached = false; + + for (int epoch = 0; epoch < config.num_epochs; ++epoch) { + result.epochs_completed = epoch + 1; + optimizer.zero_grad(); + + auto current_cell_features = + makeCellFeaturesWithPositions(working_cell_features, cell_positions); + const auto wl_loss = wirelengthAttractionLoss( + current_cell_features, + working_pin_features, + working_edge_list); + const auto overlap_loss = overlapRepulsionLoss( + current_cell_features, + working_pin_features, + working_edge_list); + const auto total_loss = + config.lambda_wirelength * wl_loss + + config.lambda_overlap * overlap_loss; + + total_loss.backward(); + clipGradientNorm(cell_positions, 5.0); + optimizer.step(); + scheduler.step(optimizer, total_loss.item()); + + const bool should_log_epoch = + config.verbose && + ((config.log_interval > 0 && epoch % config.log_interval == 0) || + epoch == config.num_epochs - 1); + const bool should_compute_overlap_metrics = + config.track_overlap_metrics || + config.early_stop_enabled || + should_log_epoch; + + OverlapMetrics overlap_metrics; + torch::Tensor updated_cell_features; + if (should_compute_overlap_metrics) { + updated_cell_features = makeCellFeaturesWithPositions( + working_cell_features, + cell_positions.detach()); + overlap_metrics = calculateOverlapMetrics(updated_cell_features); + } + + if (config.early_stop_enabled) { + const double overlap_score = overlap_metrics.total_overlap_area; + const bool has_zero_overlap = + overlap_metrics.overlap_count == 0 || + overlap_score <= config.early_stop_overlap_threshold; + + if (has_zero_overlap) { + const double current_wl = wirelengthAttractionLoss( + updated_cell_features, + working_pin_features, + working_edge_list) + .item(); + if (!zero_overlap_reached || + current_wl < + best_zero_overlap_wl - config.early_stop_min_delta) { + zero_overlap_reached = true; + best_zero_overlap_wl = current_wl; + best_cell_positions = cell_positions.detach().clone(); + result.best_epoch = epoch; + zero_overlap_epochs_without_improvement = 0; + } else { + ++zero_overlap_epochs_without_improvement; + } + + if (zero_overlap_reached && + zero_overlap_epochs_without_improvement >= + config.early_stop_zero_overlap_patience) { + result.stopped_early = true; + result.stop_reason = "zero_overlap_plateau"; + } + } else { + if (zero_overlap_reached) { + ++zero_overlap_epochs_without_improvement; + if (zero_overlap_epochs_without_improvement >= + config.early_stop_zero_overlap_patience) { + result.stopped_early = true; + result.stop_reason = "zero_overlap_plateau"; + } + } else { + if (overlap_score < + best_overlap_score - config.early_stop_min_delta) { + best_overlap_score = overlap_score; + best_cell_positions = cell_positions.detach().clone(); + result.best_epoch = epoch; + epochs_without_improvement = 0; + } else { + ++epochs_without_improvement; + } + + if (epochs_without_improvement >= + config.early_stop_patience) { + result.stopped_early = true; + result.stop_reason = "overlap_plateau"; + } + } + } + } + + if (config.track_loss_history) { + result.loss_history.total_loss.push_back(total_loss.item()); + result.loss_history.wirelength_loss.push_back(wl_loss.item()); + result.loss_history.overlap_loss.push_back(overlap_loss.item()); + result.loss_history.learning_rate.push_back( + optimizerLearningRate(optimizer)); + if (config.track_overlap_metrics) { + result.loss_history.overlap_count.push_back( + overlap_metrics.overlap_count); + result.loss_history.total_overlap_area.push_back( + overlap_metrics.total_overlap_area); + result.loss_history.max_overlap_area.push_back( + overlap_metrics.max_overlap_area); + } + } + + if (should_log_epoch) { + std::cout << "Epoch " << epoch << "/" << config.num_epochs << ":\n"; + std::cout << " Total Loss: " << total_loss.item() << "\n"; + std::cout << " Wirelength Loss: " << wl_loss.item() << "\n"; + std::cout << " Overlap Loss: " << overlap_loss.item() << "\n"; + std::cout << " Learning Rate: " << optimizerLearningRate(optimizer) + << "\n"; + if (should_compute_overlap_metrics) { + std::cout << " Overlap Count: " + << overlap_metrics.overlap_count << "\n"; + std::cout << " Total Overlap Area: " + << overlap_metrics.total_overlap_area << "\n"; + } + if (config.early_stop_enabled) { + std::cout << " Best Epoch: " << result.best_epoch << "\n"; + } + } + + if (result.stopped_early) { + if (config.verbose) { + std::cout << "Early stopping at epoch " << epoch + << " with reason=" << result.stop_reason + << " best_epoch=" << result.best_epoch << "\n"; + } + break; + } + } + + const auto final_positions = + config.early_stop_enabled ? best_cell_positions : cell_positions.detach(); + result.final_cell_features = + makeCellFeaturesWithPositions(working_cell_features, final_positions); + return result; +} + +} // namespace placement diff --git a/cpp/vcpkg.json b/cpp/vcpkg.json new file mode 100644 index 0000000..95ad7d6 --- /dev/null +++ b/cpp/vcpkg.json @@ -0,0 +1,10 @@ +{ + "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json", + "name": "placement-cpp", + "version-string": "0.1.0", + "dependencies": [ + "cli11", + "matplotlib-cpp", + "sqlite3" + ] +} diff --git a/cpp/visualization.cpp b/cpp/visualization.cpp new file mode 100644 index 0000000..54fbcd2 --- /dev/null +++ b/cpp/visualization.cpp @@ -0,0 +1,306 @@ +#include "placement/visualization.h" + +#include "placement/metrics.h" +#include "placement/types.h" + +#define WITHOUT_NUMPY +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { + +using namespace torch::indexing; +namespace plt = matplotlibcpp; + +#ifndef PLACEMENT_PYTHON_SITE_PACKAGES +#define PLACEMENT_PYTHON_SITE_PACKAGES "" +#endif + +int64_t featureIndex(placement::CellFeatureIdx idx) { + return static_cast(idx); +} + +struct CellRect { + double center_x = 0.0; + double center_y = 0.0; + double width = 0.0; + double height = 0.0; +}; + +struct PanelData { + torch::Tensor cells; + std::vector rects; + placement::OverlapMetrics metrics; + double min_x = -10.0; + double max_x = 10.0; + double min_y = -10.0; + double max_y = 10.0; +}; + +torch::Tensor prepareCellFeatures(const torch::Tensor& cell_features) { + if (!cell_features.defined()) { + throw std::invalid_argument("cell feature tensor must be defined"); + } + if (cell_features.dim() != 2) { + throw std::invalid_argument("cell feature tensor must be two-dimensional"); + } + if (cell_features.size(0) > 0 && + cell_features.size(1) <= featureIndex(placement::CellFeatureIdx::Height)) { + throw std::invalid_argument( + "cell feature tensor must contain area, pins, x, y, width, and height"); + } + + return cell_features.detach() + .to(torch::TensorOptions().device(torch::kCPU).dtype(torch::kFloat64)) + .contiguous(); +} + +double scalarAt(const torch::Tensor& cells, int64_t row, placement::CellFeatureIdx idx) { + return cells.index({row, featureIndex(idx)}).item(); +} + +bool isFinite(double value) { + return std::isfinite(value); +} + +PanelData buildPanelData(const torch::Tensor& cell_features) { + PanelData panel; + panel.cells = prepareCellFeatures(cell_features); + panel.metrics = placement::calculateOverlapMetrics(panel.cells); + + double min_x = std::numeric_limits::infinity(); + double max_x = -std::numeric_limits::infinity(); + double min_y = std::numeric_limits::infinity(); + double max_y = -std::numeric_limits::infinity(); + + const int64_t num_cells = panel.cells.size(0); + panel.rects.reserve(static_cast(num_cells)); + for (int64_t index = 0; index < num_cells; ++index) { + CellRect rect; + rect.center_x = scalarAt(panel.cells, index, placement::CellFeatureIdx::X); + rect.center_y = scalarAt(panel.cells, index, placement::CellFeatureIdx::Y); + rect.width = scalarAt(panel.cells, index, placement::CellFeatureIdx::Width); + rect.height = scalarAt(panel.cells, index, placement::CellFeatureIdx::Height); + panel.rects.push_back(rect); + + if (isFinite(rect.center_x) && isFinite(rect.center_y)) { + min_x = std::min(min_x, rect.center_x); + max_x = std::max(max_x, rect.center_x); + min_y = std::min(min_y, rect.center_y); + max_y = std::max(max_y, rect.center_y); + } + } + + if (min_x <= max_x && min_y <= max_y) { + constexpr double kMargin = 10.0; + panel.min_x = min_x - kMargin; + panel.max_x = max_x + kMargin; + panel.min_y = min_y - kMargin; + panel.max_y = max_y + kMargin; + } + + return panel; +} + +std::string formatTitle(const std::string& title, const placement::OverlapMetrics& metrics) { + std::ostringstream output; + output << title << "\nOverlaps: " << metrics.overlap_count + << ", Total Overlap Area: " << std::fixed << std::setprecision(2) + << metrics.total_overlap_area; + return output.str(); +} + +void drawCell(const CellRect& rect) { + if (!isFinite(rect.center_x) || !isFinite(rect.center_y) || !isFinite(rect.width) || + !isFinite(rect.height) || rect.width <= 0.0 || rect.height <= 0.0) { + return; + } + + const double left = rect.center_x - rect.width / 2.0; + const double right = rect.center_x + rect.width / 2.0; + const double bottom = rect.center_y - rect.height / 2.0; + const double top = rect.center_y + rect.height / 2.0; + const std::vector xs = {left, right, right, left, left}; + const std::vector ys = {bottom, bottom, top, top, bottom}; + + if (!plt::fill(xs, ys, {{"color", "lightblue"}})) { + throw std::runtime_error("Call to fill() failed."); + } + if (!plt::plot(xs, ys, "b-")) { + throw std::runtime_error("Call to plot() failed."); + } +} + +void setEqualAspect() { + PyObject* axes = PyObject_CallObject( + matplotlibcpp::detail::_interpreter::get().s_python_function_gca, + matplotlibcpp::detail::_interpreter::get().s_python_empty_tuple); + if (axes == nullptr) { + throw std::runtime_error("Call to gca() failed."); + } + + PyObject* result = PyObject_CallMethod( + axes, + const_cast("set_aspect"), + "ss", + "equal", + "box"); + Py_DECREF(axes); + if (result == nullptr) { + throw std::runtime_error("Call to set_aspect() failed."); + } + Py_DECREF(result); +} + +void drawPanel(const PanelData& panel, const std::string& title) { + for (const CellRect& rect : panel.rects) { + drawCell(rect); + } + + plt::title(formatTitle(title, panel.metrics)); + setEqualAspect(); + plt::grid(true); + plt::xlim(panel.min_x, panel.max_x); + plt::ylim(panel.min_y, panel.max_y); +} + +void selectSubplot(long plot_number) { + PyObject* args = PyTuple_New(1); + PyTuple_SetItem(args, 0, PyLong_FromLong(plot_number)); + + PyObject* result = PyObject_CallObject( + matplotlibcpp::detail::_interpreter::get().s_python_function_subplot, + args); + Py_DECREF(args); + if (result == nullptr) { + throw std::runtime_error("Call to subplot() failed."); + } + Py_DECREF(result); +} + +void setEnvVar(const std::string& name, const std::string& value, bool overwrite) { +#ifdef _WIN32 + if (!overwrite && std::getenv(name.c_str()) != nullptr) { + return; + } + _putenv_s(name.c_str(), value.c_str()); +#else + setenv(name.c_str(), value.c_str(), overwrite ? 1 : 0); +#endif +} + +void prependEnvPath(const std::string& name, const std::string& path) { + if (path.empty()) { + return; + } + + const char* current_value = std::getenv(name.c_str()); + if (current_value == nullptr || std::string(current_value).empty()) { + setEnvVar(name, path, true); + return; + } + + const std::string current(current_value); + if (current == path) { + return; + } + +#ifdef _WIN32 + constexpr char kPathSeparator = ';'; +#else + constexpr char kPathSeparator = ':'; +#endif + const std::string path_with_separator = path + kPathSeparator; + const std::string separator_with_path = + std::string(1, kPathSeparator) + path + kPathSeparator; + const bool ends_with_path = + current.size() > path.size() && + current.compare(current.size() - path.size(), path.size(), path) == 0 && + current[current.size() - path.size() - 1] == kPathSeparator; + if (current.rfind(path_with_separator, 0) == 0 || + current.find(separator_with_path) != std::string::npos || ends_with_path) { + return; + } + + setEnvVar(name, path + kPathSeparator + current, true); +} + +void configureHeadlessBackend() { + prependEnvPath("PYTHONPATH", PLACEMENT_PYTHON_SITE_PACKAGES); + + const std::filesystem::path config_dir = + std::filesystem::temp_directory_path() / "matplotlib-cpp"; + const std::filesystem::path cache_dir = + std::filesystem::temp_directory_path() / "matplotlib-cpp-cache"; + std::filesystem::create_directories(config_dir); + std::filesystem::create_directories(cache_dir); + + setEnvVar("MPLBACKEND", "Agg", true); + setEnvVar("MPLCONFIGDIR", config_dir.string(), true); + setEnvVar("XDG_CACHE_HOME", cache_dir.string(), false); +} + +void closePlotIgnoringErrors() { + try { + plt::close(); + } catch (...) { + } +} + +} // namespace + +namespace placement { + +void plotPlacement( + const torch::Tensor& initial_cell_features, + const torch::Tensor& final_cell_features, + const std::filesystem::path& output_path) { + configureHeadlessBackend(); + + const PanelData initial_panel = buildPanelData(initial_cell_features); + const PanelData final_panel = buildPanelData(final_cell_features); + + const std::filesystem::path parent = output_path.parent_path(); + if (!parent.empty()) { + std::filesystem::create_directories(parent); + } + + try { + plt::figure_size(1600, 800); + selectSubplot(121); + drawPanel(initial_panel, "Initial Placement"); + selectSubplot(122); + drawPanel(final_panel, "Final Placement"); + plt::tight_layout(); + plt::save(output_path.string()); + plt::close(); + } catch (const std::exception& error) { + if (PyErr_Occurred() != nullptr) { + PyErr_Print(); + } + closePlotIgnoringErrors(); + throw std::runtime_error( + "Unable to render placement image to " + output_path.string() + + ": " + error.what()); + } catch (...) { + if (PyErr_Occurred() != nullptr) { + PyErr_Print(); + } + closePlotIgnoringErrors(); + throw std::runtime_error( + "Unable to render placement image to " + output_path.string()); + } +} + +} // namespace placement diff --git a/hyperparameter_search.py b/hyperparameter_search.py new file mode 100644 index 0000000..b77a0f4 --- /dev/null +++ b/hyperparameter_search.py @@ -0,0 +1,154 @@ +from learning_rate_scheduler_util import suggest_scheduler_config + + +DEFAULT_OPTUNA_TUNING_CASES = [ + (2, 20, 1201), + (3, 40, 1202), + (4, 75, 1203), + (10, 2000, 1210) +] + + +def run_optuna_search( + args, + *, + get_best_device, + seed_torch, + generate_placement_input, + initialize_cell_positions, + train_placement, + calculate_normalized_metrics, + tuning_cases=None, +): + """Run Optuna-based hyperparameter search.""" + try: + import optuna + except ImportError as exc: + raise RuntimeError( + "Optuna is not installed. Install it with `pip install optuna` to use --optuna." + ) from exc + + tuning_cases = tuning_cases or DEFAULT_OPTUNA_TUNING_CASES + device = get_best_device() + + def objective(trial): + lambda_wirelength = trial.suggest_float( + "lambda_wirelength", + 0.1, + 10.0, + log=True, + ) + lambda_overlap = trial.suggest_float( + "lambda_overlap", + 0.5, + 50.0, + log=True, + ) + lr = trial.suggest_float("lr", 1e-3, 3e-1, log=True) + scheduler_name, scheduler_kwargs = suggest_scheduler_config( + trial, + lr=lr, + num_epochs=args.optuna_epochs, + ) + + overlap_scores = [] + wirelength_scores = [] + + for case_idx, (num_macros, num_std_cells, seed) in enumerate( + tuning_cases, + start=1, + ): + seed_torch(seed) + cell_features, pin_features, edge_list = generate_placement_input( + num_macros, + num_std_cells, + device=device, + verbose=False, + ) + initialize_cell_positions(cell_features) + + result = train_placement( + cell_features, + pin_features, + edge_list, + num_epochs=args.optuna_epochs, + lr=lr, + lambda_wirelength=lambda_wirelength, + lambda_overlap=lambda_overlap, + scheduler_name=scheduler_name, + scheduler_kwargs=scheduler_kwargs, + track_loss_history=args.track_loss_history, + verbose=False, + run_metadata={ + "runner": "optuna", + "trial_number": trial.number, + "seed": seed, + "num_macros": num_macros, + "num_std_cells": num_std_cells, + }, + early_stop_enabled=args.early_stop, + early_stop_patience=args.early_stop_patience, + early_stop_min_delta=args.early_stop_min_delta, + early_stop_overlap_threshold=args.early_stop_overlap_threshold, + early_stop_zero_overlap_patience=args.early_stop_zero_overlap_patience, + device=device, + ) + + metrics = calculate_normalized_metrics( + result["final_cell_features"], + pin_features, + edge_list, + ) + overlap_scores.append(metrics["overlap_ratio"]) + wirelength_scores.append(metrics["normalized_wl"]) + + partial_score = ( + sum(overlap_scores) / len(overlap_scores) * 1000.0 + + sum(wirelength_scores) / len(wirelength_scores) + ) + trial.report(partial_score, step=case_idx) + if trial.should_prune(): + raise optuna.TrialPruned() + + avg_overlap = sum(overlap_scores) / len(overlap_scores) + avg_wirelength = sum(wirelength_scores) / len(wirelength_scores) + objective_value = avg_overlap * 1000.0 + avg_wirelength + + trial.set_user_attr("avg_overlap", avg_overlap) + trial.set_user_attr("avg_wirelength", avg_wirelength) + return objective_value + + storage = args.optuna_storage or None + study = optuna.create_study( + direction="minimize", + study_name=args.optuna_study_name, + storage=storage, + load_if_exists=bool(storage), + sampler=optuna.samplers.TPESampler(seed=42), + pruner=optuna.pruners.MedianPruner(n_startup_trials=5, n_warmup_steps=1), + ) + + print("=" * 70) + print("RUNNING OPTUNA SEARCH") + print("=" * 70) + print(f"Trials: {args.optuna_trials}") + print(f"Epochs per trial: {args.optuna_epochs}") + print(f"Tuning cases: {tuning_cases}") + print(f"Device: {device}") + + study.optimize(objective, n_trials=args.optuna_trials) + + best_trial = study.best_trial + print("\n" + "=" * 70) + print("BEST OPTUNA TRIAL") + print("=" * 70) + print(f"Objective: {best_trial.value:.6f}") + print( + f"Average Overlap: {best_trial.user_attrs.get('avg_overlap', float('nan')):.6f}" + ) + print( + f"Average Wirelength: {best_trial.user_attrs.get('avg_wirelength', float('nan')):.6f}" + ) + print("Best parameters:") + for key, value in best_trial.params.items(): + print(f" {key}: {value}") diff --git a/lab/loss_curve_test.py b/lab/loss_curve_test.py new file mode 100644 index 0000000..90682c2 --- /dev/null +++ b/lab/loss_curve_test.py @@ -0,0 +1,105 @@ +import torch +import matplotlib.pyplot as plt +from matplotlib.ticker import ScalarFormatter + + +def overlap_loss_from_pairwise_overlap_area(pairwise_overlap_area: torch.Tensor) -> torch.Tensor: + """Apply the same masking and normalization used in placement.py.""" + n = pairwise_overlap_area.shape[0] + mask = torch.triu(torch.ones_like(pairwise_overlap_area), diagonal=1) + overlap_sclar = 150 + # normalization = torch.sqrt( + # torch.tensor( + # n, + # device=pairwise_overlap_area.device, + # dtype=pairwise_overlap_area.dtype, + # ) + # ) + # return torch.log1p(torch.sum(pairwise_overlap_area * mask) / normalization) + return torch.log1p(torch.sum(pairwise_overlap_area * mask)) * overlap_sclar + + +def main() -> None: + # Sweep one active upper-triangular overlap value from 1e7 down to 1. + overlap_values = torch.logspace(7, 0, steps=200) + losses = [] + + for overlap_value in overlap_values: + pairwise_overlap_area = torch.tensor( + [ + [0.0, overlap_value.item()], + [0.0, 0.0], + ], + dtype=torch.float32, + ) + losses.append(overlap_loss_from_pairwise_overlap_area(pairwise_overlap_area).item()) + + losses = torch.tensor(losses) + overlap_np = overlap_values.numpy() + losses_np = losses.numpy() + + fig, ax = plt.subplots(figsize=(9, 6)) + (line,) = ax.plot( + overlap_np, + losses_np, + linewidth=2, + label="loss(pairwise_overlap_area)", + ) + ax.scatter(overlap_np, losses_np, s=12, alpha=0.35, color=line.get_color()) + ax.set_xlabel("pairwise_overlap_area") + ax.set_ylabel("loss") + ax.set_title("Interactive Overlap Loss Curve") + ax.grid(True, which="both", linestyle="--", alpha=0.4) + ax.legend(loc="best") + ax.ticklabel_format(style="plain", axis="both", useOffset=False) + ax.xaxis.set_major_formatter(ScalarFormatter()) + ax.yaxis.set_major_formatter(ScalarFormatter()) + + annotation = ax.annotate( + "", + xy=(0, 0), + xytext=(15, 15), + textcoords="offset points", + bbox={"boxstyle": "round", "fc": "white", "alpha": 0.9}, + arrowprops={"arrowstyle": "->", "alpha": 0.6}, + ) + annotation.set_visible(False) + + def update_annotation(index: int) -> None: + x_value = float(overlap_np[index]) + y_value = float(losses_np[index]) + annotation.xy = (x_value, y_value) + annotation.set_text( + f"pairwise_overlap_area={x_value:,.3f}\nloss={y_value:,.3f}" + ) + annotation.set_visible(True) + + def on_move(event) -> None: + if event.inaxes != ax or event.xdata is None or event.ydata is None: + if annotation.get_visible(): + annotation.set_visible(False) + fig.canvas.draw_idle() + return + + display_points = ax.transData.transform( + torch.tensor(list(zip(overlap_np, losses_np))).numpy() + ) + dx = display_points[:, 0] - event.x + dy = display_points[:, 1] - event.y + distances = dx * dx + dy * dy + nearest_index = int(distances.argmin()) + + if distances[nearest_index] < 250: + update_annotation(nearest_index) + elif annotation.get_visible(): + annotation.set_visible(False) + + fig.canvas.draw_idle() + + fig.canvas.mpl_connect("motion_notify_event", on_move) + plt.tight_layout() + plt.show() + + +if __name__ == "__main__": + main() diff --git a/lab/loss_tracking.ipynb b/lab/loss_tracking.ipynb new file mode 100644 index 0000000..1513c41 --- /dev/null +++ b/lab/loss_tracking.ipynb @@ -0,0 +1,517 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "imports-cell", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import sqlite3\n", + "import struct\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "load-loss-history-db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading latest database: ../loss_tracking/loss_tracking_20260420_012613_033605.sqlite3\n", + "Loaded 9 runs from /Users/vrajpandya/repo/intern_challenge/loss_tracking/loss_tracking_20260420_012613_033605.sqlite3\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", + "
test_idrun_countseedslatest_run_id
011[1001]20260420_012620_124613
121[1002]20260420_012620_186187
231[1003]20260420_012620_133819
341[1004]20260420_012620_862646
451[1005]20260420_012626_972623
561[1006]20260420_012628_796746
671[1007]20260420_012633_126300
781[1008]20260420_012634_066538
891[1009]20260420_012645_340855
\n", + "
" + ], + "text/plain": [ + " test_id run_count seeds latest_run_id\n", + "0 1 1 [1001] 20260420_012620_124613\n", + "1 2 1 [1002] 20260420_012620_186187\n", + "2 3 1 [1003] 20260420_012620_133819\n", + "3 4 1 [1004] 20260420_012620_862646\n", + "4 5 1 [1005] 20260420_012626_972623\n", + "5 6 1 [1006] 20260420_012628_796746\n", + "6 7 1 [1007] 20260420_012633_126300\n", + "7 8 1 [1008] 20260420_012634_066538\n", + "8 9 1 [1009] 20260420_012645_340855" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loss_tracking_dir = Path(\"../loss_tracking\")\n", + "db_paths = sorted(loss_tracking_dir.glob(\"loss_tracking_*.sqlite3\"))\n", + "\n", + "if not db_paths:\n", + " raise FileNotFoundError(f\"No SQLite loss history database found in {loss_tracking_dir.resolve()}\")\n", + "\n", + "db_path = max(db_paths, key=lambda path: path.stat().st_mtime)\n", + "print(f\"Loading latest database: {db_path}\")\n", + "\n", + "with sqlite3.connect(db_path) as connection:\n", + " loss_df = pd.read_sql_query(\n", + " \"\"\"\n", + " SELECT\n", + " lh.run_id,\n", + " lh.epoch,\n", + " lh.total_loss,\n", + " lh.wirelength_loss,\n", + " lh.overlap_loss,\n", + " lh.overlap_count,\n", + " lh.total_overlap_area,\n", + " lh.max_overlap_area,\n", + " r.runner,\n", + " r.run_label,\n", + " r.run_started_at,\n", + " r.saved_at,\n", + " r.num_epochs,\n", + " r.lr,\n", + " r.lambda_wirelength,\n", + " r.lambda_overlap,\n", + " r.log_interval,\n", + " r.verbose,\n", + " r.total_cells,\n", + " r.total_pins,\n", + " r.total_edges,\n", + " COALESCE(tc.test_id, r.test_id) AS test_id,\n", + " COALESCE(tc.num_macros, r.num_macros) AS num_macros,\n", + " COALESCE(tc.num_std_cells, r.num_std_cells) AS num_std_cells,\n", + " COALESCE(tc.seed, r.seed) AS seed\n", + " FROM loss_history AS lh\n", + " JOIN runs AS r ON r.run_id = lh.run_id\n", + " LEFT JOIN test_cases AS tc ON tc.test_id = r.test_id\n", + " ORDER BY tc.test_id, lh.run_id, lh.epoch\n", + " \"\"\",\n", + " connection,\n", + " )\n", + "\n", + "def decode_sqlite_numeric(value):\n", + " if isinstance(value, bytes):\n", + " if len(value) == 4:\n", + " return struct.unpack(\"\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
test_idseedrun_idrunnerrun_labelsaved_at
01100120260420_012620_124613test.pytrain_placement2026-04-20T01:26:20
12100220260420_012620_186187test.pytrain_placement2026-04-20T01:26:20
23100320260420_012620_133819test.pytrain_placement2026-04-20T01:26:20
34100420260420_012620_862646test.pytrain_placement2026-04-20T01:26:20
45100520260420_012626_972623test.pytrain_placement2026-04-20T01:26:26
56100620260420_012628_796746test.pytrain_placement2026-04-20T01:26:28
67100720260420_012633_126300test.pytrain_placement2026-04-20T01:26:33
78100820260420_012634_066538test.pytrain_placement2026-04-20T01:26:34
89100920260420_012645_340855test.pytrain_placement2026-04-20T01:26:45
\n", + "" + ], + "text/plain": [ + " test_id seed run_id runner run_label \\\n", + "0 1 1001 20260420_012620_124613 test.py train_placement \n", + "1 2 1002 20260420_012620_186187 test.py train_placement \n", + "2 3 1003 20260420_012620_133819 test.py train_placement \n", + "3 4 1004 20260420_012620_862646 test.py train_placement \n", + "4 5 1005 20260420_012626_972623 test.py train_placement \n", + "5 6 1006 20260420_012628_796746 test.py train_placement \n", + "6 7 1007 20260420_012633_126300 test.py train_placement \n", + "7 8 1008 20260420_012634_066538 test.py train_placement \n", + "8 9 1009 20260420_012645_340855 test.py train_placement \n", + "\n", + " saved_at \n", + "0 2026-04-20T01:26:20 \n", + "1 2026-04-20T01:26:20 \n", + "2 2026-04-20T01:26:20 \n", + "3 2026-04-20T01:26:20 \n", + "4 2026-04-20T01:26:26 \n", + "5 2026-04-20T01:26:28 \n", + "6 2026-04-20T01:26:33 \n", + "7 2026-04-20T01:26:34 \n", + "8 2026-04-20T01:26:45 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "available_runs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "plot-loss-history", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(4, 1, figsize=(14, 18), sharex=True)\n", + "\n", + "for run_id, run_df in loss_df.groupby(\"run_id\", sort=True):\n", + " run_label = f\"run {run_id}\"\n", + " if \"test_id\" in run_df.columns and run_df[\"test_id\"].notna().any():\n", + " run_label = f\"test {int(run_df['test_id'].dropna().iloc[0])} | {run_label}\"\n", + " if \"seed\" in run_df.columns and run_df[\"seed\"].notna().any():\n", + " run_label = f\"{run_label} | seed {int(run_df['seed'].dropna().iloc[0])}\"\n", + "\n", + " total_loss_log = np.log1p(run_df[\"total_loss\"].clip(lower=0))\n", + " overlap_loss_log = np.log1p(run_df[\"overlap_loss\"].clip(lower=0))\n", + "\n", + " axes[0].plot(run_df[\"epoch\"], total_loss_log, label=f\"total {run_label}\", alpha=0.8)\n", + " axes[0].plot(\n", + " run_df[\"epoch\"],\n", + " overlap_loss_log,\n", + " linestyle=\":\",\n", + " label=f\"overlap {run_label}\",\n", + " alpha=0.7,\n", + " )\n", + " axes[1].plot(\n", + " run_df[\"epoch\"],\n", + " run_df[\"wirelength_loss\"],\n", + " label=f\"wirelength {run_label}\",\n", + " alpha=0.8,\n", + " )\n", + "\n", + " if \"overlap_count\" in run_df.columns:\n", + " axes[2].plot(\n", + " run_df[\"epoch\"],\n", + " run_df[\"overlap_count\"],\n", + " label=f\"count {run_label}\",\n", + " alpha=0.8,\n", + " )\n", + " if \"max_overlap_area\" in run_df.columns:\n", + " axes[3].plot(\n", + " run_df[\"epoch\"],\n", + " run_df[\"max_overlap_area\"],\n", + " label=f\"max area {run_label}\",\n", + " alpha=0.8,\n", + " )\n", + "\n", + "axes[0].set_ylabel(\"log1p(Loss)\")\n", + "axes[0].set_title(\"Log Total And Overlap Loss By Run\")\n", + "axes[0].legend(loc=\"center left\", bbox_to_anchor=(1.02, 0.5))\n", + "axes[0].grid(True, alpha=0.3)\n", + "\n", + "axes[1].set_ylabel(\"Wirelength Loss\")\n", + "axes[1].set_title(\"Wirelength Loss By Run\")\n", + "axes[1].legend(loc=\"center left\", bbox_to_anchor=(1.02, 0.5))\n", + "axes[1].grid(True, alpha=0.3)\n", + "\n", + "axes[2].set_ylabel(\"Overlap Count\")\n", + "axes[2].set_title(\"Overlap Count By Run\")\n", + "axes[2].legend(loc=\"center left\", bbox_to_anchor=(1.02, 0.5))\n", + "axes[2].grid(True, alpha=0.3)\n", + "\n", + "axes[3].set_xlabel(\"Epoch\")\n", + "axes[3].set_ylabel(\"Max Overlap Area\")\n", + "axes[3].set_title(\"Max Overlap Area By Run\")\n", + "axes[3].legend(loc=\"center left\", bbox_to_anchor=(1.02, 0.5))\n", + "axes[3].grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + } + ], + "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.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/lab/profiling.ipynb b/lab/profiling.ipynb new file mode 100644 index 0000000..7f37000 --- /dev/null +++ b/lab/profiling.ipynb @@ -0,0 +1,4409 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "id": "16fc7e3c-465e-4189-86d0-54a1f6c5e169", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import pstats\n", + "\n", + "profile_dir = (Path.cwd() / \"..\" / \"profile\").resolve()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "efbaba45", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Latest profile: /Users/vrajpandya/repo/intern_challenge/profile/profile_20260418_091607.prof\n" + ] + } + ], + "source": [ + "# reload latest profile\n", + "profiles = sorted(profile_dir.glob(\"*.prof\"), key=lambda path: path.stat().st_mtime)\n", + "\n", + "if not profiles:\n", + " raise FileNotFoundError(f\"No .prof files found in {profile_dir}\")\n", + "\n", + "latest_profile = profiles[-1]\n", + "print(f\"Latest profile: {latest_profile}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "635d44c1", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sat Apr 18 09:16:07 2026 /Users/vrajpandya/repo/intern_challenge/profile/profile_20260418_091607.prof\n", + "\n", + " 2875198 function calls (2837522 primitive calls) in 1.650 seconds\n", + "\n", + " Ordered by: cumulative time\n", + "\n", + " ncalls tottime percall cumtime percall filename:lineno(function)\n", + " 1 0.000 0.000 1.651 1.651 /Users/vrajpandya/repo/intern_challenge/placement.py:716(main)\n", + " 1 0.001 0.001 0.917 0.917 /Users/vrajpandya/repo/intern_challenge/placement.py:638(plot_placement)\n", + " 1 0.028 0.028 0.688 0.688 /Users/vrajpandya/repo/intern_challenge/placement.py:369(train_placement)\n", + " 375/8 0.001 0.000 0.631 0.079 :1167(_find_and_load)\n", + " 371/8 0.001 0.000 0.631 0.079 :1122(_find_and_load_unlocked)\n", + " 362/9 0.001 0.000 0.630 0.070 :666(_load_unlocked)\n", + " 350/9 0.000 0.000 0.630 0.070 :934(exec_module)\n", + " 944/13 0.000 0.000 0.629 0.048 :233(_call_with_frames_removed)\n", + " 806/9 0.020 0.000 0.626 0.070 {built-in method builtins.exec}\n", + " 189/16 0.000 0.000 0.477 0.030 {built-in method builtins.__import__}\n", + " 452/47 0.001 0.000 0.461 0.010 :1209(_handle_fromlist)\n", + " 1001 0.001 0.000 0.331 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_compile.py:20(inner)\n", + " 1 0.000 0.000 0.330 0.330 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:1129(savefig)\n", + " 1 0.000 0.000 0.330 0.330 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:3234(savefig)\n", + " 1 0.000 0.000 0.330 0.330 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2052(print_figure)\n", + " 1 0.000 0.000 0.294 0.294 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/adam.py:15(__init__)\n", + " 1 0.000 0.000 0.294 0.294 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:239(__init__)\n", + " 1 0.000 0.000 0.293 0.293 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/__init__.py:1()\n", + " 1 0.000 0.000 0.239 0.239 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:1()\n", + " 2 0.000 0.000 0.230 0.115 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2043()\n", + " 2 0.000 0.000 0.230 0.115 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:450(print_png)\n", + " 2 0.000 0.000 0.230 0.115 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:440(_print_pil)\n", + "1305/1164 0.009 0.000 0.199 0.000 {built-in method builtins.__build_class__}\n", + " 1 0.000 0.000 0.166 0.166 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:1531(imsave)\n", + " 1 0.000 0.000 0.165 0.165 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:2346(save)\n", + " 1 0.000 0.000 0.160 0.160 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:1242(_save)\n", + " 1 0.000 0.000 0.160 0.160 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:499(_save)\n", + " 1 0.000 0.000 0.160 0.160 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:527(_encode_tile)\n", + " 2 0.160 0.080 0.160 0.080 {method 'encode' of 'ImagingEncoder' objects}\n", + " 105 0.000 0.000 0.145 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:159(_update_set_signature_and_docstring)\n", + " 104 0.000 0.000 0.143 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:126(__init_subclass__)\n", + " 1000 0.001 0.000 0.141 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_tensor.py:433(backward)\n", + " 1 0.000 0.000 0.140 0.140 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:1459(subplots)\n", + " 1000 0.002 0.000 0.140 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/__init__.py:149(backward)\n", + " 1000 0.135 0.000 0.135 0.000 {method 'run_backward' of 'torch._C._EngineBase' objects}\n", + " 1 0.000 0.000 0.134 0.134 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/decorators.py:1()\n", + " 1 0.000 0.000 0.134 0.134 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/decorators.py:101(inner)\n", + " 2 0.000 0.000 0.134 0.067 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:82(remove)\n", + " 4/3 0.000 0.000 0.134 0.045 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:63(__call__)\n", + " 1 0.000 0.000 0.134 0.134 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:149(_allowed_function_ids)\n", + " 585/2 0.023 0.000 0.131 0.065 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:188(_find_torch_objects)\n", + " 7/3 0.000 0.000 0.130 0.043 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:443(wrapper)\n", + " 6 0.000 0.000 0.122 0.020 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:4338(get_tightbbox)\n", + " 1 0.000 0.000 0.120 0.120 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:1()\n", + " 1 0.000 0.000 0.114 0.114 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/__init__.py:1()\n", + " 117 0.000 0.000 0.113 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1837(kwdoc)\n", + " 350 0.001 0.000 0.110 0.000 :1007(get_code)\n", + " 2 0.000 0.000 0.102 0.051 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:93(draw_wrapper)\n", + " 592/2 0.001 0.000 0.102 0.051 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:54(draw_wrapper)\n", + " 2 0.000 0.000 0.102 0.051 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:3134(draw)\n", + " 6/2 0.000 0.000 0.100 0.050 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:114(_draw_list_compositing_images)\n", + " 4 0.000 0.000 0.100 0.025 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3005(draw)\n", + " 1001 0.059 0.000 0.100 0.000 /Users/vrajpandya/repo/intern_challenge/placement.py:252(wirelength_attraction_loss)\n", + " 117 0.002 0.000 0.097 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1598(pprint_setters)\n", + " 14/10 0.000 0.000 0.096 0.010 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1404(_get_tightbbox_for_layout_only)\n", + " 22 0.000 0.000 0.095 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1320(get_tightbbox)\n", + " 1 0.000 0.000 0.095 0.095 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colorbar.py:1()\n", + " 1 0.000 0.000 0.094 0.094 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:777(figure)\n", + " 1 0.000 0.000 0.094 0.094 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:462(new_figure_manager)\n", + " 1 0.000 0.000 0.092 0.092 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:1()\n", + " 1 0.000 0.000 0.086 0.086 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3404(new_figure_manager)\n", + " 1 0.000 0.000 0.086 0.086 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3413(new_figure_manager_given_figure)\n", + " 1 0.000 0.000 0.086 0.086 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1774(new_manager)\n", + " 1 0.042 0.042 0.086 0.086 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2682(create_with_canvas)\n", + " 1 0.000 0.000 0.085 0.085 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:1()\n", + " 122 0.002 0.000 0.083 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1270(_update_ticks)\n", + " 4252 0.006 0.000 0.080 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1470(get_valid_values)\n", + " 1 0.000 0.000 0.074 0.074 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:2591(tight_layout)\n", + " 1 0.000 0.000 0.074 0.074 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:3508(tight_layout)\n", + " 1 0.000 0.000 0.074 0.074 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:163(execute)\n", + " 1 0.000 0.000 0.072 0.072 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_layout.py:194(get_tight_layout_figure)\n", + " 1 0.000 0.000 0.072 0.072 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_layout.py:20(_auto_adjust_subplotpars)\n", + " 15841 0.011 0.000 0.071 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:157(_is_allowed_module_prefix)\n", + " 9 0.000 0.000 0.068 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/__init__.py:108(import_module)\n", + " 9 0.000 0.000 0.068 0.008 :1194(_gcd_import)\n", + " 1 0.000 0.000 0.067 0.067 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/__init__.py:1()\n", + " 1 0.000 0.000 0.066 0.066 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/convert_frame.py:1()\n", + " 2 0.000 0.000 0.064 0.032 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:381(draw)\n", + " 1 0.000 0.000 0.060 0.060 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:1()\n", + " 350 0.000 0.000 0.060 0.000 :1127(get_data)\n", + " 1 0.000 0.000 0.059 0.059 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config.py:1()\n", + " 7277 0.040 0.000 0.059 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:867(cleandoc)\n", + " 1 0.000 0.000 0.059 0.059 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:1736(get_tightbbox)\n", + " 2 0.000 0.000 0.057 0.028 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/__init__.py:1820(__getattr__)\n", + " 1 0.000 0.000 0.057 0.057 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/__init__.py:1()\n", + " 7315 0.003 0.000 0.055 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:848(getdoc)\n", + " 1 0.000 0.000 0.054 0.054 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/contour.py:1()\n", + " 350 0.049 0.000 0.049 0.000 {method 'read' of '_io.BufferedReader' objects}\n", + " 462 0.002 0.000 0.049 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:915(get_window_extent)\n", + " 1 0.000 0.000 0.049 0.049 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1()\n", + " 23961 0.011 0.000 0.046 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:973(getmodule)\n", + " 7505 0.003 0.000 0.046 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/__init__.py:272(_compile)\n", + " 1 0.000 0.000 0.046 0.046 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:799(subplots)\n", + " 1 0.000 0.000 0.046 0.046 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:264(subplots)\n", + " 2 0.000 0.000 0.046 0.023 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:658(add_subplot)\n", + " 2 0.000 0.000 0.046 0.023 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:569(__init__)\n", + " 350 0.000 0.000 0.045 0.000 :727(_compile_bytecode)\n", + " 1000 0.003 0.000 0.045 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:356(wrapper)\n", + " 350 0.045 0.000 0.045 0.000 {built-in method marshal.loads}\n", + " 8 0.000 0.000 0.044 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1379(draw)\n", + " 1 0.000 0.000 0.043 0.043 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1()\n", + " 189 0.000 0.000 0.042 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:738(compile)\n", + " 10 0.000 0.000 0.041 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:2943(_update_title_position)\n", + " 440 0.005 0.000 0.040 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:358(_get_layout)\n", + " 1 0.022 0.022 0.040 0.040 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:152(__init__)\n", + " 60 0.000 0.000 0.039 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1311(_get_ticklabel_bboxes)\n", + " 1 0.000 0.000 0.039 0.039 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/errors.py:1()\n", + " 60 0.000 0.000 0.039 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1315()\n", + " 1 0.000 0.000 0.039 0.039 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1()\n", + " 1 0.000 0.000 0.038 0.038 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/__init__.py:1()\n", + " 1 0.000 0.000 0.038 0.038 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_axes.py:1()\n", + " 1000 0.008 0.000 0.037 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/nn/utils/clip_grad.py:12(clip_grad_norm_)\n", + " 123 0.000 0.000 0.037 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1209(wrap)\n", + " 8766 0.003 0.000 0.037 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:936(getsourcefile)\n", + " 223 0.000 0.000 0.037 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1422(__init__)\n", + " 123 0.003 0.000 0.037 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:884(_process_class)\n", + " 234 0.000 0.000 0.037 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:579(draw)\n", + " 223 0.006 0.000 0.037 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1442(get_aliases)\n", + " 1 0.000 0.000 0.037 0.037 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_diagnostic.py:1()\n", + " 1 0.000 0.000 0.036 0.036 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/__init__.py:1()\n", + " 62 0.001 0.000 0.036 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:142(get_window_extent)\n", + " 20 0.000 0.000 0.036 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2599(_update_label_position)\n", + " 30 0.000 0.000 0.036 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2143(_get_tick_boxes_siblings)\n", + " 1 0.000 0.000 0.036 0.036 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1()\n", + " 16993 0.009 0.000 0.035 0.000 {built-in method builtins.any}\n", + " 1000 0.002 0.000 0.034 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:58(_use_grad)\n", + " 1 0.000 0.000 0.034 0.034 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:1()\n", + " 1 0.000 0.000 0.034 0.034 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:1()\n", + " 106 0.000 0.000 0.033 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:2376(add_patch)\n", + " 117 0.000 0.000 0.032 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:48(__init__)\n", + " 1 0.000 0.000 0.032 0.032 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/formatter.py:1()\n", + " 362 0.000 0.000 0.032 0.000 :566(module_from_spec)\n", + "12203/9731 0.005 0.000 0.031 0.000 {built-in method numpy.core._multiarray_umath.implement_array_function}\n", + " 1 0.000 0.000 0.031 0.031 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/__init__.py:1()\n", + " 1001 0.031 0.000 0.031 0.000 {built-in method torch.logsumexp}\n", + " 1000 0.002 0.000 0.031 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/adam.py:130(step)\n", + " 1882 0.001 0.000 0.031 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:268(to_rgba)\n", + " 1 0.014 0.014 0.031 0.031 /Users/vrajpandya/repo/intern_challenge/placement.py:91(generate_placement_input)\n", + " 1 0.000 0.000 0.030 0.030 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/skipfiles.py:1()\n", + " 1 0.000 0.000 0.030 0.030 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:1()\n", + " 93 0.000 0.000 0.029 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:350(get_tightbbox)\n", + " 189 0.000 0.000 0.029 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:970(parse)\n", + " 40 0.000 0.000 0.029 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/__init__.py:225(compile)\n", + " 123 0.000 0.000 0.029 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1192(dataclass)\n", + " 8780 0.003 0.000 0.029 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/package/package_importer.py:692(_patched_getfile)\n", + " 383/189 0.001 0.000 0.029 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:447(_parse_sub)\n", + " 553/192 0.011 0.000 0.028 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:507(_parse)\n", + " 2 0.000 0.000 0.028 0.014 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1198(_gen_axes_spines)\n", + " 2 0.000 0.000 0.028 0.014 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1213()\n", + " 8 0.000 0.000 0.028 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:432(linear_spine)\n", + " 8 0.000 0.000 0.028 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:35(__init__)\n", + " 233 0.000 0.000 0.028 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:340(_set_facecolor)\n", + " 127 0.000 0.000 0.028 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:347(set_facecolor)\n", + " 7764 0.001 0.000 0.028 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:961(getabsfile)\n", + " 28 0.028 0.001 0.028 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:364(by_key)\n", + " 1 0.000 0.000 0.027 0.027 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/__init__.py:1()\n", + " 1 0.000 0.000 0.027 0.027 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1()\n", + " 10 0.000 0.000 0.027 0.003 :1231(create_module)\n", + " 10 0.027 0.003 0.027 0.003 {built-in method _imp.create_dynamic}\n", + " 106 0.001 0.000 0.027 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:2389(_update_patch_limits)\n", + " 1 0.000 0.000 0.026 0.026 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/axes3d.py:1()\n", + " 1 0.000 0.000 0.026 0.026 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1()\n", + " 244 0.000 0.000 0.026 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2138(__call__)\n", + " 1000 0.002 0.000 0.025 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/adam.py:254(adam)\n", + " 1 0.000 0.000 0.025 0.025 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:1()\n", + " 19 0.000 0.000 0.025 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/skipfiles.py:190(add)\n", + " 5 0.000 0.000 0.024 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/skipfiles.py:185(_recompile_re)\n", + " 8780 0.011 0.000 0.024 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:896(getfile)\n", + " 223 0.008 0.000 0.024 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1517(get_setters)\n", + " 122 0.000 0.000 0.024 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1606(get_major_ticks)\n", + " 244 0.000 0.000 0.024 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2142(tick_values)\n", + " 234 0.001 0.000 0.023 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:530(_draw_paths_with_artist_properties)\n", + " 121853 0.015 0.000 0.023 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:183()\n", + " 5768 0.002 0.000 0.022 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/__init__.py:173(search)\n", + " 37 0.000 0.000 0.022 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1555(_get_tick)\n", + " 900 0.001 0.000 0.022 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:65(_get_text_metrics_with_cache)\n", + " 10 0.000 0.000 0.022 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2358(_update_label_position)\n", + " 244 0.003 0.000 0.022 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2077(_raw_ticks)\n", + " 9 0.000 0.000 0.022 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:729(__init_subclass__)\n", + " 388 0.002 0.000 0.021 0.000 :1056(_find_spec)\n", + " 455 0.001 0.000 0.021 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:413(_create_fn)\n", + " 1001 0.001 0.000 0.021 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/decorators.py:33(disable)\n", + " 597 0.001 0.000 0.020 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:259(get_transform)\n", + " 1000 0.008 0.000 0.020 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/adam.py:330(_single_tensor_adam)\n", + " 142 0.000 0.000 0.020 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:95(draw_path)\n", + " 50 0.000 0.000 0.020 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:287(draw)\n", + " 142 0.017 0.000 0.019 0.000 {method 'draw_path' of 'matplotlib.backends._backend_agg.RendererAgg' objects}\n", + " 1 0.000 0.000 0.019 0.019 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_fontconfig_pattern.py:1()\n", + "281051/281043 0.016 0.000 0.019 0.000 {built-in method builtins.isinstance}\n", + " 1 0.000 0.000 0.019 0.019 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/__init__.py:1()\n", + " 122 0.001 0.000 0.019 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1497(get_minorticklocs)\n", + "6348/5165 0.002 0.000 0.018 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:289(wrapper)\n", + " 519 0.002 0.000 0.018 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:746(get_patch_transform)\n", + " 388 0.000 0.000 0.018 0.000 :1496(find_spec)\n", + " 388 0.001 0.000 0.018 0.000 :1464(_get_spec)\n", + " 1001 0.003 0.000 0.018 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:267(__call__)\n", + " 742 0.000 0.000 0.017 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3277(signature)\n", + " 742 0.000 0.000 0.017 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3023(from_callable)\n", + " 865/742 0.002 0.000 0.017 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2426(_signature_from_callable)\n", + " 4 0.015 0.004 0.017 0.004 /Users/vrajpandya/repo/intern_challenge/placement.py:470(calculate_overlap_metrics)\n", + " 37 0.001 0.000 0.016 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:65(__init__)\n", + " 136 0.000 0.000 0.016 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:38(__call__)\n", + " 499 0.002 0.000 0.016 0.000 :1604(find_spec)\n", + " 30 0.005 0.000 0.016 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:847(_rc_params_in_file)\n", + " 126/115 0.000 0.000 0.016 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:79(__call__)\n", + " 106981 0.010 0.000 0.015 0.000 {built-in method builtins.getattr}\n", + " 1001 0.002 0.000 0.015 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:307(_fn)\n", + " 2 0.000 0.000 0.015 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1381(clear)\n", + " 2 0.000 0.000 0.015 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1254(__clear)\n", + " 219049 0.015 0.000 0.015 0.000 {method 'startswith' of 'str' objects}\n", + " 1148 0.001 0.000 0.014 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1472(transform)\n", + " 1 0.000 0.000 0.013 0.013 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/style/__init__.py:1()\n", + " 1 0.000 0.000 0.013 0.013 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:1()\n", + " 122 0.000 0.000 0.013 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1493(get_majorticklocs)\n", + " 1 0.000 0.000 0.013 0.013 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/style/core.py:1()\n", + "2598/1427 0.004 0.000 0.013 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2431(get_affine)\n", + " 12 0.000 0.000 0.013 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:51(__missing__)\n", + " 223 0.008 0.000 0.013 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1453()\n", + " 1 0.000 0.000 0.012 0.012 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/output_graph.py:1()\n", + " 133 0.000 0.000 0.012 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:651(union)\n", + " 189 0.000 0.000 0.012 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:571(_code)\n", + " 1 0.000 0.000 0.012 0.012 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2645(__init__)\n", + " 1 0.011 0.011 0.011 0.011 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:120(__init__)\n", + " 128 0.001 0.000 0.011 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:734(draw)\n", + " 19 0.000 0.000 0.011 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:412(__init__)\n", + " 2 0.000 0.000 0.011 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/style/core.py:206(read_style_directory)\n", + " 123 0.000 0.000 0.011 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:600(get_window_extent)\n", + " 456 0.011 0.000 0.011 0.000 {built-in method builtins.dir}\n", + " 1 0.000 0.000 0.011 0.011 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_axes.py:46(Axes)\n", + " 18 0.000 0.000 0.011 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:469(__init__)\n", + " 39 0.000 0.000 0.011 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:73(_get_text_metrics_with_cache_impl)\n", + " 39 0.000 0.000 0.011 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:208(get_text_width_height_descent)\n", + " 9940 0.010 0.000 0.010 0.000 {method 'search' of 're.Pattern' objects}\n", + " 244 0.000 0.000 0.010 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:213(format_ticks)\n", + " 1 0.000 0.000 0.010 0.010 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:1()\n", + " 123 0.001 0.000 0.010 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:528(_init_fn)\n", + " 804 0.002 0.000 0.010 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1176(_update_props)\n", + " 1059/189 0.005 0.000 0.010 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:37(_compile)\n", + " 1148 0.001 0.000 0.010 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2406(transform_affine)\n", + " 1000 0.003 0.000 0.010 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:776(zero_grad)\n", + " 150 0.001 0.000 0.010 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:738(draw)\n", + " 350 0.009 0.000 0.009 0.000 {built-in method io.open_code}\n", + " 695 0.003 0.000 0.009 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2331(_signature_from_function)\n", + " 1 0.000 0.000 0.009 0.009 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:1()\n", + " 6334 0.005 0.000 0.009 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2683(__init__)\n", + " 260 0.000 0.000 0.009 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:225(__init__)\n", + " 4698 0.003 0.000 0.009 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:69(_wrapreduction)\n", + " 72 0.000 0.000 0.009 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1233(findfont)\n", + " 714 0.000 0.000 0.009 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1212(_internal_update)\n", + " 25 0.000 0.000 0.009 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1576(_copy_tick_props)\n", + " 260 0.000 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:306(_set_marker)\n", + " 1 0.000 0.000 0.008 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/__init__.py:1()\n", + " 1 0.000 0.000 0.008 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:1()\n", + " 1 0.000 0.000 0.008 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1()\n", + " 5085 0.004 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copy.py:66(copy)\n", + " 152 0.001 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2757(get_tick_space)\n", + " 9669 0.008 0.000 0.008 0.000 {method 'reduce' of 'numpy.ufunc' objects}\n", + " 350 0.001 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1418(__sub__)\n", + " 75 0.000 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1336(update_from)\n", + " 519 0.000 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:880(get_bbox)\n", + " 68 0.000 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:250(_prepare_font)\n", + " 2 0.002 0.001 0.008 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1393(_findfont_cached)\n", + " 492 0.000 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:147()\n", + " 2722 0.001 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1340(__add__)\n", + " 123 0.001 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:607(get_extents)\n", + " 1 0.000 0.000 0.008 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:1()\n", + " 8 0.000 0.000 0.008 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:4306(get_default_bbox_extra_artists)\n", + " 1000 0.001 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_contextlib.py:112(decorate_context)\n", + " 976 0.001 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:711(__setitem__)\n", + " 1 0.000 0.000 0.008 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:439(_warn_if_gui_out_of_main_thread)\n", + " 3 0.000 0.000 0.008 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:270(_get_backend_mod)\n", + " 1 0.000 0.000 0.008 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/guards.py:1()\n", + " 2/1 0.000 0.000 0.008 0.008 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:284(switch_backend)\n", + " 492 0.000 0.000 0.008 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1223(set)\n", + " 8 0.000 0.000 0.008 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:4335()\n", + " 111 0.001 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:287(__init__)\n", + " 122 0.000 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:699(set_locs)\n", + " 12751 0.004 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:741(__getitem__)\n", + "5559/5339 0.001 0.000 0.007 0.000 {built-in method builtins.next}\n", + " 1 0.000 0.000 0.007 0.007 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1()\n", + " 1 0.000 0.000 0.007 0.007 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_code_flow.py:1()\n", + " 464 0.001 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:860(_fully_clipped_to_axes)\n", + " 1294 0.001 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1106(get_points)\n", + " 2000 0.001 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/profiler.py:630(__enter__)\n", + " 36 0.000 0.000 0.007 0.000 :1655(_fill_cache)\n", + " 4675/75 0.003 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copy.py:128(deepcopy)\n", + " 12/8 0.000 0.000 0.007 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:575(__get__)\n", + "4816/4734 0.004 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:773(is_safe_constant)\n", + " 300/75 0.001 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copy.py:227(_deepcopy_dict)\n", + " 437 0.000 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1536(number_of_parameters)\n", + " 94 0.000 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:1391(_preprocess_data)\n", + " 2722 0.001 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2498(composite_transform_factory)\n", + " 36 0.007 0.000 0.007 0.000 {built-in method posix.listdir}\n", + " 20 0.000 0.000 0.007 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:944(set_tick_params)\n", + " 1 0.000 0.000 0.006 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1()\n", + " 1 0.000 0.000 0.006 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:240(_check_versions)\n", + " 1 0.000 0.000 0.006 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:1()\n", + " 2436 0.006 0.000 0.006 0.000 {built-in method posix.stat}\n", + " 1047 0.001 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:813(from_extents)\n", + " 1 0.000 0.000 0.006 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_thread_flow.py:1()\n", + " 1 0.000 0.000 0.006 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_caffe2.py:1()\n", + " 954 0.000 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1542(is_alias)\n", + " 1913 0.001 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:51(_wrapfunc)\n", + "16691/13889 0.003 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:317(stale)\n", + " 32774 0.005 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:283(ismodule)\n", + " 1 0.000 0.000 0.006 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:1()\n", + " 1 0.000 0.000 0.006 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:1()\n", + " 1 0.000 0.000 0.006 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:1()\n", + " 2257 0.004 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:35(update_wrapper)\n", + "155602/154398 0.006 0.000 0.006 0.000 {built-in method builtins.len}\n", + " 1 0.000 0.000 0.006 0.006 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/__init__.py:1()\n", + " 134 0.000 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:772(set_clip_path)\n", + " 2834 0.004 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:638(__hash__)\n", + " 626 0.001 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:508(update_position)\n", + "2760/2701 0.001 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:338(inner)\n", + " 105 0.001 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:170()\n", + " 6 0.000 0.000 0.006 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3157(grid)\n", + " 1908 0.002 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copy.py:259(_reconstruct)\n", + " 12 0.000 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1658(grid)\n", + " 1938 0.001 0.000 0.006 0.000 <__array_function__ internals>:177(amin)\n", + " 2000 0.000 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_ops.py:687(__call__)\n", + " 1962 0.001 0.000 0.006 0.000 <__array_function__ internals>:177(amax)\n", + " 1 0.006 0.006 0.006 0.006 {built-in method set_icon}\n", + " 28626 0.004 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:162(__getitem__)\n", + " 123 0.000 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:624(_cmp_fn)\n", + " 106 0.000 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1400(contains_branch_seperately)\n", + " 88 0.000 0.000 0.006 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:104(__init__)\n", + "2488/2433 0.001 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:132(__enter__)\n", + " 106 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1381(contains_branch)\n", + " 1 0.000 0.000 0.005 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_thread_flow_location.py:1()\n", + " 2000 0.005 0.000 0.005 0.000 {built-in method torch._ops.profiler._record_function_enter_new}\n", + " 3798 0.002 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1889(__init__)\n", + " 68 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1303(_find_fonts_by_props)\n", + " 123 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:588(_repr_fn)\n", + " 1 0.000 0.000 0.005 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_conversion.py:1()\n", + "17646/17633 0.004 0.000 0.005 0.000 {method 'join' of 'str' objects}\n", + " 15237 0.002 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:252(get)\n", + " 732 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2265(getter)\n", + " 2513 0.003 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:758(__init__)\n", + " 1118 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:899(copy)\n", + " 4 0.000 0.000 0.005 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:882(clear)\n", + " 1 0.000 0.000 0.005 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/axis3d.py:1()\n", + " 54891 0.005 0.000 0.005 0.000 {built-in method builtins.min}\n", + "5790/5337 0.002 0.000 0.005 0.000 {built-in method __new__ of type object at 0x1057ebd60}\n", + " 1 0.000 0.000 0.005 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1()\n", + " 1 0.000 0.000 0.005 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builtin.py:1()\n", + " 2000 0.002 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/profiler.py:636(__exit__)\n", + " 109 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:694(__init__)\n", + " 92 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2514(get_tick_space)\n", + " 848 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:374(extents)\n", + " 628 0.001 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:738(_convert_units)\n", + " 36 0.001 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:488(__new__)\n", + "1576/1574 0.002 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1777(__eq__)\n", + " 1 0.000 0.000 0.005 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/category.py:1()\n", + " 2220 0.002 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2348(__init__)\n", + " 68 0.005 0.000 0.005 0.000 {method 'set_text' of 'matplotlib.ft2font.FT2Font' objects}\n", + " 4252 0.002 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1555(aliased_name)\n", + " 1 0.000 0.000 0.005 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/textpath.py:1()\n", + " 842 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:847(viewLim)\n", + " 1 0.000 0.000 0.005 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_properties.py:1()\n", + " 1 0.000 0.000 0.005 0.005 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/quiver.py:1()\n", + " 931 0.000 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:649(__eq__)\n", + " 1938 0.001 0.000 0.005 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2829(amin)\n", + " 4 0.000 0.000 0.005 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:794(_set_scale)\n", + " 4 0.000 0.000 0.004 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:103(set_default_locators_and_formatters)\n", + " 1908/848 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2391(_iter_break_from_left_to_right)\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:489(InstructionTranslatorBase)\n", + " 1026 0.003 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2969(__init__)\n", + " 1303 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:38(_wrapit)\n", + "5281/3214 0.001 0.000 0.004 0.000 {built-in method builtins.hash}\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/__init__.py:1()\n", + " 43052 0.004 0.000 0.004 0.000 {built-in method builtins.hasattr}\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/__init__.py:1()\n", + " 1962 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2703(amax)\n", + " 846 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:833(_unstale_viewLim)\n", + " 2000 0.002 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_foreach_utils.py:46(_has_foreach_support)\n", + " 33 0.000 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:162(stack_op)\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ExifTags.py:1()\n", + " 636 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:413(iter_bezier)\n", + " 137 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:666(recache)\n", + " 1 0.004 0.004 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:39(__init__)\n", + " 636 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:723(_get_field)\n", + " 362 0.001 0.000 0.004 0.000 :493(_init_module_attrs)\n", + " 4 0.000 0.000 0.004 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:425(__init__)\n", + " 4 0.000 0.000 0.004 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:537(set_useMathText)\n", + " 8861 0.003 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:691(__call__)\n", + " 1000 0.000 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_tensor.py:34(wrapped)\n", + " 1 0.000 0.000 0.004 0.004 /Users/vrajpandya/repo/intern_challenge/placement.py:586(calculate_normalized_metrics)\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/ElementTree.py:1()\n", + " 2001 0.004 0.000 0.004 0.000 {built-in method torch.stack}\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cm.py:1()\n", + " 76922 0.004 0.000 0.004 0.000 {method 'lstrip' of 'str' objects}\n", + " 410 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:447(update_position)\n", + " 1 0.004 0.004 0.004 0.004 /Users/vrajpandya/repo/intern_challenge/placement.py:541(calculate_cells_with_overlaps)\n", + " 2123 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1782(transform)\n", + " 1490/642 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2384(__eq__)\n", + " 7104 0.003 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1769(__init__)\n", + " 1000 0.004 0.000 0.004 0.000 {built-in method torch._foreach_norm}\n", + " 48 0.000 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:1347(_add_data_doc)\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/helpers.py:1()\n", + " 341 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:595(__init__)\n", + "2488/2433 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:141(__exit__)\n", + " 109 0.004 0.000 0.004 0.000 {built-in method torch.rand}\n", + " 1404 0.000 0.000 0.004 0.000 :140(_path_stat)\n", + " 84433 0.004 0.000 0.004 0.000 {method 'append' of 'list' objects}\n", + " 256 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:463(transformed)\n", + " 1047 0.000 0.000 0.004 0.000 <__array_function__ internals>:177(reshape)\n", + " 1478 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:103(_stale_axes_callback)\n", + " 13069 0.003 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:690(_get)\n", + " 122 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:781(_set_format)\n", + " 122 0.000 0.000 0.004 0.000 <__array_function__ internals>:177(isclose)\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:321(preinit)\n", + " 1231/365 0.003 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:172(getwidth)\n", + " 846 0.001 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:836()\n", + " 522 0.000 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:804(from_bounds)\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1()\n", + " 18314 0.003 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:292(isclass)\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:1()\n", + " 244 0.000 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1564(_get_tick_label_size)\n", + " 1 0.000 0.000 0.004 0.004 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/common.py:1()\n", + " 122 0.000 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/numeric.py:2278(isclose)\n", + " 4 0.000 0.000 0.004 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1108(set_clip_path)\n", + " 1000 0.003 0.000 0.004 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_tensor.py:911(__rdiv__)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/__init__.py:1()\n", + " 3 0.000 0.000 0.003 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:393(get_renderer)\n", + " 3 0.003 0.001 0.003 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:64(__init__)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/common.py:8(pyparsing_common)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1()\n", + " 4 0.000 0.000 0.003 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/torch_version.py:87()\n", + " 4 0.000 0.000 0.003 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/torch_version.py:75(_cmp_wrapper)\n", + " 18 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:799(validate_cycler)\n", + " 55889 0.003 0.000 0.003 0.000 {method 'get' of 'dict' objects}\n", + " 96 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:157(_reset_visual_defaults)\n", + " 700 0.001 0.000 0.003 0.000 :437(cache_from_source)\n", + " 2100 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1291(set_ydata)\n", + " 8 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/torch_version.py:31(__call__)\n", + " 16 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/torch_version.py:22(get_cls)\n", + " 1006 0.000 0.000 0.003 0.000 :16(exists)\n", + " 959 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1998(rotate_deg)\n", + " 29 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:187(draw_text)\n", + " 244 0.000 0.000 0.003 0.000 <__array_function__ internals>:177(clip)\n", + " 3091 0.003 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:182(set_children)\n", + " 2548 0.002 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:2011(_setattr_cm)\n", + " 5120 0.001 0.000 0.003 0.000 :117(__instancecheck__)\n", + " 2002 0.003 0.000 0.003 0.000 {built-in method torch.abs}\n", + "4452/4450 0.001 0.000 0.003 0.000 {built-in method builtins.all}\n", + " 2/1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_jit_internal.py:478(fn)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/functional.py:970(_return_output)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/functional.py:740(_unique_impl)\n", + " 1 0.003 0.003 0.003 0.003 {built-in method unique_dim}\n", + " 10655 0.003 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:400(istype)\n", + " 1470 0.002 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:664(_is_type)\n", + " 9282 0.003 0.000 0.003 0.000 {method 'split' of 'str' objects}\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1()\n", + " 16172 0.003 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:231(__next)\n", + " 2846 0.001 0.000 0.003 0.000 :126(_path_join)\n", + " 453 0.002 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:237(__set_name__)\n", + " 1003 0.003 0.000 0.003 0.000 {built-in method torch.tensor}\n", + " 244 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2111(clip)\n", + " 3314 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:158(invalidate)\n", + " 6 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:220(extract_stack)\n", + " 1000 0.001 0.000 0.003 0.000 /Users/vrajpandya/repo/intern_challenge/placement.py:308(overlap_repulsion_loss)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/common.py:1()\n", + " 6 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:375(extract)\n", + " 2246 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1849(transform_affine)\n", + " 123 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1593(transform_path)\n", + " 6 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:397(_extract_from_extended_frame_gen)\n", + " 3 0.000 0.000 0.003 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2211(__init_subclass__)\n", + " 1906 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:416(pchanged)\n", + " 530 0.002 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/bezier.py:208(__call__)\n", + " 6 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2253(pprint_styles)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:92(_disallowed_function_ids)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:1728(get_default_bbox_extra_artists)\n", + " 1604 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1758(convert_units)\n", + " 1047 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:198(reshape)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/table.py:1()\n", + " 760 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:302(xmin)\n", + " 244 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:216()\n", + " 83 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:316(line)\n", + " 1000 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:109(_default_to_fused_or_foreach)\n", + " 810 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:317(ymax)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result.py:1()\n", + " 394 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:99(__init__)\n", + " 21 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/linecache.py:26(getline)\n", + " 176 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:94(closegroup)\n", + " 21 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/linecache.py:36(getlines)\n", + " 1000 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/__init__.py:56(_make_grads)\n", + " 1000 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_foreach_utils.py:34(_group_tensors_by_device_and_dtype)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:1()\n", + " 11 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/linecache.py:80(updatecache)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool.py:1()\n", + " 2598 0.001 0.000 0.003 0.000 <__array_function__ internals>:177(dot)\n", + " 165/106 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:461(__getitem__)\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cm.py:32(_gen_cmap_registry)\n", + " 33 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2315(_signature_from_builtin)\n", + " 1885 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:269(convert_xunits)\n", + " 13322 0.002 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:170(append)\n", + " 2489 0.001 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:287(helper)\n", + " 790 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:307(ymin)\n", + " 959 0.002 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1975(rotate)\n", + " 33 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2172(_signature_fromstr)\n", + " 760 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:312(xmax)\n", + " 12 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1076(parse_string)\n", + " 18136 0.002 0.000 0.003 0.000 {built-in method builtins.max}\n", + " 6 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2257()\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend.py:1()\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact.py:1()\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:1()\n", + " 1 0.000 0.000 0.003 0.003 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1()\n", + " 131 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:239(__array__)\n", + " 1000 0.002 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/adam.py:80(_init_group)\n", + " 424 0.000 0.000 0.003 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1710(__eq__)\n", + " 133 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:656()\n", + " 4000 0.002 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/grad_mode.py:182(__init__)\n", + " 123 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1602(transform_path_affine)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_secondary_axes.py:1()\n", + " 61 0.000 0.000 0.002 0.000 <__array_function__ internals>:177(isin)\n", + " 15841 0.002 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:176()\n", + " 44125 0.002 0.000 0.002 0.000 {built-in method builtins.id}\n", + " 1604 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/units.py:56(_is_natively_supported)\n", + " 243 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1333(__init__)\n", + " 9181 0.002 0.000 0.002 0.000 {method 'copy' of 'numpy.ndarray' objects}\n", + " 61 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:766(isin)\n", + " 424 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2162(__eq__)\n", + " 1921 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:285(process)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:1()\n", + " 710 0.000 0.000 0.002 0.000 :392(cached)\n", + " 999 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:572(__call__)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_helper.py:1()\n", + " 530 0.002 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/bezier.py:199(__init__)\n", + " 1883 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:281(convert_yunits)\n", + " 61 0.000 0.000 0.002 0.000 <__array_function__ internals>:177(in1d)\n", + " 1452 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1270(set_xdata)\n", + " 5120 0.001 0.000 0.002 0.000 {built-in method _abc._abc_instancecheck}\n", + " 133 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:657()\n", + " 582 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1743(normalize_kwargs)\n", + " 1324 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:68(_stale_figure_callback)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run.py:1()\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:1()\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool_component.py:1()\n", + " 2000 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_ops.py:447(__call__)\n", + " 244 0.000 0.000 0.002 0.000 {method 'clip' of 'numpy.ndarray' objects}\n", + " 388 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:690(new_gc)\n", + " 12104 0.002 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:113(__init__)\n", + " 61 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:524(in1d)\n", + " 15818 0.002 0.000 0.002 0.000 {built-in method builtins.setattr}\n", + " 105 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:638(Union)\n", + " 133 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:658()\n", + " 45 0.001 0.000 0.002 0.000 {built-in method builtins.eval}\n", + " 582 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:356(__setitem__)\n", + " 133 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:659()\n", + " 68 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1525(get_font)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:1()\n", + " 1001 0.002 0.000 0.002 0.000 {built-in method torch.sum}\n", + " 244 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:127(_clip)\n", + " 1745 0.002 0.000 0.002 0.000 {built-in method torch.randint}\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/mathtext.py:1()\n", + " 360 0.000 0.000 0.002 0.000 :567(_get_cached)\n", + " 388 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:766(__init__)\n", + " 122 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/numeric.py:2359(within_tol)\n", + " 13 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:401(validate_font_properties)\n", + " 10 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_fontconfig_pattern.py:80(parse_fontconfig_pattern)\n", + " 1581 0.000 0.000 0.002 0.000 {method 'all' of 'numpy.ndarray' objects}\n", + " 668 0.000 0.000 0.002 0.000 <__array_function__ internals>:177(all)\n", + " 631 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:221(is_color_like)\n", + " 7289 0.002 0.000 0.002 0.000 {method 'expandtabs' of 'str' objects}\n", + " 5903 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/function_base.py:346(iterable)\n", + " 90 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:194(update)\n", + " 28 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:599(_frozen_get_del_attr)\n", + " 10878 0.002 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:378(isfunction)\n", + " 790 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1115(score_family)\n", + " 549 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:168(_type_check)\n", + " 409 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:307(validate_color)\n", + " 2000 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/profiler.py:619(__init__)\n", + " 110 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1229(_cm_set)\n", + " 1167 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2043(scale)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/parsers/expat.py:1()\n", + " 7583 0.002 0.000 0.002 0.000 {built-in method numpy.asarray}\n", + " 1 0.002 0.002 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1493(_get_font)\n", + " 571 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:296(wrapper)\n", + " 1634 0.000 0.000 0.002 0.000 {method 'max' of 'numpy.ndarray' objects}\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_invocation.py:1()\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/onnxruntime.py:1()\n", + " 306/12 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:776(_parseNoCache)\n", + "4747/3314 0.002 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:167(_invalidate_internal)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/kiwisolver/__init__.py:1()\n", + " 4284 0.002 0.000 0.002 0.000 {built-in method numpy.array}\n", + " 72/12 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3861(parseImpl)\n", + " 6510 0.002 0.000 0.002 0.000 {method 'item' of 'torch._C._TensorBase' objects}\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/__init__.py:1()\n", + "2195/2193 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2592(get_matrix)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/dicts.py:1()\n", + " 1000 0.002 0.000 0.002 0.000 {method 'mul_' of 'torch._C._TensorBase' objects}\n", + " 122 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:708(_compute_offset)\n", + " 189 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:509(_compile_info)\n", + " 3003 0.002 0.000 0.002 0.000 {method 'long' of 'torch._C._TensorBase' objects}\n", + " 53 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:662(intersection)\n", + " 111 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:88(f)\n", + " 1000 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_contextlib.py:141(clone)\n", + " 2489 0.002 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:104(__init__)\n", + " 9 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5392(__init__)\n", + " 1768 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:909(get_siblings)\n", + " 2000 0.002 0.000 0.002 0.000 {built-in method torch._ops.profiler.}\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location.py:1()\n", + " 371 0.000 0.000 0.002 0.000 :169(__enter__)\n", + " 360 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:180(__init__)\n", + " 29/8 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4379(leave_whitespace)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/fft.py:1()\n", + " 2000/493 0.000 0.000 0.002 0.000 :121(__subclasscheck__)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1564(_load_fontmanager)\n", + " 1000 0.002 0.000 0.002 0.000 {built-in method torch.clamp}\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/exceptions.py:1()\n", + " 8821 0.002 0.000 0.002 0.000 {method 'format' of 'str' objects}\n", + " 1141 0.000 0.000 0.002 0.000 {method 'min' of 'numpy.ndarray' objects}\n", + " 8765 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:456(istraceback)\n", + " 9122 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:300(ismethod)\n", + " 1000 0.002 0.000 0.002 0.000 {method 'addcmul_' of 'torch._C._TensorBase' objects}\n", + " 1000 0.002 0.000 0.002 0.000 {method 'add_' of 'torch._C._TensorBase' objects}\n", + " 1000 0.002 0.000 0.002 0.000 {built-in method torch._foreach_mul_}\n", + " 1581 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:61(_all)\n", + " 2674 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:405(_strip_comment)\n", + " 106 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:2491(update_datalim)\n", + " 32 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1036(from_list)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_tricontour.py:1()\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_address.py:1()\n", + " 75 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:279(__deepcopy__)\n", + " 482 0.000 0.000 0.002 0.000 :159(_path_isfile)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:970(json_load)\n", + " 409 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:499(copy)\n", + " 2000/493 0.001 0.000 0.002 0.000 {built-in method _abc._abc_subclasscheck}\n", + " 1004 0.002 0.000 0.002 0.000 {method 'clone' of 'torch._C._TensorBase' objects}\n", + " 36 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:347(_apply_params)\n", + " 122 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:747(_set_order_of_magnitude)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/json/__init__.py:274(load)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:157(Version)\n", + " 8765 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:480(iscode)\n", + " 519 0.000 0.000 0.002 0.000 :150(_path_is_mode_type)\n", + " 309 0.000 0.000 0.002 0.000 <__array_function__ internals>:177(column_stack)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/JpegImagePlugin.py:1()\n", + " 28 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:182(_collapse_string_to_ranges)\n", + " 11 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2815(__new__)\n", + " 366 0.000 0.000 0.002 0.000 <__array_function__ internals>:177(round_)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/__init__.py:1()\n", + " 1634 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:39(_amax)\n", + " 4698 0.002 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:70()\n", + " 668 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2432(all)\n", + " 8765 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:466(isframe)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_funcs.py:1()\n", + " 7 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/tokenize.py:392(open)\n", + " 1000 0.002 0.000 0.002 0.000 {method 'lerp_' of 'torch._C._TensorBase' objects}\n", + " 2846 0.001 0.000 0.002 0.000 :128()\n", + " 1001 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:442(__init__)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2752(_get_renderer)\n", + " 59 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:678(Optional)\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1()\n", + " 999 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:514(_format_maybe_minus_and_locale)\n", + " 1329 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:966(_auto_draw_if_interactive)\n", + " 386 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:626(translated)\n", + " 8 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2678(__init__)\n", + " 3764 0.001 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:99(check_in_list)\n", + " 2 0.002 0.001 0.002 0.001 {method 'sum' of 'torch._C._TensorBase' objects}\n", + " 1 0.000 0.000 0.002 0.002 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:1()\n", + " 96 0.000 0.000 0.002 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1303(set_fontproperties)\n", + " 27 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/collections/__init__.py:348(namedtuple)\n", + " 90 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1201(update)\n", + " 241 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:279(validate_color_for_prop_cycle)\n", + " 2513 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:216(_is_nth_color)\n", + " 35 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:107()\n", + " 1141 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:43(_amin)\n", + " 790 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1191(score_weight)\n", + " 252 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2817(nonsingular)\n", + " 55/8 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3635(leave_whitespace)\n", + " 40 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/tokenize.py:299(detect_encoding)\n", + " 999 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2897(_interval_contains_close)\n", + " 1000 0.001 0.000 0.001 0.000 {built-in method torch._C._linalg.linalg_vector_norm}\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/html/__init__.py:1()\n", + " 488 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:93(_clip_dep_is_scalar_nan)\n", + " 118 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3231(__str__)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/context.py:1()\n", + " 5578 0.001 0.000 0.001 0.000 {method 'match' of 're.Pattern' objects}\n", + " 790 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1173(score_stretch)\n", + " 882 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:64(check_isinstance)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/tensor.py:1()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_change.py:1()\n", + " 1000 0.001 0.000 0.001 0.000 {built-in method torch._C._group_tensors_by_device_and_dtype}\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/replay_record.py:1()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:1()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/__init__.py:1()\n", + " 1000 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/grad_mode.py:78(__enter__)\n", + " 11 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2795(_make_nmtuple)\n", + " 5 0.001 0.000 0.001 0.000 {built-in method torch.sqrt}\n", + " 114/57 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3722(copy)\n", + " 1761 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1277(__setattr__)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/axes3d.py:42(Axes3D)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/_functional_collectives.py:1()\n", + " 36071 0.001 0.000 0.001 0.000 {built-in method builtins.callable}\n", + " 137 0.000 0.000 0.001 0.000 <__array_function__ internals>:177(broadcast_arrays)\n", + " 584 0.001 0.000 0.001 0.000 :179(_get_module_lock)\n", + " 18 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:662(cycler)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset11.py:1()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/json/__init__.py:299(loads)\n", + " 356 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:786(_finddoc)\n", + " 3 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:592(getmembers)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/json/decoder.py:332(decode)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/json/decoder.py:343(raw_decode)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builder.py:1()\n", + " 3 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:550(_getmembers)\n", + " 366 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3754(round_)\n", + " 42 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/tokenize.py:323(read_or_stop)\n", + " 14 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:595(set_parse_action)\n", + " 1038 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2030(translate)\n", + " 19434 0.001 0.000 0.001 0.000 {method 'items' of 'dict' objects}\n", + " 9 0.001 0.000 0.001 0.000 {method 'readline' of '_io.BufferedReader' objects}\n", + " 394 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:794(unit)\n", + " 123 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1800(transform_path_affine)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1619(_get_renderer)\n", + " 33 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2100(_signature_strip_non_python_syntax)\n", + " 388 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:923(_set_gc_clip)\n", + " 309 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/shape_base.py:612(column_stack)\n", + " 39 0.001 0.000 0.001 0.000 {built-in method io.open}\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5798()\n", + " 10 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2398(_update_offset_text_position)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/random.py:26(manual_seed)\n", + " 1332 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:1285(is_interactive)\n", + " 1149 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:786(get_transform)\n", + " 99/33 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:95(__call__)\n", + " 137 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/stride_tricks.py:480(broadcast_arrays)\n", + " 1000 0.001 0.000 0.001 0.000 {method 'addcdiv_' of 'torch._C._TensorBase' objects}\n", + " 4811 0.001 0.000 0.001 0.000 {built-in method builtins.sorted}\n", + " 363 0.000 0.000 0.001 0.000 :1599(_get_spec)\n", + " 18 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:262(_trim_arity)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:609(_ensure_mutable)\n", + " 98 0.000 0.000 0.001 0.000 :105(__new__)\n", + " 14 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:675()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:603(_copy)\n", + " 37 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1029(get_path)\n", + " 8859 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1096(__new__)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_functorch/deprecated.py:1()\n", + " 1 0.001 0.001 0.001 0.001 {method 'copy' of 'ImagingCore' objects}\n", + " 366 0.000 0.000 0.001 0.000 <__array_function__ internals>:177(around)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:1()\n", + " 518 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1279(_preprocess_math)\n", + " 106 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:930(update_from_data_xy)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/cuda/random.py:109(manual_seed_all)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/cuda/__init__.py:227(_lazy_call)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:213(format_stack)\n", + " 19 0.000 0.000 0.001 0.000 :73(find_spec)\n", + " 99/33 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:346(__post_init__)\n", + " 700 0.000 0.000 0.001 0.000 :132(_path_split)\n", + "3360/2126 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2398()\n", + " 22 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4779(parseImpl)\n", + " 12 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:237(set_clip_path)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_ndarray.py:1()\n", + " 860 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:735(unwrap)\n", + " 7 0.001 0.000 0.001 0.000 {method 'readlines' of '_io._IOBase' objects}\n", + " 462 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:890(get_unitless_position)\n", + "4867/4697 0.001 0.000 0.001 0.000 {method 'update' of 'dict' objects}\n", + " 396/33 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:141(apply)\n", + " 1 0.001 0.001 0.001 0.001 {built-in method torch.full}\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/api.py:1()\n", + " 1060 0.001 0.000 0.001 0.000 {method 'outer' of 'numpy.ufunc' objects}\n", + " 636 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:347(iter_segments)\n", + " 114/57 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3724()\n", + " 67 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:128(deprecate)\n", + " 999 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:245(fix_minus)\n", + " 571 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:213(register)\n", + " 1000 0.001 0.000 0.001 0.000 {method 'sqrt' of 'torch._C._TensorBase' objects}\n", + " 13070 0.001 0.000 0.001 0.000 {function RcParams.__getitem__ at 0x13d5fd440}\n", + " 1000 0.001 0.000 0.001 0.000 {built-in method torch.ones_like}\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:1()\n", + " 522 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2576(__init__)\n", + " 102 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1540(copy_with)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ExifTags.py:20(Base)\n", + " 2 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:810(_init_axis)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_transformation.py:1()\n", + " 4345 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:198()\n", + " 2248 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1355(_iter_break_from_left_to_right)\n", + " 1151 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/__init__.py:163(match)\n", + " 1271 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:115(get_transform)\n", + " 3 0.001 0.000 0.001 0.000 {built-in method torch.cat}\n", + " 1001 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:221(__init__)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/jit_utils.py:1()\n", + " 55 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3643()\n", + " 61 0.000 0.000 0.001 0.000 <__array_function__ internals>:177(intersect1d)\n", + " 118 0.001 0.000 0.001 0.000 {built-in method builtins.compile}\n", + " 175 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:310(_to_rgba_no_colorcycle)\n", + " 60 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1531(__getitem__)\n", + " 2246 0.001 0.000 0.001 0.000 {built-in method matplotlib._path.affine_transform}\n", + " 3000 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_foreach_utils.py:8(_get_foreach_kernels_supported_devices)\n", + " 388 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:934(set_clip_path)\n", + " 288 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_normalizations.py:189(normalizer)\n", + " 1148 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2411(transform_non_affine)\n", + " 2 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5684(srange)\n", + " 1000 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:84(_get_value)\n", + " 60 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:829(_open_file_or_url)\n", + " 394 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:132(check_shape)\n", + " 16 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:292(draw)\n", + " 193 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3039(replace)\n", + " 12 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1871(apply_aspect)\n", + " 266/157 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1857(name)\n", + " 536 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:368(bounds)\n", + " 166 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:615(_from_any)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:1()\n", + " 546 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/__init__.py:178(sub)\n", + " 61 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:373(intersect1d)\n", + " 1000 0.001 0.000 0.001 0.000 {method 'reciprocal' of 'torch._C._TensorBase' objects}\n", + " 1000 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:97(_dispatch_sqrt)\n", + " 222 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:647(set_data)\n", + " 350 0.000 0.000 0.001 0.000 :1146(path_stats)\n", + " 1000 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/nn/utils/clip_grad.py:46()\n", + " 394 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:202(_update_values)\n", + " 435 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:814(set_size)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:1()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_notification.py:1()\n", + " 243 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1238(__init__)\n", + " 215/110 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1832(default_name)\n", + " 4731 0.001 0.000 0.001 0.000 {built-in method numpy.asanyarray}\n", + " 288 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_normalizations.py:190(normalizer_inner)\n", + " 2152 0.001 0.000 0.001 0.000 :380(__eq__)\n", + " 457 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:928(_json_decode)\n", + " 1000 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/grad_mode.py:82(__exit__)\n", + " 76 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:239(_get_xy_display)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor.py:1()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/fx/decomposition_table.py:1()\n", + " 7031 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1036(get_points)\n", + " 1000 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:309(_cuda_graph_capture_health_check)\n", + " 4008 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:946()\n", + " 42 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1615(__getitem__)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_replacement.py:1()\n", + " 4 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/library.py:42(__init__)\n", + " 454 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/tokenize.py:433(_tokenize)\n", + " 106 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:374(set_alpha)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_attachment.py:1()\n", + " 695 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:167(get_annotations)\n", + " 392 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2770(__str__)\n", + " 603 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:159(_type_convert)\n", + " 106 0.000 0.000 0.001 0.000 <__array_function__ internals>:177(vstack)\n", + " 366 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3245(around)\n", + " 74 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1183(set_marker)\n", + " 38/18 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4373(parseImpl)\n", + " 9401 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:293(axes)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImagePalette.py:1()\n", + " 213 0.000 0.000 0.001 0.000 :216(_lock_unlock_module)\n", + " 18351 0.001 0.000 0.001 0.000 {built-in method builtins.abs}\n", + " 70 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:257(rename_parameter)\n", + " 363 0.000 0.000 0.001 0.000 :778(spec_from_file_location)\n", + " 100 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2746(_revalidate)\n", + " 26 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:416(make_keyword_only)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:2973(frombuffer)\n", + " 359 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:730(set_figure)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_configuration_override.py:1()\n", + " 684/532 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2377(_invalidate_internal)\n", + " 185 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:257(_recache)\n", + " 256/18 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:414(visit)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_ufuncs.py:1()\n", + " 654 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:449(_field_init)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pstats.py:1()\n", + " 67 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1089(reversed)\n", + " 178 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1612(transform_path_non_affine)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:2896(new)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_location.py:1()\n", + " 25/6 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3816(streamline)\n", + " 490 0.000 0.000 0.001 0.000 <__array_function__ internals>:177(concatenate)\n", + " 256/18 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:420(generic_visit)\n", + " 582 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1782()\n", + " 5770 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1929(get_matrix)\n", + " 1000 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/grad_mode.py:73(__init__)\n", + " 1 0.001 0.001 0.001 0.001 {built-in method PIL._imaging.fill}\n", + " 62 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1352(__add__)\n", + " 338 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:437(set_transform)\n", + " 1000 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/nn/utils/clip_grad.py:61()\n", + " 518 0.000 0.000 0.001 0.000 <__array_function__ internals>:177(ndim)\n", + " 35/5 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3675(streamline)\n", + " 3500 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:189()\n", + " 2000 0.001 0.000 0.001 0.000 {method 'to' of 'torch._C._TensorBase' objects}\n", + " 9073 0.001 0.000 0.001 0.000 {method 'group' of 're.Match' objects}\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/fx/registration.py:1()\n", + " 1464 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1203(set_y)\n", + " 74 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:241(_optimize_charset)\n", + " 726 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:367(_escape)\n", + " 26/14 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4108(parseImpl)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_common.py:1()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:1()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:1()\n", + " 1909 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1226(_is_dunder)\n", + " 3045 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3018()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_afm.py:1()\n", + " 3006 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:943()\n", + " 548 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:827(_set_new_attribute)\n", + " 350 0.000 0.000 0.001 0.000 :642(_classify_pyc)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_property_file_references.py:1()\n", + " 562 0.000 0.000 0.001 0.000 :1421(_path_importer_cache)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_stack.py:1()\n", + " 6758 0.001 0.000 0.001 0.000 {method 'endswith' of 'str' objects}\n", + " 1758 0.001 0.000 0.001 0.000 {method '__reduce_ex__' of 'object' objects}\n", + " 1027 0.001 0.000 0.001 0.000 {method 'detach' of 'torch._C._TensorBase' objects}\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/resume_execution.py:1()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_reference.py:1()\n", + " 2 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1369(make_dataclass)\n", + " 78 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:234(_adjust_location)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1()\n", + " 44 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:66(__set_name__)\n", + " 11 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2797()\n", + " 1012 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1337(_to_unmasked_float_array)\n", + " 67 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1108()\n", + " 78/4 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:909(_parseCache)\n", + " 790 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1107(_expand_aliases)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/helpers.py:648(make_html_tags)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:13(glob)\n", + " 2770 0.001 0.000 0.001 0.000 {method 'reshape' of 'numpy.ndarray' objects}\n", + " 122 0.000 0.000 0.001 0.000 <__array_function__ internals>:177(unique)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/helpers.py:590(_makeTags)\n", + " 106 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/shape_base.py:223(vstack)\n", + " 2714 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:185(is_consecutive)\n", + " 12 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:57()\n", + " 1768 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:451(get)\n", + " 350 0.000 0.000 0.001 0.000 :675(_validate_timestamp_pyc)\n", + " 34 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:60(_iglob)\n", + " 123 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2037(_signature_bound_method)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/__init__.py:1()\n", + " 32 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:409(to_rgba_array)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/user_defined.py:1()\n", + " 6590 0.001 0.000 0.001 0.000 {built-in method builtins.iter}\n", + " 217 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_helper.py:263(decorator)\n", + " 584 0.001 0.000 0.001 0.000 :100(acquire)\n", + " 63 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3783(__init__)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:1()\n", + " 63 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:818(__init__)\n", + " 4 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:647(__init__)\n", + " 219 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:240(_check_color_like)\n", + " 1030 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1192(set_x)\n", + " 27/7 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4409(streamline)\n", + " 4 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3316(tick_params)\n", + " 336 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:670()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:400(ParserElement)\n", + " 30 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:845(_hash_add)\n", + " 244 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_ufunc_config.py:33(seterr)\n", + " 75 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copy.py:237(_deepcopy_method)\n", + " 8 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1189(_set_lim)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_analysis.py:1()\n", + " 584 0.001 0.000 0.001 0.000 :125(release)\n", + " 9571 0.001 0.000 0.001 0.000 {method 'pop' of 'list' objects}\n", + " 2000 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:122()\n", + " 50 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:342(update_from)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph.py:1()\n", + " 123 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:228(_recursive_repr)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_content.py:1()\n", + " 112 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1171(_set_artist_props)\n", + " 125 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1155(update_from)\n", + " 1050 0.000 0.000 0.001 0.000 :84(_unpack_uint32)\n", + " 530 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/bezier.py:203()\n", + " 20 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4889(parseImpl)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2398(__init__)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:105(_glob1)\n", + " 123 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:573()\n", + " 900 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copy.py:264()\n", + " 151 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1001(set_alpha)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:1()\n", + " 1758 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copyreg.py:104(__newobj__)\n", + " 30 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:638(_hash_fn)\n", + " 244 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1904(scale_range)\n", + " 341 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:736(set_style)\n", + " 636 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:368(field)\n", + " 388 0.001 0.000 0.001 0.000 {method '__exit__' of '_io._IOBase' objects}\n", + " 106 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:470(cleaned)\n", + " 22 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4956(parseImpl)\n", + " 10 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2791(_generateDefaultName)\n", + " 195 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1110()\n", + " 371 0.000 0.000 0.001 0.000 :173(__exit__)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/fx/__init__.py:1()\n", + " 3538/834 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:353(recursive_subclasses)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config.py:310()\n", + " 1000 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_foreach_utils.py:39()\n", + " 120 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1181(set_position)\n", + " 2002 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:192(innermost_fn)\n", + " 4000 0.001 0.000 0.001 0.000 {built-in method torch._C._set_grad_enabled}\n", + " 95 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2257(p)\n", + " 122 0.000 0.000 0.001 0.000 <__array_function__ internals>:177(ptp)\n", + " 378 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1504(__and__)\n", + " 629 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1324(is_math_text)\n", + " 356 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:776(_findclass)\n", + " 130 0.000 0.000 0.001 0.000 <__array_function__ internals>:177(any)\n", + " 15 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2792(charsAsStr)\n", + " 1511 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2123(transform)\n", + " 2 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2294(__init__)\n", + " 122 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:138(unique)\n", + " 384 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:162(_fast_from_codes_and_verts)\n", + " 4000 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_foreach_utils.py:49()\n", + " 44 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:51(__init__)\n", + " 2198 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:65(wraps)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/utils.py:1()\n", + " 15957 0.001 0.000 0.001 0.000 {built-in method builtins.ord}\n", + " 44 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1345()\n", + " 38 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1586(__getitem__)\n", + " 36 0.000 0.000 0.001 0.000 :1408(_path_hooks)\n", + " 1000 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_contextlib.py:149(__new__)\n", + " 420 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2214()\n", + " 483 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:722(set_family)\n", + " 33 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:364(_update_contains)\n", + " 16 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1126(_set_position)\n", + " 50 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/stride_tricks.py:546()\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_bbox.py:8(adjust_bbox)\n", + " 9000 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_jit_internal.py:1109(is_scripting)\n", + " 341 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:749(set_variant)\n", + " 7930 0.001 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2736(name)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/__init__.py:1()\n", + " 530 0.000 0.000 0.001 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/bezier.py:283(axis_aligned_extrema)\n", + " 1 0.000 0.000 0.001 0.001 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:1()\n", + " 29 0.001 0.000 0.001 0.000 {method 'draw_glyphs_to_bitmap' of 'matplotlib.ft2font.FT2Font' objects}\n", + " 366 0.001 0.000 0.001 0.000 {method 'round' of 'numpy.ndarray' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:542(_AxesBase)\n", + " 247 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:245(_collect_parameters)\n", + " 79 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3601(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_inductor/test_operators.py:1()\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:726(_get_transformed_path)\n", + " 42 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2984(parseImpl)\n", + " 5354 0.000 0.000 0.000 0.000 {method 'find' of 'str' objects}\n", + " 244 0.000 0.000 0.000 0.000 {method 'sum' of 'numpy.ndarray' objects}\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:299(_apply)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_type_utils.py:1()\n", + " 108 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:982(set_color)\n", + " 502 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:396(_simple)\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:440(_apply_tickdir)\n", + " 244 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(nonzero)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:1()\n", + " 2234 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1262(set_text)\n", + " 2399 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:247(match)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/types.py:1()\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/stride_tricks.py:340(_broadcast_to)\n", + " 333 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1197(_set_markercolor)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:658(get_position)\n", + " 8634 0.000 0.000 0.000 0.000 {method 'rstrip' of 'str' objects}\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:497(_apply_tickdir)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:1315(subplots_adjust)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2770(get_transformed_path_and_affine)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_region.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes_impl.py:1()\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:473(__prepare__)\n", + " 2265 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:158(__len__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:175(_listdir)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:181(FigureBase)\n", + " 209 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:1441(formatannotation)\n", + " 141 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1084(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_normalizations.py:1()\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:711(_transform_path)\n", + " 1213 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:450(get_transform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_functorch/make_functional.py:1()\n", + " 3031 0.000 0.000 0.000 0.000 :244(_verbose_message)\n", + " 28 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1600(__getitem_inner__)\n", + " 225 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:455(__init__)\n", + " 233 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:314(_set_edgecolor)\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:141(_iterdir)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2532(__init__)\n", + " 5610 0.000 0.000 0.000 0.000 {method 'pop' of 'dict' objects}\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2759(get_transformed_points_and_affine)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/helpers.py:692()\n", + " 156/148 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:339(get_spine_transform)\n", + " 55 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:33(parse)\n", + " 7100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2748(kind)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1138(set_linestyle)\n", + " 185 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:338(_set_artist_props)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:940(glob)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_cm_listed.py:1()\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2604(ptp)\n", + " 1599 0.000 0.000 0.000 0.000 {built-in method builtins.delattr}\n", + " 6000 0.000 0.000 0.000 0.000 {built-in method torch.is_grad_enabled}\n", + " 1554 0.000 0.000 0.000 0.000 :1032(__exit__)\n", + " 6495 0.000 0.000 0.000 0.000 {method '__contains__' of 'frozenset' objects}\n", + " 56 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:2081(getLogger)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_ufunc_config.py:430(__enter__)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1054(set)\n", + " 1020 0.000 0.000 0.000 0.000 :405(parent)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:223(define_aliases)\n", + " 10/3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:14(__get__)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:323(_unique1d)\n", + " 466 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:75(_scale_dashes)\n", + " 1000 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/nn/utils/clip_grad.py:39()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/torch.py:1()\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:47(_sum)\n", + " 4798 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1563()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:1()\n", + " 598 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2255(get_affine)\n", + " 150 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1833(frozen)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_tensor.py:980(__iter__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:1()\n", + " 130 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2333(any)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementPath.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/hooks.py:1()\n", + " 1554 0.000 0.000 0.000 0.000 :1028(__enter__)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:1603(_max_pool)\n", + " 92 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:788(frozen)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1053(set_color)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method torch.sin}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:1()\n", + " 6988 0.000 0.000 0.000 0.000 {method 'isidentifier' of 'str' objects}\n", + " 370 0.000 0.000 0.000 0.000 :71(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:1()\n", + " 1 0.000 0.000 0.000 0.000 {method 'unbind' of 'torch._C._TensorBase' objects}\n", + " 1 0.000 0.000 0.000 0.000 {method 'set_window_title' of '_macosx.FigureManager' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_exception.py:1()\n", + " 276 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:401(_tuple_str)\n", + " 3512 0.000 0.000 0.000 0.000 {built-in method builtins.issubclass}\n", + " 252 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/getlimits.py:581(tiny)\n", + " 2000 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/adam.py:296()\n", + " 8/4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:981(__get__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_web_request.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/ElementTree.py:36(_get_py3_cls)\n", + " 56 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1327(getLogger)\n", + " 370 0.000 0.000 0.000 0.000 :198(cb)\n", + " 199 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/__init__.py:253(escape)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_web_response.py:1()\n", + " 3384 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:837()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result_provenance.py:1()\n", + " 12/5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4092(streamline)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2973(re_match)\n", + " 6109 0.000 0.000 0.000 0.000 {method 'add' of 'set' objects}\n", + " 518 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3152(ndim)\n", + " 132 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:430(visit_Constant)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_text_helpers.py:1()\n", + " 571 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:159(add)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_rectangle.py:1()\n", + " 1000 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_foreach_utils.py:14(_get_fused_kernels_supported_devices)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2961(re)\n", + " 1 0.000 0.000 0.000 0.000 {method 'read' of '_io.TextIOWrapper' objects}\n", + " 260 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:282(_set_fillstyle)\n", + " 106 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(atleast_2d)\n", + " 1003 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_tensor.py:1002(__hash__)\n", + " 279 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2421(transform_path_non_affine)\n", + " 4001 0.000 0.000 0.000 0.000 {built-in method torch._C._get_privateuse1_backend_name}\n", + " 800 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copy.py:243(_keep_alive)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_stack_frame.py:1()\n", + " 117 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:396(set_linestyle)\n", + " 432 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1289()\n", + " 106 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:858(update_from_path)\n", + " 5533 0.000 0.000 0.000 0.000 {method 'values' of 'dict' objects}\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2536(_init)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:1()\n", + " 94 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1095(set_fontsize)\n", + " 29 0.000 0.000 0.000 0.000 {method 'draw_text_image' of 'matplotlib.backends._backend_agg.RendererAgg' objects}\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_ufunc_config.py:435(__exit__)\n", + " 148/39 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1862(__str__)\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2731(__init__)\n", + " 970 0.000 0.000 0.000 0.000 {method 'flatten' of 'numpy.ndarray' objects}\n", + " 388 0.000 0.000 0.000 0.000 :922(find_spec)\n", + " 564 0.000 0.000 0.000 0.000 {method 'sub' of 're.Pattern' objects}\n", + " 106 0.000 0.000 0.000 0.000 {built-in method matplotlib._path.cleanup_path}\n", + " 1400 0.000 0.000 0.000 0.000 :134()\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:379(wrapper)\n", + " 3937 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:700(get_size)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_fontconfig_pattern.py:57(_make_fontconfig_parser)\n", + " 494 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:683(_get_wrapped_text)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_logical_location.py:1()\n", + " 127 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:329(set_edgecolor)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:281(_ptp)\n", + " 64 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4349(__init__)\n", + " 804 0.000 0.000 0.000 0.000 {built-in method numpy.arange}\n", + " 123 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:392(_fields_in_init_order)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_configuration.py:1()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2298(_init)\n", + " 460 0.000 0.000 0.000 0.000 :60(isabs)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method utcfromtimestamp}\n", + " 175/95 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:909(get_xaxis_transform)\n", + " 278 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2222(transform_non_affine)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:144(get_grid_positions)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_prims/executor.py:1()\n", + " 1799 0.000 0.000 0.000 0.000 {method 'replace' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:1()\n", + " 338 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1094(get_default_size)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_message.py:1()\n", + " 929 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2761(_set_dpi)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_version_control_details.py:1()\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1947(le)\n", + " 30 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(linspace)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_constrained_layout.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph_traversal.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_suppression.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset10.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_bbox.py:39(restore_bbox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/_functional_collectives.py:500(_register_ops)\n", + " 351 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:762(set_weight)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:732(set_transform)\n", + " 591 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:78(_is_private)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_edge.py:1()\n", + " 1279 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:284(tell)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_enums.py:1()\n", + " 5650 0.000 0.000 0.000 0.000 {method 'strip' of 'str' objects}\n", + " 199 0.000 0.000 0.000 0.000 {method 'translate' of 'str' objects}\n", + " 512 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:341(intervaly)\n", + " 117 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1624()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_funcs.py:18(_public_functions)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffTags.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:80(alphanums)\n", + " 917 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:755(_is_wrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/_beartype.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location_relationship.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_sarif_log.py:1()\n", + " 341 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:788(set_stretch)\n", + " 3191 0.000 0.000 0.000 0.000 {method 'setdefault' of 'dict' objects}\n", + " 530 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:831(__setattr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_edge_traversal.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:1()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:274(clear)\n", + " 1150 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1851(_str_equal)\n", + " 2873 0.000 0.000 0.000 0.000 {method 'rpartition' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_translation_metadata.py:1()\n", + " 2 0.000 0.000 0.000 0.000 {method 'clear' of 'matplotlib.backends._backend_agg.RendererAgg' objects}\n", + " 252 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/getlimits.py:558(smallest_normal)\n", + " 67 0.000 0.000 0.000 0.000 {built-in method builtins.print}\n", + " 36 0.000 0.000 0.000 0.000 :1696(path_hook_for_FileFinder)\n", + " 25 0.000 0.000 0.000 0.000 {method 'draw_markers' of 'matplotlib.backends._backend_agg.RendererAgg' objects}\n", + " 3692 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:655(get_family)\n", + " 341 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:872(set_math_fontfamily)\n", + " 636/212 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2397()\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:1892(nonzero)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:1062(close)\n", + " 166/90 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:989(get_yaxis_transform)\n", + " 28 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1581(copy_with)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/function_base.py:23(linspace)\n", + " 636 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:287(__init__)\n", + " 72 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:945(_get_mixins_)\n", + " 36 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:484(_parse_args)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:215(_get_draw_artists)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/html/entities.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:44(destroy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_property_file_reference.py:1()\n", + " 92 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:235(frozen)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1857(get_data_ratio)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:70(alphas)\n", + " 141 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1536()\n", + " 571 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:242(x0)\n", + " 284 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:625(get_snap)\n", + " 105 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:301(_remove_dups_flatten)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:785(set_subplotspec)\n", + " 3624 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:677(get_variant)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool_component_reference.py:1()\n", + " 3624 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:671(get_style)\n", + " 3624 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:692(get_stretch)\n", + " 29 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:353(_select_from)\n", + " 2785 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:841(get_visible)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:55(_chars_for_ranges)\n", + " 801 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1467(debug)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run_automation_details.py:1()\n", + " 516 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:350(width)\n", + " 84 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:244(make_alias)\n", + " 96 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1027(set_linespacing)\n", + " 571 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:135(__init__)\n", + " 106 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/shape_base.py:81(atleast_2d)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_property_bag.py:1()\n", + " 3624 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:683(get_weight)\n", + " 61 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(zeros_like)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_relationship.py:1()\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:504(_from_parts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:169(destroy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_physical_location.py:1()\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1954(ge)\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:434(_get_text1_transform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:155(MarkerStyle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/guards.py:787(PyExprCSEPass)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1221(set_markerfacecolor)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_node.py:1()\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1526(__or__)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:868(__new__)\n", + " 188 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1246(set_verticalalignment)\n", + " 1134 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1345(__eq__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:805(copy)\n", + " 4005 0.000 0.000 0.000 0.000 {method 'values' of 'collections.OrderedDict' objects}\n", + " 83 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_helper.py:361(decorator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/codegen.py:1()\n", + " 334 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:919(set_capstyle)\n", + " 572 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:820(_set_qualname)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:844(_create_)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1416(ArtistInspector)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config_utils.py:14(install_config_module)\n", + " 334 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:989(set_joinstyle)\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:937(get_xaxis_text1_transform)\n", + " 2144 0.000 0.000 0.000 0.000 :1103(__eq__)\n", + " 274 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1043(set_visible)\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_ufunc_config.py:132(geterr)\n", + " 37 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/textwrap.py:470(indent)\n", + " 1 0.000 0.000 0.000 0.000 {function FigureManagerMac.destroy at 0x13eb8d580}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/relativedelta.py:1()\n", + " 4000 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_utils.py:841(is_compiling)\n", + " 798 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:966()\n", + " 3635 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1809(get_affine)\n", + " 4 0.000 0.000 0.000 0.000 {built-in method torch.zeros}\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:316(delete_parameter)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2638(_update_offset_text_position)\n", + " 350 0.000 0.000 0.000 0.000 :599(_check_name_wrapper)\n", + " 22 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1364()\n", + " 755 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2308(get_matrix)\n", + " 388 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/_distutils_hack/__init__.py:89(find_spec)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:491(_get_text1_transform)\n", + " 628 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:47(_is_dunder)\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:108(_clip_dep_invoke_with_casting)\n", + " 2598 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/multiarray.py:740(dot)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_axes.py:104(set_title)\n", + " 1000 0.000 0.000 0.000 0.000 {built-in method torch.is_complex}\n", + " 2836 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:706(get_file)\n", + " 127 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:381(set_linewidth)\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_deprecation.py:20(decorator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ExifTags.py:294()\n", + " 2022 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2758(_get_dpi)\n", + " 106 0.000 0.000 0.000 0.000 {built-in method matplotlib._path.update_path_extents}\n", + " 593 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:750(__delattr__)\n", + " 557 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:252(y0)\n", + " 474 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:37(_is_descriptor)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_multiformat_message_string.py:1()\n", + " 631 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:509(_init_param)\n", + " 1182 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:152()\n", + " 372 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:181(__init__)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1017(get_yaxis_text1_transform)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4084(__init__)\n", + " 494 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:284(get_rotation)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_inductor/config.py:1()\n", + " 3644 0.000 0.000 0.000 0.000 {method 'lower' of 'str' objects}\n", + " 1292 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:670(_set)\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:437(_get_text2_transform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:761(SetVariable)\n", + " 1797 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:425()\n", + " 2834 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:864(get_math_fontfamily)\n", + " 39 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:56(parse_parts)\n", + " 600/586 0.000 0.000 0.000 0.000 {built-in method builtins.repr}\n", + " 3108 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copy.py:107(_copy_immutable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/algorithms/_checkpoint/checkpoint_wrapper.py:1()\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:494(_get_text2_transform)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1630(make_norm_from_scale)\n", + " 413 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:356(height)\n", + " 127 0.000 0.000 0.000 0.000 {method 'any' of 'numpy.ndarray' objects}\n", + " 306 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:136(__new__)\n", + " 162 0.000 0.000 0.000 0.000 :71(join)\n", + " 1768 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:912()\n", + " 488 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1937(closeto)\n", + " 740 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1632(__eq__)\n", + " 769 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:192(__get__)\n", + " 385 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:734(get_path)\n", + " 1458 0.000 0.000 0.000 0.000 {method 'extend' of 'list' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:129()\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:963(get_xaxis_text2_transform)\n", + " 184 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2063(_signature_is_builtin)\n", + " 25 0.000 0.000 0.000 0.000 {method 'numpy' of 'torch._C._TensorBase' objects}\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:539(_get_data_path)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/library.py:65(define)\n", + " 61 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/numeric.py:77(zeros_like)\n", + " 469 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:327(__set_name__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1814(Parser)\n", + " 24 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3903(_generateDefaultName)\n", + " 6/3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config_utils.py:22(visit)\n", + " 14/12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1074(get_position)\n", + " 8 0.000 0.000 0.000 0.000 {built-in method torch._C.define}\n", + " 137 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/stride_tricks.py:416(_broadcast_shape)\n", + " 78 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2668(__init__)\n", + " 676 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:969(set_foreground)\n", + " 488 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:103(_clip_dep_is_byte_swapped)\n", + " 37 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:260(contextmanager)\n", + " 86 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1112(set_zorder)\n", + " 152 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(result_type)\n", + " 2937 0.000 0.000 0.000 0.000 {method 'get' of 'mappingproxy' objects}\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1043(get_yaxis_text2_transform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_color_data.py:1()\n", + " 188 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:997(set_horizontalalignment)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method torch.cos}\n", + " 28 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5368(__init__)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/textwrap.py:419(dedent)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3588(set_xlim)\n", + " 1666 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1758()\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:331(wrapper)\n", + " 1101 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:646(_is_classvar)\n", + " 176 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:82(opengroup)\n", + " 189 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:222(__init__)\n", + " 1258 0.000 0.000 0.000 0.000 {method 'count' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_fix.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:133()\n", + " 322 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:332(intervalx)\n", + " 2002 0.000 0.000 0.000 0.000 {built-in method torch._C._dynamo.eval_frame.set_eval_frame}\n", + " 1001 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/skipfiles.py:205(check)\n", + " 1184 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:933(get_rasterized)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:982()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1946(get_width_height)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:4283(get_children)\n", + " 76 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:91()\n", + " 82 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2266(__init__)\n", + " 37 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1324(__init_subclass__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:63()\n", + " 1071 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:109(__init__)\n", + " 3650 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copy.py:182(_deepcopy_atomic)\n", + " 591 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:58(_is_sunder)\n", + " 288 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:897(set_alpha)\n", + " 80 0.000 0.000 0.000 0.000 {method 'copy' of 'dict' objects}\n", + " 959 0.000 0.000 0.000 0.000 {method 'tolist' of 'numpy.ndarray' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:1()\n", + " 47 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_ufuncs.py:287(deco_unary_ufunc)\n", + " 1785 0.000 0.000 0.000 0.000 {built-in method posix.fspath}\n", + " 387 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/textwrap.py:482(prefixed_lines)\n", + " 28 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2915(__init__)\n", + " 47 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:518(decorating_function)\n", + " 1101 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:654(_is_initvar)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/linalg.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffTags.py:419(_populate)\n", + " 342 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/ma/core.py:587(filled)\n", + " 90 0.000 0.000 0.000 0.000 {built-in method builtins.sum}\n", + " 170 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cm.py:89(__getitem__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2858(__init__)\n", + " 252 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/getlimits.py:476(__new__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:1()\n", + " 38 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_ufuncs.py:65(deco_binary_ufunc)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_special_locations.py:1()\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:191(_create_closed)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/mlab.py:1()\n", + " 130 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:559(_axis_map)\n", + " 2508 0.000 0.000 0.000 0.000 {built-in method _imp.release_lock}\n", + " 2508 0.000 0.000 0.000 0.000 {built-in method _imp.acquire_lock}\n", + " 2002 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:205(enable_dynamic)\n", + " 66 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:130(clone)\n", + " 265 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:410()\n", + " 1000 0.000 0.000 0.000 0.000 {built-in method torch._C._are_functorch_transforms_active}\n", + " 303 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:1297(_val_or_rc)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1974(__init__)\n", + " 145 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:894(_parse_flags)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1123(set_linewidth)\n", + " 348/264 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1351(__hash__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset8.py:1()\n", + " 390 0.000 0.000 0.000 0.000 :357(__init__)\n", + " 309 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/shape_base.py:608(_column_stack_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/isoparser.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/GifImagePlugin.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/helpers.py:14(delimited_list)\n", + " 36 0.000 0.000 0.000 0.000 :1559(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2360(Figure)\n", + " 36 0.000 0.000 0.000 0.000 :1684()\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1009(_find_new_)\n", + " 22 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:213(__getattr__)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:354(get_transform)\n", + " 2000 0.000 0.000 0.000 0.000 {method '__exit__' of 'torch._C.DisableTorchFunctionSubclass' objects}\n", + " 127 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_methods.py:55(_any)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_type_utils.py:61(JitScalarType)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2034(set_params)\n", + " 17 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/library.py:86(impl)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:1()\n", + " 354 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:1945(_signature_get_user_defined_method)\n", + " 54 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:744(_get_axis_name)\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1214(set_rotation)\n", + " 36 0.000 0.000 0.000 0.000 :64(__init__)\n", + " 84 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3904()\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:183(__init__)\n", + " 125 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:453(set_capstyle)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:327(max)\n", + " 1666 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:211(vertices)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1437(__mul__)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1211(set_markeredgecolor)\n", + " 1000 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/backends/cuda/__init__.py:29(is_built)\n", + " 10 0.000 0.000 0.000 0.000 :1239(exec_module)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:737(_get_scale_docs)\n", + " 399 0.000 0.000 0.000 0.000 :180(_path_isabs)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1515(_set_title_offset_trans)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/isoparser.py:42(isoparser)\n", + " 228 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:33(_get_dash_pattern)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/output_graph.py:100(OutputGraphState)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1407(set_dash_capstyle)\n", + " 192/186 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:434(_get_literal_prefix)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset13.py:1()\n", + " 730 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:79(groups)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:1345()\n", + " 1000 0.000 0.000 0.000 0.000 {method 'conj' of 'torch._C._TensorBase' objects}\n", + " 170 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:953(copy)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:819(set_figure)\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2315(__init__)\n", + " 2 0.000 0.000 0.000 0.000 :412(realpath)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:235()\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2485(get_ticks_position)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:213(_get_version)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1231(set_markerfacecoloralt)\n", + " 744 0.000 0.000 0.000 0.000 {built-in method _thread.allocate_lock}\n", + " 10 0.000 0.000 0.000 0.000 {built-in method _imp.exec_dynamic}\n", + " 44 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/skipfiles.py:61(_module_dir)\n", + " 1000 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/__init__.py:139(_tensor_or_tensors_to_tuple)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/abc.py:1()\n", + " 1938 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2824(_amin_dispatcher)\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:457()\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:2516(_process_unit_info)\n", + " 2000 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/jit/__init__.py:124(annotate)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:215(connect)\n", + " 1962 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2698(_amax_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/hooks.py:6(Hooks)\n", + " 472 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2678(get_matrix)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:1()\n", + " 14 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5585(__init__)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2269(setter)\n", + " 200 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:164(_copy_docstring_and_deprecators)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:1()\n", + " 860 0.000 0.000 0.000 0.000 {method 'rfind' of 'str' objects}\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_functorch/deprecated.py:41(setup_docs)\n", + " 48 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/skipfiles.py:57(_strip_init_py)\n", + " 148 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1267(__getattr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/fnmatch.py:48(filter)\n", + " 306/282 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:159(__init__)\n", + " 1233 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:78()\n", + " 152 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:565(__getitem__)\n", + " 36 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:187(finalize)\n", + " 107 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:935(_check_for_existing_members_)\n", + " 151 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2075(_signature_is_functionlike)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1065(set_drawstyle)\n", + " 2862 0.000 0.000 0.000 0.000 {built-in method math.factorial}\n", + " 499 0.000 0.000 0.000 0.000 :67(_relax_case)\n", + " 2000 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/decorators.py:141(graph_break)\n", + " 123 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:548()\n", + " 698 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:255(iter_fields)\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:962(_get_markerfacecolor)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:514(_get_config_or_cache_dir)\n", + " 18 0.000 0.000 0.000 0.000 {built-in method _functools.reduce}\n", + " 117 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:493(set_hatch)\n", + " 118 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:301(set_antialiased)\n", + " 1 0.000 0.000 0.000 0.000 /Users/vrajpandya/repo/intern_challenge/placement.py:210()\n", + " 582 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:69(_is_internal_class)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/onnxruntime.py:595(OrtBackend)\n", + " 495 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2646(get_matrix)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/texmanager.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/testing/_internal/logging_tensor.py:1()\n", + " 415 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/shape_base.py:207(_arrays_for_stack_dispatcher)\n", + " 72 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:981(_find_data_type_)\n", + " 2 0.000 0.000 0.000 0.000 :421(_joinrealpath)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/shlex.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ExifTags.py:304(GPS)\n", + " 247 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1872(inverted)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_layout.py:236()\n", + " 2002 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:188(nothing)\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_ufunc_config.py:452(_no_nep50_warning)\n", + " 633 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:437(_field_assign)\n", + " 131 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1915(__eq__)\n", + " 12/2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1503(makeOptionalList)\n", + " 33 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/tokenize.py:408(tokenize)\n", + " 98 0.000 0.000 0.000 0.000 {built-in method _abc._abc_init}\n", + " 74 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1041(set_fontfamily)\n", + " 27 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:384(_mk_bitmap)\n", + " 351 0.000 0.000 0.000 0.000 :48(_new_module)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend.py:342(Legend)\n", + " 632 0.000 0.000 0.000 0.000 :41(_get_sep)\n", + " 130 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:562()\n", + " 170 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:771(__copy__)\n", + " 537 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:180(validator)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1359(set_dash_joinstyle)\n", + " 68 0.000 0.000 0.000 0.000 {method 'clear' of 'matplotlib.ft2font.FT2Font' objects}\n", + " 36 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:744()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:1()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3822(set_ylim)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2202(_get_ticks_position)\n", + " 34 0.000 0.000 0.000 0.000 :229(expanduser)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:43(parse)\n", + " 60 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1317()\n", + " 1000 0.000 0.000 0.000 0.000 {built-in method math.sqrt}\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2013(_validate_steps)\n", + " 121 0.000 0.000 0.000 0.000 :319(decode)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1646(convert_class)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/backends/registry.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:344(Slider)\n", + " 1168 0.000 0.000 0.000 0.000 {method '__exit__' of '_thread.lock' objects}\n", + " 108 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:287(_deduplicate)\n", + " 78 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:135(get_patch_transform)\n", + " 1038 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:767(rotation_point)\n", + " 22 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2324(blended_transform_factory)\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:785(_set_tickdown)\n", + " 1101 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:660(_is_kw_only)\n", + " 117 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:473(set_joinstyle)\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:273(__bool__)\n", + " 1338 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2119(get_matrix)\n", + " 183 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/getlimits.py:668(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:281(_make_selector)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:238(Dvi)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1423(set_solid_capstyle)\n", + " 1128 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:904(get_text)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:1()\n", + " 801 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1734(isEnabledFor)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1663(__call__)\n", + " 123 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:592()\n", + " 58 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:479(lru_cache)\n", + " 55 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1378(_fixupParents)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_fontconfig_pattern.py:59(comma_separated)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:349(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/onnxruntime.py:536(OrtBackendOptions)\n", + " 42 0.000 0.000 0.000 0.000 {method 'sort' of 'list' objects}\n", + " 60 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2752(replace)\n", + " 27 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:45(allow_rasterization)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_color_data.py:989()\n", + " 215 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_funcs.py:19(is_public_function)\n", + " 58 0.000 0.000 0.000 0.000 :778(__contains__)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:49(make_function_id_set)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:415(cycler)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:467(__getitem__)\n", + " 378 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:568(isstring)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1375(set_solid_joinstyle)\n", + " 175 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:465(_get_charset_prefix)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:561(_setResultsName)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2941(_wait_cursor_for_draw_cm)\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1922(__init__)\n", + " 512 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:868(__eq__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:260(compile_pattern)\n", + " 137 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/stride_tricks.py:538()\n", + " 1000 0.000 0.000 0.000 0.000 {built-in method torch._C._has_torch_function}\n", + " 571 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:76(set_base)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3086(ArrowStyle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:1()\n", + " 96 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1317(set_usetex)\n", + " 146 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffTags.py:26(__new__)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:765(_set_tickleft)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/guards.py:171(GuardBuilder)\n", + " 1184 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:960(get_agg_filter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:588(matplotlib_fname)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1700(update_units)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:101(VariableTracker)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1392(__radd__)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:482(anchored)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:1()\n", + " 587 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config_utils.py:76(__getattr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/fnmatch.py:38(_compile_pattern)\n", + " 522 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:298(axes)\n", + " 1050 0.000 0.000 0.000 0.000 {built-in method from_bytes}\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:687(Literal)\n", + " 64 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:536(__str__)\n", + " 94 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(copyto)\n", + " 1001 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:751(__init__)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:505(set_pickradius)\n", + " 1 0.000 0.000 0.000 0.000 {method 'throw' of 'generator' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset12.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/proj3d.py:1()\n", + " 2 0.000 0.000 0.000 0.000 {method 'set_cursor' of '_macosx.FigureCanvas' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext_data.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2802(NavigationToolbar2)\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1615(raise_if_exceeds)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:2533(SpanSelector)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/fx/patcher.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/output_graph.py:213(OutputGraph)\n", + " 16/8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/units.py:164(get_converter)\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4147(_generateDefaultName)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/side_effects.py:1()\n", + " 17 0.000 0.000 0.000 0.000 {built-in method torch._C.impl}\n", + " 999 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:283(get_loc)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:3005(set_size_inches)\n", + " 388 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:914(set_antialiased)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3497(get_xbound)\n", + " 440 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:246(_get_multialignment)\n", + " 130 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:967(__init__)\n", + " 156/148 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:202(_ensure_position_is_set)\n", + " 1236 0.000 0.000 0.000 0.000 {built-in method _thread.get_ident}\n", + " 1000 0.000 0.000 0.000 0.000 {method 'numel' of 'torch._C._TensorBase' objects}\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2271()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2240(LogLocator)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1189(reversed)\n", + " 23 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4948(__init__)\n", + " 1047 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:193(_reshape_dispatcher)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:474(_cycler)\n", + " 316 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:878(_convert_validator_spec)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:84(TransformNode)\n", + " 40 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1149(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/optimizer.py:1()\n", + " 32 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:497()\n", + " 24 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:220(decorate)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset10.py:75(_apply)\n", + " 68 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:42(get_hinting_flag)\n", + " 1056 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:223(codes)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1069(_update_transScale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:615(RangeSlider)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/bezier.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:27(Collection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/functions.py:1()\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1820(__init_subclass__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:1341(TextBox)\n", + " 37 0.000 0.000 0.000 0.000 :164(_path_isdir)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:609(gen_candidates)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:450(DebugActions)\n", + " 1016 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1331(get_usetex)\n", + " 754 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:396()\n", + " 90 0.000 0.000 0.000 0.000 :878(__iter__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1181(_gen_axes_patch)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3547(get_xlim)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result.py:28(Result)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:54(literal_eval)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:981(resolve)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:242(__set_name__)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5590(__add__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:118(pyparsing_unicode)\n", + " 32 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:667(__init__)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1719(set)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/axis3d.py:38(Axis)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_transformation.py:43(Instruction)\n", + " 189 0.000 0.000 0.000 0.000 {built-in method _sre.compile}\n", + " 1001 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:754(__enter__)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:765(__truediv__)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_logging/_internal.py:427(getArtifactLogger)\n", + " 988 0.000 0.000 0.000 0.000 {built-in method math.cos}\n", + " 36 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4148()\n", + " 55 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1447(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_ndarray.py:174(ndarray)\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:779(_set_tickup)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2282(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/warnings.py:130(filterwarnings)\n", + " 571 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:267(onnx_symbolic)\n", + " 44 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:533(copy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/contour.py:716(ContourSet)\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:229(_connect_picklable)\n", + " 292 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:239(__iter__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageOps.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:596(Axis)\n", + " 120/78 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1637(__hash__)\n", + " 388 0.000 0.000 0.000 0.000 {built-in method _imp.find_frozen}\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:59(FunctionIdSet)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/fx/diagnostics.py:1()\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:206(_from_iter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_invocation.py:17(Invocation)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:101(resize)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:530(_make_child)\n", + " 1876 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:847()\n", + " 42 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:546(__fspath__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:873(_set_lim_and_transforms)\n", + " 78 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:270(get_patch_transform)\n", + " 99 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builtin.py:396(__init__)\n", + " 90 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2218()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_adapters.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:294(HammerAxes)\n", + " 984 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3031(parameters)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:552(get_configdir)\n", + " 1017 0.000 0.000 0.000 0.000 {built-in method math.radians}\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:24(_prevent_rasterization)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ExifTags.py:359(LightSource)\n", + " 1105 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2214(cast)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:52(__init__)\n", + " 12 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(cumsum)\n", + " 123 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1017()\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3750(get_ybound)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:771(_set_tickright)\n", + " 794 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1338()\n", + " 189 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:954(fix_flags)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_util.py:1()\n", + " 70 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:775(__getattr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:246(AitoffAxes)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/nn_module.py:1()\n", + " 468 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:348()\n", + " 164 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:140(validate_bool)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:523(shrunk_to_aspect)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:3738(LassoSelector)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:412(get_subplot_params)\n", + " 2075 0.000 0.000 0.000 0.000 {built-in method builtins.chr}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1518(_cached_realpath)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/contour.py:72(ContourLabeler)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:413(LambertAxes)\n", + " 75 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:132(__getstate__)\n", + " 244 0.000 0.000 0.000 0.000 {method 'nonzero' of 'numpy.ndarray' objects}\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1966(clear)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:341(MollweideAxes)\n", + " 571 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:71(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/common.py:422()\n", + " 42 0.000 0.000 0.000 0.000 :771(get)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:4054(FancyArrowPatch)\n", + " 54 0.000 0.000 0.000 0.000 :674(__getitem__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/torch_version.py:59(_convert_to_version)\n", + " 27 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:386()\n", + " 74 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:214(_compile_charset)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1908(_set_device_pixel_ratio)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:909(home)\n", + " 196 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1031(get_hatch_path)\n", + " 39 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2981(_generateDefaultName)\n", + " 37 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:207(_apply_tickdir)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3800(get_ylim)\n", + " 24 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:431(__iadd__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2106(IdentityTransform)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1241(set_markeredgewidth)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/helpers.py:1061()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1330(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:1307(rruleset)\n", + " 32 0.000 0.000 0.000 0.000 :941(update)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:299(set_position)\n", + " 1004 0.000 0.000 0.000 0.000 {built-in method torch._C._has_torch_function_unary}\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1632(get_minor_ticks)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_trifinder.py:1()\n", + " 350 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/textwrap.py:479(predicate)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2338(CompositeGenericTransform)\n", + " 988 0.000 0.000 0.000 0.000 {built-in method math.sin}\n", + " 353 0.000 0.000 0.000 0.000 :1097(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:58(_timelex)\n", + " 385 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:734(unit_rectangle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:78()\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:4424()\n", + " 33 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/numeric.py:150(ones)\n", + " 3 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(inv)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:110(_weak_or_strong_ref)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:399(_patch_step_function)\n", + " 170 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:677(__init__)\n", + " 264 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:432()\n", + " 21/20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1640(__repr__)\n", + " 790 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1145(score_style)\n", + " 318 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:781(__iter__)\n", + " 754 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1101()\n", + " 61 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(empty_like)\n", + " 790 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1209(score_size)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1633(nonsingular)\n", + " 388 0.000 0.000 0.000 0.000 :748(find_spec)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/fx/passes/fake_tensor_prop.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:97()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:43(Tick)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2264()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/BmpImagePlugin.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:314(_POERules)\n", + " 176 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:429()\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:734(_get_shared_axes)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_prims/context.py:1()\n", + " 507 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:166(__setitem__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/types.py:32(GuardFn)\n", + " 24/23 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1475(__repr__)\n", + " 75 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1609()\n", + " 192 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1773(__array__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1989(_switch_canvas_and_return_print_method)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:216(Line2D)\n", + " 75 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:137(__setstate__)\n", + " 123 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1043()\n", + " 1029 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2740(default)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/linalg/linalg.py:469(inv)\n", + " 334 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1000(set_linewidth)\n", + " 134 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1862(_str_lower_equal)\n", + " 46 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:110(__init__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1679(_make_norm_from_scale)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:1078(putchunk)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:353(profile_hook_step)\n", + " 492 0.000 0.000 0.000 0.000 {built-in method builtins.divmod}\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:64()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_functorch/make_functional.py:254(FunctionalModuleWithBuffers)\n", + " 860 0.000 0.000 0.000 0.000 {built-in method sys.getrecursionlimit}\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1043(_translate_tick_params)\n", + " 106 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/shape_base.py:218(_vhstack_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3807(FancyBboxPatch)\n", + " 371 0.000 0.000 0.000 0.000 :165(__init__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1284(__instancecheck__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1773(__class_getitem__)\n", + " 385 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/stride_tricks.py:542()\n", + " 67/55 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:224(_type_repr)\n", + " 22 0.000 0.000 0.000 0.000 :162(find_spec)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:3814(PolygonSelector)\n", + " 1000 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:340(_optimizer_step_code)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2293(BoxStyle)\n", + " 668 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2427(_all_dispatcher)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:651(cache)\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2011(__init_subclass__)\n", + " 663 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:892(get_clip_path)\n", + " 326 0.000 0.000 0.000 0.000 {built-in method sys.intern}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:1()\n", + " 732 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3241(_around_dispatcher)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1547(__subclasscheck__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:29(Cursors)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1573(get_matrix)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:670(Rectangle)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2523(cumsum)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:745(_draw_disabled)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/distributed.py:1()\n", + " 494 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:601(get_wrap)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3569(_validate_converted_limits)\n", + " 494 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:292(get_transform_rotates_text)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2243(mpl_connect)\n", + " 790 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1162(score_variant)\n", + " 106 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:344(__len__)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1256(set_markersize)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset17.py:1()\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1737(__call__)\n", + " 1001 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:757(__exit__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1259(Arrow)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2658(ConnectionStyle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_reductions_impl.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/mps/__init__.py:42(manual_seed)\n", + " 125 0.000 0.000 0.000 0.000 {method '__deepcopy__' of 'numpy.ndarray' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/skipfiles.py:128()\n", + " 67 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:191(__getitem__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builder.py:199(VariableBuilder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:85(identchars)\n", + " 58 0.000 0.000 0.000 0.000 {built-in method builtins.round}\n", + " 105 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:1443(repl)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/linalg.py:33(linalg_errors)\n", + " 51 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:394()\n", + " 488 0.000 0.000 0.000 0.000 {built-in method math.log10}\n", + " 189 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:73(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset7.py:1()\n", + " 262 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:124()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:571(get_cachedir)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:4394(ConnectionPatch)\n", + " 244 0.000 0.000 0.000 0.000 {built-in method numpy.seterrobj}\n", + " 530 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/bezier.py:242(degree)\n", + " 154 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:757(preParse)\n", + " 37 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:195(_set_labelrotation)\n", + " 440 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:317(get_rotation_mode)\n", + " 222 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1329()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/streamplot.py:1()\n", + " 121 0.000 0.000 0.000 0.000 {built-in method _codecs.utf_8_decode}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset14.py:1()\n", + " 23 0.000 0.000 0.000 0.000 {built-in method posix.lstat}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/mps/__init__.py:15(_get_default_mps_generator)\n", + " 52 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3819()\n", + " 790 0.000 0.000 0.000 0.000 {built-in method builtins.vars}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_legacy.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:1212(AnnotationBbox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:26(GridSpecBase)\n", + " 341 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:844(set_file)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method torch._C._mps_get_default_generator}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:116(UserErrorType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:211(BboxBase)\n", + " 518 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1347(get_parse_math)\n", + " 118 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:310(ismethoddescriptor)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:29(format_list)\n", + " 170 0.000 0.000 0.000 0.000 {method 'astype' of 'numpy.ndarray' objects}\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:125()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:578(_ReducedHCT_Element)\n", + " 78 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:111(set_)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:297(get_joinstyle)\n", + " 571 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:81(in_base)\n", + " 1 0.000 0.000 0.000 0.000 {method 'close' of '_io.BufferedRandom' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_adapters.py:42(CompatibilityFiles)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:24(BaseListVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/onnxruntime.py:430(OrtExecutionInfoPerSession)\n", + " 57 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:444(_uniq)\n", + " 4 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(diff)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:348(SymmetricalLogTransform)\n", + " 248 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2271()\n", + " 848 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1367(depth)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/bezier.py:189(BezierSegment)\n", + " 123 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1046()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:1949(Cursor)\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2786(get_affine)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:955(x0)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_cm.py:1()\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1041(set_antialiased)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/skipfiles.py:72()\n", + " 2 0.000 0.000 0.000 0.000 {built-in method posix.scandir}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:99(identbodychars)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:186(__init__)\n", + " 822 0.000 0.000 0.000 0.000 {method '__subclasses__' of 'type' objects}\n", + " 242 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3614()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/random.py:1()\n", + " 42 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/tokenize.py:329(find_cookie)\n", + " 123 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:397()\n", + " 222 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1335()\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1100(set_gapcolor)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:1377(expanduser)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1685(_safe_first_finite)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/side_effects.py:60(SideEffects)\n", + " 549 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:884(get_clip_on)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:3056(ToolHandles)\n", + " 346 0.000 0.000 0.000 0.000 {method 'ravel' of 'numpy.ndarray' objects}\n", + " 488 0.000 0.000 0.000 0.000 {built-in method numpy.geterrobj}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builder.py:1428(TrackedFake)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:430(ImageFileDirectory_v2)\n", + " 55 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1234()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/guards.py:878(CheckFunctionManager)\n", + " 123 0.000 0.000 0.000 0.000 :146(update_abstractmethods)\n", + " 557 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:888(get_clip_box)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4758(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1090(TimerBase)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3063(__hash__)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1867(_set_formatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:1034(NonUniformImage)\n", + " 184 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:505(isbuiltin)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/comptime.py:1()\n", + " 183 0.000 0.000 0.000 0.000 {method 'sort' of 'numpy.ndarray' objects}\n", + " 28 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:657(stem)\n", + " 123 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1052()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_ops.py:641(__getattr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/units.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/table.py:37(Cell)\n", + " 518 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:3148(_ndim_dispatcher)\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:298(set_rotation_mode)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:992(__init__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:985(intervalx)\n", + " 388 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1004(set_url)\n", + " 452 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:611(get_gid)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/fx/_compatibility.py:24(mark_not_back_compat)\n", + " 78 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:108(get)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:1096(write)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:1008(stat)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:513(format)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:24(Path)\n", + " 694 0.000 0.000 0.000 0.000 {method 'copy' of 'list' objects}\n", + " 490 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/multiarray.py:152(concatenate)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:134(Diagnostics)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:2945(ToolLineHandles)\n", + " 367 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:426(_get_iscased)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3727(_setResultsName)\n", + " 648 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:754()\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset10.py:137(_max_pool)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builder.py:152(GraphArg)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PpmImagePlugin.py:1()\n", + " 284 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:939(set_dashes)\n", + " 899 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:589()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_casting_dicts.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:208(OffsetBox)\n", + " 500 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1128(sticky_edges)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/algorithms/_checkpoint/checkpoint_wrapper.py:21(ActivationWrapper)\n", + " 117 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:182(_validate_hatch_pattern)\n", + " 467 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:849(get_in_layout)\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_reductions_impl.py:24(_deco_axis_expand)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:550(set_markevery)\n", + " 568 0.000 0.000 0.000 0.000 {method 'keys' of 'dict' objects}\n", + " 55 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:523(_format_parsed_parts)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:586(set_clip_box)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:56(draw_idle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/constant.py:1()\n", + " 88 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:146(__init__)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:46(__new__)\n", + " 14 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/fft.py:11(upcast)\n", + " 99 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:66(__call__)\n", + " 123 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:346(__init__)\n", + " 33 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:200(__setitem__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1671(FigureCanvasBase)\n", + " 292 0.000 0.000 0.000 0.000 {method 'find' of 'bytearray' objects}\n", + " 222 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2264()\n", + " 350 0.000 0.000 0.000 0.000 {built-in method _imp._fix_co_filename}\n", + " 24/23 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1481()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/_beartype.py:39(RuntimeTypeCheckState)\n", + " 392 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:723(get_path_effects)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_functorch/config.py:1()\n", + " 344 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:801()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/style/core.py:238(reload_library)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:1245(is_dir)\n", + " 169 0.000 0.000 0.000 0.000 {built-in method numpy.empty}\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:135(__init__)\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/copyreg.py:113(_slotnames)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5716()\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:74(from_sarif)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1621()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2856(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:27(Patch)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:125(_unpack_tuple)\n", + " 730 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/_beartype.py:57(_no_op_decorator)\n", + " 404 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:254(should_simplify)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/function_base.py:1320(diff)\n", + " 374 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:541(locator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/testing.py:1()\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4879(__init__)\n", + " 96 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:321(set_antialiased)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:582(get_data_path)\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:307(_class_escape)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:569(__init__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:528(set_results_name)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/abc.py:56(Traversable)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:300(get_capstyle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:65(_single_shot_timer)\n", + " 404 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/path.py:242(simplify_threshold)\n", + " 334 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1012(set_snap)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5711()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:141(InstructionTranslatorGraphState)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset16.py:1()\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:882(wrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:1788()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:4182(Lasso)\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/linecache.py:52(checkcache)\n", + " 187 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:31(_combine_flags)\n", + " 22 0.000 0.000 0.000 0.000 :370(_get_module_info)\n", + " 334 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:664(get_sketch_params)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:294(__init__)\n", + " 99 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:331(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:157(Transpose)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:336(_validate_cmap)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:936(get_markeredgecolor)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:227(__getitem__)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:458(format_frame_summary)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config_utils.py:1()\n", + " 22 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:959(reset_cache)\n", + " 31 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/warnings.py:466(__enter__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_enums.py:27(JoinStyle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_prims/context.py:82(TorchRefsMode)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_functorch/make_functional.py:310(FunctionalModule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/style/core.py:198(update_user_library)\n", + " 437 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1243(name)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1697(Norm)\n", + " 453 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:234(__init__)\n", + " 2 0.000 0.000 0.000 0.000 :27(isfile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/error.py:1()\n", + " 362 0.000 0.000 0.000 0.000 :413(has_location)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/testing/_internal/logging_tensor.py:97(LoggingTensorHandler)\n", + " 95 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2205(parse_name)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:490(enter_context)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1922(Arc)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1969()\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:236(set_locs)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/resume_execution.py:312(ContinueExecutionCache)\n", + " 131 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1711(set_whitespace_chars)\n", + " 102 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/exceptions.py:24(__init__)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:546(__exit__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:441(_validate_papersize)\n", + " 156 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1924(__hash__)\n", + " 54 0.000 0.000 0.000 0.000 :756(encode)\n", + " 19 0.000 0.000 0.000 0.000 {method 'write' of '_io.BufferedRandom' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1339(LocationEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/container.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4757(_MultipleMatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/quiver.py:443(Quiver)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:965(x1)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builder.py:193(FrameStateSizeEntry)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1615(Annotation)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:996(CheckButtons)\n", + " 1 0.000 0.000 0.000 0.000 {method 'float' of 'torch._C._TensorBase' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_managers.py:1()\n", + " 17 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:362(size)\n", + " 350 0.000 0.000 0.000 0.000 :1122(get_filename)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:1111(mkdir)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/types.py:67(new_class)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset11.py:92(_apply)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_common.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_factories.py:1()\n", + " 59 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:228(_acquireLock)\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:265(getuntil)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_enums.py:119(CapStyle)\n", + " 388 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:807(restore)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:153(RendererBase)\n", + " 288 0.000 0.000 0.000 0.000 :1565()\n", + " 28 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:877(_make_child_relpath)\n", + " 325 0.000 0.000 0.000 0.000 {method 'values' of 'mappingproxy' objects}\n", + " 17 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:273(validate_color_or_auto)\n", + " 28 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:462(_validate_linestyle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1314(FancyArrow)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/win.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ExifTags.py:340()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:786(_add_axes_internal)\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:349(__init__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1827(set_major_formatter)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:960(y0)\n", + " 286 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:552(formatter)\n", + " 262 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:930(set_clip_rectangle)\n", + " 2 0.000 0.000 0.000 0.000 {built-in method torch.zeros_like}\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset11.py:349(_interpolate)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_binary_ufuncs_impl.py:1()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3123(set_axisbelow)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool_component.py:19(ToolComponent)\n", + " 50 0.000 0.000 0.000 0.000 {method 'remove' of 'list' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/resume_execution.py:33(ReenterWith)\n", + " 18 0.000 0.000 0.000 0.000 {method 'findall' of 're.Pattern' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run.py:30(Run)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_funcs_impl.py:1()\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:754(set_clip_box)\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4430(_generateDefaultName)\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:440()\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/random.py:39(deco_stream)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:222(__init__)\n", + " 183 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:630()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:2166(InliningInstructionTranslator)\n", + " 51 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:239(splitroot)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:18(PolarTransform)\n", + " 38 0.000 0.000 0.000 0.000 :309(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:111()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:13(Level)\n", + " 47 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:357(validate_fontsize)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:123(_SymbolicFunctionGroup)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1701(__init__)\n", + " 150 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1232(__reduce_ex__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1719(__init__)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/getlimits.py:692(max)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:177(Resampling)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1401(MouseButton)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_thread_flow.py:16(ThreadFlow)\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2107(_clip_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:14(Spine)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/autograd/function.py:307(__init__)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_helper.py:1068(_interpolate_helper)\n", + " 172 0.000 0.000 0.000 0.000 :835(__iter__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:247(TorchHigherOrderOperatorVariable)\n", + " 150 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:898(get_position)\n", + " 2 0.000 0.000 0.000 0.000 :110(register)\n", + " 201 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:59(func)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:753()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:64(OverrideDict)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset15.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ExifTags.py:343(Interop)\n", + " 217 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_helper.py:234(parse_args)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:226(set_prop_cycle)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method torch._C._get_operation_overload}\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3461(export)\n", + " 350 0.000 0.000 0.000 0.000 :931(create_module)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3596(ParseExpression)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/_ufunc_config.py:426(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builtin.py:56(BuiltinVariable)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method posix.getcwd}\n", + " 4 0.000 0.000 0.000 0.000 {built-in method torch._C._dispatch_library}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1763(AffineBase)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:309(_convert)\n", + " 156 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:558(__getattr__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:313(select_from)\n", + " 59 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:237(_releaseLock)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/fnmatch.py:74(translate)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext_data.py:464()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/testing.py:15(pyparsing_test)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:297(HammerTransform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/quiver.py:870(Barbs)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:416(LambertTransform)\n", + " 2 0.000 0.000 0.000 0.000 {built-in method _abc._abc_register}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:474(SizeVariable)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_legacy.py:15(deprecated)\n", + " 125 0.000 0.000 0.000 0.000 {built-in method numpy.zeros}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:22(_NodeMissingOnnxShapeInference)\n", + " 196 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:834(get_clip_path)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:249(AitoffTransform)\n", + " 462 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1147(__init__)\n", + " 66 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:356(_aggregate_mutables)\n", + " 44 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1844(set_name)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:273(DefaultsSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/mutation_guard.py:1()\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:264(get_aliased_and_aliases)\n", + " 57 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2463()\n", + " 38 0.000 0.000 0.000 0.000 {method 'splitlines' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/GifImagePlugin.py:39(LoadingStrategy)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1613(__invert__)\n", + " 8 0.000 0.000 0.000 0.000 {built-in method torch._C._dispatch_has_kernel_for_dispatch_key}\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:260(points_to_pixels)\n", + " 136 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1549()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_version_control_details.py:15(VersionControlDetails)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/comptime.py:18(ComptimeVar)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/__init__.py:36(__deprecate_private_class)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pstats.py:68(StatsProfile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1693(Annulus)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2789(_Mode)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:1794(_adaptive_pool)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ExifTags.py:351(IFD)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:849(__init__)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:503(_cmpkey)\n", + " 34 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:297(__getitem__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:934(_scandir)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/_functional_collectives_impl.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_unary_ufuncs_impl.py:1()\n", + " 54 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2345(parseImpl)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_globals.py:1()\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1091()\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3399(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2890(Regex)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:344(MollweideTransform)\n", + " 216 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1757()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2028(_staircase)\n", + " 2 0.000 0.000 0.000 0.000 {built-in method posix.access}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:368(FigureCanvasAgg)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/fx/passes/fake_tensor_prop.py:12(FakeTensorProp)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:964(StepPatch)\n", + " 46 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:515(_from_parsed_parts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:208(__getattr__)\n", + " 31 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/warnings.py:487(__exit__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:168(Transform)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1893(set_major_locator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_content.py:15(ArtifactContent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:188(InvertedPolarTransform)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset10.py:335(_interpolate)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/dicts.py:507(PythonSysModulesVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1823(_MathStyle)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:1716(_avg_pool)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/algorithms/_checkpoint/checkpoint_wrapper.py:16(CheckpointImpl)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:204(TensorProperty)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:201(LogTransform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_properties.py:25(ExternalProperties)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2820(parseImpl)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4739(__init__)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:506(suppress_matplotlib_deprecation_warning)\n", + " 200 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/stride_tricks.py:345()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2177(BlendedGenericTransform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:272(InvertedAitoffTransform)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:755(get_remove_overlapping_locs)\n", + " 122 0.000 0.000 0.000 0.000 {method 'reset' of '_contextvars.ContextVar' objects}\n", + " 84 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:603()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_tensor.py:964(__len__)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1269(_process)\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:686(_register_basic)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:202(SymbolicRegistry)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:763(GraphicsContextBase)\n", + " 62 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:266(_check_generic)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1853(set_minor_formatter)\n", + " 149 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/collections/__init__.py:422()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1814(Affine2DBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_location.py:12(ArtifactLocation)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:3552(_unsupported_dropout)\n", + " 122 0.000 0.000 0.000 0.000 {method 'set' of '_contextvars.ContextVar' objects}\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset10.py:289(_avg_pool)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/types.py:51(DynamoCallbackFn)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:610(Shadow)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:4978(_one_hidden_rnn)\n", + " 21 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/linecache.py:147(lazycache)\n", + " 216 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1756()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_layoutgrid.py:1()\n", + " 244 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:1888(_nonzero_dispatcher)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:383(decorator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:1502(add_gridspec)\n", + " 109 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:772(rotation_point)\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:967(_find_data_repr_)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:316(InvertedHammerTransform)\n", + " 67 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:205()\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:287(wrapper)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5451(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:456(InvertedLambertTransform)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:188(caching_module_getattr)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:363()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_rectangle.py:12(Rectangle)\n", + " 114 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:260()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:209(Quantize)\n", + " 332 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1248(value)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:196(Dither)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:386(InvertedMollweideTransform)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3054(_hash_basis)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1611(set_aspect)\n", + " 244 0.000 0.000 0.000 0.000 {built-in method math.floor}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2698(_Base)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2611(set_layout_engine)\n", + " 96 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1335(set_parse_math)\n", + " 14 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:436()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1909(set_minor_locator)\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/stride_tricks.py:25(_maybe_view_as_subclass)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:139(finalize)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:970(y1)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1138(start)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1265(_set_artist_props)\n", + " 41 0.000 0.000 0.000 0.000 {built-in method _imp.is_builtin}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:99(Disposal)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/utils.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1513(Ellipse)\n", + " 54 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:746()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1176(PolyCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/texmanager.py:56(TexManager)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/mathtext.py:48(__init__)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:918(__init__)\n", + " 196 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:886(get_snap)\n", + " 12 0.000 0.000 0.000 0.000 {method 'cumsum' of 'numpy.ndarray' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4344(ParseElementEnhance)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:52(_process_keys)\n", + " 44 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1150(_generate_next_value_)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_configuration.py:12(ReportingConfiguration)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:924(reset_ticks)\n", + " 57 0.000 0.000 0.000 0.000 {built-in method fromkeys}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_property_file_references.py:15(ExternalPropertyFileReferences)\n", + " 196 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1046(get_hatch_linewidth)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:104(__init__)\n", + " 196 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1038(get_hatch_color)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:243(InvertedLogTransform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:1371(_tzparser)\n", + " 196 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1027(get_hatch)\n", + " 196 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:849(get_dashes)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:583(LogitTransform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:1518(TensorStaticReason)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:381(InvertedSymmetricalLogTransform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4437(IndentedBlock)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:12(MutableLocalSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:58(RendererAgg)\n", + " 97 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5713()\n", + " 226 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:180(open_group)\n", + " 1 0.000 0.000 0.000 0.000 {method '_timer_start' of '_macosx.Timer' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:483(InvertedAsinhTransform)\n", + " 174 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:279(get_fillstyle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_cm.py:66(cubehelix)\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:597(get_url)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:672(get_offset)\n", + " 196 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1050(get_sketch_params)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:464(AsinhTransform)\n", + " 226 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:187(close_group)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:152(validate_axisbelow)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:887(RegularPolygon)\n", + " 2 0.000 0.000 0.000 0.000 {built-in method posix.mkdir}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/GimpGradientFile.py:1()\n", + " 49 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2333(_generateDefaultName)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1837(is_separable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/resume_execution.py:279(ResumeFunctionMetadata)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:328(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:27(ParseResults)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:609(LogisticTransform)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:367(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_cm_listed.py:2061()\n", + " 180 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:355()\n", + " 100 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1455(is_dashed)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset18.py:1()\n", + " 104 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:165(keys)\n", + " 17 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2795(__hash__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_device.py:1()\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:2181(wrap_logical_op_with_negation)\n", + " 55 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:202(_checkLevel)\n", + " 3 0.000 0.000 0.000 0.000 {built-in method torch._C._get_tracing_state}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_run_automation_details.py:12(RunAutomationDetails)\n", + " 289 0.000 0.000 0.000 0.000 {method 'span' of 're.Match' objects}\n", + " 68 0.000 0.000 0.000 0.000 {method 'set_size' of 'matplotlib.ft2font.FT2Font' objects}\n", + " 27 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:176(finalize)\n", + " 6 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(unravel_index)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact.py:17(Artifact)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:1808(getattr_static)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/textpath.py:26(__init__)\n", + " 154 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1700(leave_whitespace)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:1()\n", + " 51 0.000 0.000 0.000 0.000 {built-in method builtins.locals}\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:326(get)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_exporter_states.py:1()\n", + " 67 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:99(deprecated)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/context.py:34(Diagnostic)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:1641(sca)\n", + " 97 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1868(streamline)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:848(limit_range_for_scale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_tritools.py:1()\n", + " 27 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:154(_deprecated_property)\n", + " 29 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:622(name)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_trirefine.py:1()\n", + " 16 0.000 0.000 0.000 0.000 :815(__len__)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:173(__init__)\n", + " 137 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1633()\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5667()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/abc.py:131(TraversableResources)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:608(padded)\n", + " 80 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_ndarray.py:82(create_method)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:105(_set_new_active_manager)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:146()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/onnx_proto_utils.py:1()\n", + " 40 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:2998()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1564(__repr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor.py:17(ReportingDescriptor)\n", + " 53 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:182(_add_module)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_thread_flow_location.py:19(ThreadFlowLocation)\n", + " 2 0.000 0.000 0.000 0.000 <__array_function__ internals>:177(ravel_multi_index)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/_structures.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:1602(RadioButtons)\n", + " 62 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2285(_register_style)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:980(p1)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/optim/optimizer.py:846(add_param_group)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:80(Text)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:1()\n", + " 105 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:88(do_copy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3357(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1152(stop)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:75(nums)\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1147(set_fontweight)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_layout.py:160(get_subplotspec_list)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_region.py:16(Region)\n", + " 44 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:17()\n", + " 37 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:223(get_tick_padding)\n", + " 204 0.000 0.000 0.000 0.000 {method 'ljust' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:617(Final)\n", + " 177 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3035(return_annotation)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:316(_flatten_literal_params)\n", + " 16/4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:84(_convert)\n", + " 21 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:43(update)\n", + " 31 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4100()\n", + " 138 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:227()\n", + " 27 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:389(extended_frame_gen)\n", + " 33 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2119()\n", + " 131 0.000 0.000 0.000 0.000 {method 'items' of 'mappingproxy' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:496(Image)\n", + " 16 0.000 0.000 0.000 0.000 :798(__eq__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:80(_invalidates_cache)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:815(overload_by_arg_count)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/helpers.py:703(OpAssoc)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:85(_listify_validator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/output_graph.py:141(GraphCompileReason)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:120(Blend)\n", + " 135 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3803()\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:832(_reduce_with_dtype)\n", + " 77 0.000 0.000 0.000 0.000 {method 'setter' of 'property' objects}\n", + " 105 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:86(copy)\n", + " 152 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/multiarray.py:668(result_type)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3488(__init__)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1967()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:117(Artist)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:815(Grouper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_enums.py:17(_AutoStringNameEnum)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/isoparser.py:22(_takes_ascii)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2600(_ptp_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/context.py:272(DiagnosticContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph.py:17(Graph)\n", + " 44 0.000 0.000 0.000 0.000 :357(_get_module_path)\n", + " 96 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:605(set_wrap)\n", + " 1 0.000 0.000 0.000 0.000 {method '_timer_stop' of '_macosx.Timer' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3459(__init__)\n", + " 111 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:458(_set_nothing)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triangulation.py:1()\n", + " 31 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/warnings.py:440(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_notification.py:18(Notification)\n", + " 3 0.000 0.000 0.000 0.000 :397(abspath)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1154(set_axes_locator)\n", + " 18 0.000 0.000 0.000 0.000 :794(values)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_code_flow.py:16(CodeFlow)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1683(suppress)\n", + " 54 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:246(get_canvas_width_height)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:2309(_unpack_to_numpy)\n", + " 129 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:17(__getitem__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:32(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3262(__init__)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_common.py:132(_validate_fromutc_inputs)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/numeric.py:2274(_isclose_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:204(Palette)\n", + " 83 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_helper.py:313(quantized_args)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool.py:12(Tool)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1740(tick_values)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:3228(add_axobserver)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:266(validate_color_or_inherit)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1073(Polygon)\n", + " 130 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2328(_any_dispatcher)\n", + " 161 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:196(escape_re_range_char)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_address.py:12(Address)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:405(_generate_overlap_table)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_logging/_internal.py:450(configure_artifact_log)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:231(Japanese)\n", + " 64 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:440(__repr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:15(GeoAxes)\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:167(check_getitem)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:231(__post_init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:641(Path3DCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3757(And)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:262(x1)\n", + " 39 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:877(__hash__)\n", + " 84 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:433()\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:108()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:568(parser)\n", + " 6 0.000 0.000 0.000 0.000 :150(dirname)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:1470(__get_gettz)\n", + " 122 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:133(_unique_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageColor.py:1()\n", + " 27 0.000 0.000 0.000 0.000 {method 'translate' of 'bytearray' objects}\n", + " 57 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:202()\n", + " 114 0.000 0.000 0.000 0.000 {method 'decode' of 'bytes' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:111(GradModeVariable)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:3452(register_extensions)\n", + " 33 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2224(RewriteSymbolics)\n", + " 106 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:807(get_width)\n", + " 137 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/stride_tricks.py:476(_broadcast_arrays_dispatcher)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:3047(get_size_inches)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/numeric.py:2150(identity)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_ufuncs.py:28()\n", + " 89 0.000 0.000 0.000 0.000 {method 'encode' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/actions.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1172(Wedge)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:852(register)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:154(_crc32)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1623(__getitem__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_web_response.py:15(WebResponse)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_replacement.py:16(Replacement)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:83(Unset)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:1373(_result)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:208(register_axis)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:1778(_check_class)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:681(add_parse_action)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:707(scale_factory)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:800(singledispatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:2042(MultiCursor)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_web_request.py:15(WebRequest)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:866(__contains__)\n", + " 21 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:308(wrapper)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1497(__mro_entries__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_ufuncs.py:247()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1880(Circle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/unittest/mock.py:1689(patch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_ops.py:406(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_graph_traversal.py:16(GraphTraversal)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:312(_logged_cached)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/unittest/mock.py:1321(__call__)\n", + " 100 0.000 0.000 0.000 0.000 {method '__exit__' of 'numpy.nditer' objects}\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3297(_generateDefaultName)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2278(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:693(add_condition)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:469(draw_if_interactive)\n", + " 156 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:772(postParse)\n", + " 112 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:429(is_transform_set)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/function_base.py:2269(__init__)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:116(clear)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:554()\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4972(_generateDefaultName)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:846()\n", + " 25 0.000 0.000 0.000 0.000 {built-in method unicodedata.name}\n", + " 112 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1371(get_mouseover)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:1488(CirclePolygon)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:126(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:303(IFDRational)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_cm.py:158()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:3561(_apply_env_variables)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2306(mpl_disconnect)\n", + " 77 0.000 0.000 0.000 0.000 :409(__subclasshook__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:861()\n", + " 134 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:93(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/_common.py:1()\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_guards.py:166(__hash__)\n", + " 65 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:244(__bool__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:1230(exists)\n", + " 21 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:264(__init__)\n", + " 16 0.000 0.000 0.000 0.000 :78(_check_methods)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:987(gcf)\n", + " 75 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:135()\n", + " 28 0.000 0.000 0.000 0.000 {method 'fullmatch' of 're.Pattern' objects}\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:431()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/replay_record.py:41(ExecutionRecorder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colorbar.py:195(Colorbar)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_inductor/config.py:178(decide_compile_threads)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:35(_get_running_interactive_framework)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:3441(register_extension)\n", + " 31 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:106(__hash__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2190(__init__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1560(transform_bbox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_property_bag.py:10(PropertyBag)\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pstats.py:48(__new__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/_util.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1032(enable_packrat)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_compiler.py:389(_bytes_to_codes)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:669(decorator)\n", + " 149 0.000 0.000 0.000 0.000 {method 'pop' of 'collections.deque' objects}\n", + " 78 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:199(get_path)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1570()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/dicts.py:302(DataClassVariable)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/linalg/linalg.py:136(_commonType)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:96(__get__)\n", + " 55 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:795(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:936(PathPatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/current_scope_id.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageMode.py:1()\n", + " 92 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1003(minpos)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:231(_ImageBase)\n", + " 94 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/multiarray.py:1079(copyto)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_logical_location.py:12(LogicalLocation)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/warnings.py:181(_add_filter)\n", + " 61 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/getlimits.py:679(min)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:56(_make_str_method)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_translation_metadata.py:15(TranslationMetadata)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:120(CallbackRegistry)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/distributed_c10d.py:346(__getattribute__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_result_provenance.py:15(ResultProvenance)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:112(__diag__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:3232()\n", + " 24 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2269()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location.py:19(Location)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_message.py:12(Message)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3528(__init__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:799(null)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/twodim_base.py:162(eye)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1761(set_box_aspect)\n", + " 75 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:142()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2142(_set_artist_props)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/table.py:239(Table)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:350()\n", + " 84 0.000 0.000 0.000 0.000 {method 'update' of 'set' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/fx/serialization.py:1()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_compile.py:8(_disable_dynamo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PaletteFile.py:1()\n", + " 28 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:386()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_exception.py:16(Exception)\n", + " 55 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:404()\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2736(axes)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/numeric.py:1878(isscalar)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/_binary.py:101(o32be)\n", + " 106 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/shape_base.py:77(_atleast_2d_dispatcher)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:568(__init__)\n", + " 40 0.000 0.000 0.000 0.000 {method 'startswith' of 'bytes' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:322(condition_as_parse_action)\n", + " 2 0.000 0.000 0.000 0.000 :117(splitext)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:2170(decorator)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:859(set_bounds)\n", + " 59 0.000 0.000 0.000 0.000 {method 'acquire' of '_thread.RLock' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/random.py:70(_seed_custom_device)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1697(set_adjustable)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:45(_compat_get_offset)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:212(_validate_pathlike)\n", + " 105 0.000 0.000 0.000 0.000 {method 'removeprefix' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:45(Tag)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/user_defined.py:188(UserDefinedObjectVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:982(FontManager)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:289(update)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/GimpPaletteFile.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:140(__init__)\n", + " 90 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:842(_hash_set_none)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:421(validate_whiskers)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:687()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:677(Bbox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:749(StixFonts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_physical_location.py:17(PhysicalLocation)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_inductor/__init__.py:1()\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:272(y1)\n", + " 57 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:265()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5044(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_factories.py:26(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/replay_record.py:23(ExecutionRecord)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2676(notify_axes_change)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:100(get_active)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1924(_caller)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_location_relationship.py:12(LocationRelationship)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:171(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:150(TorchFunctionDisableVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_stack_frame.py:12(StackFrame)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_special_locations.py:15(SpecialLocations)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/quiver.py:235(QuiverKey)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:214(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:1872(AppendingTiffWriter)\n", + " 27 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:325(walk_stack)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_suppression.py:12(Suppression)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:257()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:417(_getencoder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2324(new_timer)\n", + " 48 0.000 0.000 0.000 0.000 :315(__subclasshook__)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:3392(register_open)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:1693(_process_projection_requirements)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/warnings.py:165(simplefilter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_reference.py:15(ReportingDescriptorReference)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/testing.py:124(TestParseResultsAsserts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1302(RegularPolyCollection)\n", + " 41 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:262(haskeys)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/mathtext.py:37(MathTextParser)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:77()\n", + " 54 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:805(get_color)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageSequence.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_tool_component_reference.py:12(ToolComponentReference)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_node.py:17(Node)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:259(disconnect)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:41(tzutc)\n", + " 64 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3858()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:1794(_shadowed_dict)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:667(with_name)\n", + " 61 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:368(_intersect1d_dispatcher)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3216(update)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/nn_module.py:66(NNModuleVariable)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:591(__iter__)\n", + " 38 0.000 0.000 0.000 0.000 :260(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/nn_module.py:634(UnspecializedNNModuleVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:624(SkipFilesVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:256(_validate_toolbar)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_edge.py:12(Edge)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_sarif_log.py:16(SarifLog)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:1281(TorchPatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_getlimits.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:906(AnchoredOffsetbox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1909(TriMesh)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_attachment.py:18(Attachment)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset13.py:27(_apply)\n", + " 9 0.000 0.000 0.000 0.000 {method 'clear' of 'collections.OrderedDict' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_reporting_descriptor_relationship.py:16(ReportingDescriptorRelationship)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:510(update)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:345(get_path)\n", + " 47 0.000 0.000 0.000 0.000 {method 'index' of 'list' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_edge_traversal.py:12(EdgeTraversal)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:383(get_snap_threshold)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:194(find_spec)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:445()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1768(EllipseCollection)\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2259(_make_getset_interval)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3055()\n", + " 61 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:761(_isin_dispatcher)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2796()\n", + " 3 0.000 0.000 0.000 0.000 :389(normpath)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:364(get_alt_path)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:152(__contains__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:3125(clear)\n", + " 96 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:199(no_escape_re_range_char)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:594(__len__)\n", + " 61 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/arraysetops.py:519(_in1d_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_common.py:149(_tzinfo)\n", + " 28 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:673()\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4753(_generateDefaultName)\n", + " 68 0.000 0.000 0.000 0.000 {method 'get_descent' of 'matplotlib.ft2font.FT2Font' objects}\n", + " 19 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1229(__hash__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1553(unique)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:62(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:434(BakomaFonts)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:156(update)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:433(__init__)\n", + " 61 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/numeric.py:73(_zeros_like_dispatcher)\n", + " 45 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:452(_parse_letter_version)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:249(validate_backend)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_multiformat_message_string.py:12(MultiformatMessageString)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:286(_validate_color_or_linecolor)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:896(get_drawstyle)\n", + " 36 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:390()\n", + " 39 0.000 0.000 0.000 0.000 {method 'get_width_height' of 'matplotlib.ft2font.FT2Font' objects}\n", + " 5 0.000 0.000 0.000 0.000 {built-in method _warnings.warn}\n", + " 54 0.000 0.000 0.000 0.000 {method '__exit__' of '_thread.RLock' objects}\n", + " 59 0.000 0.000 0.000 0.000 {method 'release' of '_thread.RLock' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset13.py:426(_reduce_with_dtype)\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/types.py:164(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:831(PsfontsMap)\n", + " 61 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/multiarray.py:84(empty_like)\n", + " 47 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4088()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:637(colspan)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/__init__.py:21(__deprecated_private_func)\n", + " 54 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:834(get_alpha)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5509(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_external_property_file_reference.py:15(ExternalPropertyFileReference)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:2126(QuadMesh)\n", + " 12 0.000 0.000 0.000 0.000 {built-in method zlib.crc32}\n", + " 47 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4087()\n", + " 4 0.000 0.000 0.000 0.000 :283(__subclasshook__)\n", + " 24 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:221()\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2530(overload)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:44(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:501(CompilationMetrics)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:31(unicode_set)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:86(_update_methods)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:609(get_markevery)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:183(Line3D)\n", + " 50 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/markers.py:303(get_marker)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:132(tzoffset)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:174(_make_type_validator)\n", + " 49 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1663()\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_logging/_internal.py:85(register_artifact_log)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:9(Gcf)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:631(rowspan)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:239(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:328(add_text)\n", + " 49 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:715()\n", + " 48 0.000 0.000 0.000 0.000 {method 'issuperset' of 'set' objects}\n", + " 66 0.000 0.000 0.000 0.000 {built-in method _warnings._filters_mutated}\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:296(_apply_params)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:990(intervaly)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/types.py:98(prepare_class)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1695(safe_isfinite)\n", + " 1 0.000 0.000 0.000 0.000 {method 'flush' of '_io.BufferedRandom' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_configuration_override.py:16(ConfigurationOverride)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/exceptions.py:19(ParseBaseException)\n", + " 56 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:327(_select_from)\n", + " 42 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:177(__init__)\n", + " 22 0.000 0.000 0.000 0.000 :361(_is_dir)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_conversion.py:17(Conversion)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2498(get_minpos)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:76(Text3D)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:543(_new)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2634(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1223(fields)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4578(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3418(draw_if_interactive)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1590(get_major_locator)\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4370(recurse)\n", + " 36 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:385()\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/re/_parser.py:295(checkgroupname)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_inductor/config.py:311(triton)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageChops.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:88(_finalize_rasterization)\n", + " 9 0.000 0.000 0.000 0.000 :1103(_sanity_check)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/api.py:23(FFI)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1116(__init__)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:198()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_stack.py:16(Stack)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_globals.py:15(_InternalGlobals)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:454(__contains__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:804(PolarAxes)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:233()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_layout.py:226()\n", + " 29 0.000 0.000 0.000 0.000 {method 'get_bitmap_offset' of 'matplotlib.ft2font.FT2Font' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/unittest/mock.py:1271(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:180(DeterministicAlgorithmsVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_factories.py:56(__init__)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:565()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1189(args)\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3532(parseImpl)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:12(__config_flags)\n", + " 58 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:672(flipy)\n", + " 17 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:247(__iter__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:961(_CollectionWithSizes)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/abc.py:14(ResourceReader)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2239(get_label_position)\n", + " 20 0.000 0.000 0.000 0.000 :812(__init__)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5721(token_map)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:440(__getitem__)\n", + " 50 0.000 0.000 0.000 0.000 {method 'insert' of 'list' objects}\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:3058()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_secondary_axes.py:11(SecondaryAxis)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/json/decoder.py:284(__init__)\n", + " 1 0.000 0.000 0.000 0.000 :773(getenv)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:264(__init__)\n", + " 37 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:158()\n", + " 36 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:372()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:522(_push_cm_exit)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method posix.cpu_count}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_artifact_change.py:16(ArtifactChange)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:977(clear)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_enums.py:115()\n", + " 36 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:794(get_window_extent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:102(PrimitiveType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_diagnostic.py:100(__init__)\n", + " 36 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4099()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:409(iscoroutinefunction)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:493(Module_six_moves_urllib)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:633(__init__)\n", + " 1 0.000 0.000 0.000 0.000 {method 'requires_grad_' of 'torch._C._TensorBase' objects}\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_functorch/deprecated.py:20(get_warning)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:131(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/codegen.py:43(PyCodegen)\n", + " 33 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:14(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:1033(_LuatexKpsewhich)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2289(XAxis)\n", + " 35 0.000 0.000 0.000 0.000 {built-in method sys._getframe}\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2592(_check_layout_engines_compat)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/_fix.py:16(Fix)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pstats.py:74(Stats)\n", + " 1 0.000 0.000 0.000 0.000 :422(spec_from_loader)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/unittest/mock.py:1358(decorate_callable)\n", + " 35 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:229(_ishidden)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:62(__init__)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method PIL._imaging.zip_encoder}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/BmpImagePlugin.py:62(BmpImageFile)\n", + " 29 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:820(get_antialiased)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1925(set_pickradius)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:76(_convert_signed_num)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:435(locally_modified_subplot_params)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:292(p1)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:73(ToolBase)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:94(join_parsed_parts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/testing/_internal/logging_tensor.py:44(LoggingTensor)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/onnxruntime.py:128(OrtOperatorSupport)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:234(_has_alpha_channel)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/_deprecate.py:1()\n", + " 23 0.000 0.000 0.000 0.000 {method 'partition' of 'str' objects}\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:222(has_magic)\n", + " 22 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2821()\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset10.py:72(_apply_params)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:439(from_list)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1216(Normalize)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3379(_generateDefaultName)\n", + " 31 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4098()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config_utils.py:52(ConfigModule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/mutation_guard.py:56(GenerationTracker)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:3210(RectangleSelector)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_layout.py:1()\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:797(__iter__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:498(set_useLocale)\n", + " 1 0.000 0.000 0.000 0.000 :933(clear)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:695(__hash__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:221(validate_fonttype)\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:370(__init__)\n", + " 26 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2016()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2741(get_minpos)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:77(__call__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1276(Transform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:2527(YAxis)\n", + " 26 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:388(_delegate)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/replay_record.py:12(ModuleRecord)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_enums.py:181()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:33()\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:70(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/JpegPresets.py:1()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:209()\n", + " 33 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:351()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4895(_generateDefaultName)\n", + " 24 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:188(_dispatch)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:548(from_dict)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:1545(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triangulation.py:8(Triangulation)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4773(stopOn)\n", + " 2 0.000 0.000 0.000 0.000 :121(_splitext)\n", + " 9 0.000 0.000 0.000 0.000 {built-in method _struct.calcsize}\n", + " 2 0.000 0.000 0.000 0.000 :262(__subclasshook__)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:238(__contains__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_tripcolor.py:1()\n", + " 88 0.000 0.000 0.000 0.000 {built-in method builtins.globals}\n", + " 23 0.000 0.000 0.000 0.000 {method 'rsplit' of 'str' objects}\n", + " 43 0.000 0.000 0.000 0.000 {method 'pop' of 'set' objects}\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1787()\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:170(change_key)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:375(ScalarFormatter)\n", + " 24 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2265()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:21(FigureCanvasMac)\n", + " 4 0.000 0.000 0.000 0.000 :362(__subclasshook__)\n", + " 25 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_helper.py:669(_block_list_in_opset)\n", + " 39 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1873(recurse)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3045(QuotedString)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/axis3d.py:732(XAxis)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/relativedelta.py:13()\n", + " 46 0.000 0.000 0.000 0.000 {method 'reverse' of 'list' objects}\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:310(_original_line)\n", + " 21 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:171(__set_name__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:841(_is_union_type)\n", + " 61 0.000 0.000 0.000 0.000 {built-in method _sre.unicode_iscased}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:181(dynamo_timed_inner)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_inductor/config.py:404(trace)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3511(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:2177(_SelectorWidget)\n", + " 20 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1165(get_axes_locator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:531(SubplotSpec)\n", + " 16 0.000 0.000 0.000 0.000 {built-in method _struct.pack}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:665(Colormap)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:283(get_children)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1740()\n", + " 57 0.000 0.000 0.000 0.000 {built-in method _sre.unicode_tolower}\n", + " 22 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3627(recurse)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1263(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:241(parserinfo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:89(__compat__)\n", + " 4 0.000 0.000 0.000 0.000 :60(__getattr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:270(DiagnosticOptions)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:587(ExportOutput)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:960(ImageFileDirectory_v1)\n", + " 3 0.000 0.000 0.000 0.000 {built-in method posix._path_normpath}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/fx/registration.py:35(OpName)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1153(LockableBbox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4866(ZeroOrMore)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:118(set_active)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:532(FontProperties)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2149(SubFigure)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:223()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1565(EventCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:210(_process_plot_var_args)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:545(locator)\n", + " 33 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:370()\n", + " 35 0.000 0.000 0.000 0.000 {method 'bit_length' of 'int' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/logging.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/_functional_collectives.py:304(AsyncCollectiveTensor)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:97(ColorSequenceRegistry)\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:190(set_axis)\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:86(as_list)\n", + " 1 0.000 0.000 0.000 0.000 :1276(__init__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:283(__len__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:72(_convert_num)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:103(OnnxRegistry)\n", + " 8 0.000 0.000 0.000 0.000 :1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:848(AxesImage)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cycler.py:104(Cycler)\n", + " 41 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/_distutils_hack/__init__.py:96()\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:576(_validate_greaterequal0_lessequal1)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:120(__init__)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/linalg/linalg.py:112(_makearray)\n", + " 34 0.000 0.000 0.000 0.000 {method 'groupdict' of 're.Match' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:227(RuleCollection)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:3418(register_save)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1972(_MeshData)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:190(set)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/relativedelta.py:18(relativedelta)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:391(_has_code_flag)\n", + " 4 0.000 0.000 0.000 0.000 {built-in method numpy.core._multiarray_umath.normalize_axis_index}\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:835(load)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:181()\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1273(append)\n", + " 18 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:609(num2)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:131(_validate_date)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:551(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triplot.py:1()\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:33(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1378(LineCollection)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:97(__init__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1310(__init__)\n", + " 1 0.000 0.000 0.000 0.000 :1311(__iter__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/guards.py:809(Replacer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5117(Forward)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/__init__.py:110(get_projection_class)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:119(_resolve)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:236(create_module)\n", + " 10 0.000 0.000 0.000 0.000 :1220(__init__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3304(parseImpl)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset8.py:70(_apply)\n", + " 36 0.000 0.000 0.000 0.000 {method 'end' of 're.Match' objects}\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:556(formatter)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1668(__eq__)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method time.localtime}\n", + " 5 0.000 0.000 0.000 0.000 :818(fsdecode)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/dicts.py:438(HFPretrainedConfigVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/axis3d.py:740(YAxis)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_VF.py:26(__getattr__)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2883(_namedtuple_mro_entries)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:74(__lt__)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:568(_validate_greaterthan_minushalf)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImagePalette.py:25(ImagePalette)\n", + " 42 0.000 0.000 0.000 0.000 {method 'upper' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:517(CleanupHook)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/constant.py:29(ConstantVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/_binary.py:1()\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:85(_import_module)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:844(Poly3DCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cm.py:390(ScalarMappable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2354(Keyword)\n", + " 7 0.000 0.000 0.000 0.000 {method 'seek' of '_io.BufferedReader' objects}\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:702(get_scale_names)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:124()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2189(runtime_checkable)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/decorators.py:147(forbid_in_graph)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:125(Element)\n", + " 30 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/function_base.py:18(_linspace_dispatcher)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1603(get_aspect)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1305(EngFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:366(backend_mod)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_logging/_internal.py:100(is_off_by_default)\n", + " 22 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3361()\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:74(get_geometry)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method torch._C._log_api_usage_once}\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1744(_fix_ipython_backend2gui)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:442()\n", + " 37 0.000 0.000 0.000 0.000 {method 'clear' of 'dict' objects}\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:3407(register_mime)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1794()\n", + " 2 0.000 0.000 0.000 0.000 :1293(_get_parent_path)\n", + " 6 0.000 0.000 0.000 0.000 :760(decode)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4983(SkipTo)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:1766(_static_getmro)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/__init__.py:7(is_available)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:64(Rule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:815(LogFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_afm.py:358(AFM)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/jit_utils.py:23(GraphContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_managers.py:32(ToolManager)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:1729()\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:535(__init__)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:227()\n", + " 2 0.000 0.000 0.000 0.000 :786(keys)\n", + " 2 0.000 0.000 0.000 0.000 {method 'manual_seed' of 'torch._C.Generator' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1884(Affine2D)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:765(_validate_legend_loc)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:1418(_rrulestr)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method torch._C._get_schema}\n", + " 13 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_deprecation.py:8(deprecated)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:512(__init__)\n", + " 1 0.000 0.000 0.000 0.000 {method '_set_window_mode' of '_macosx.FigureManager' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_analysis.py:21()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1512(CenteredNorm)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3321(White)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:2452(_unit_change_handler)\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:374(validate_fontweight)\n", + " 24 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:617(get_gridspec)\n", + " 21 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:305(_export)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:418(__getattr__)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1798(get_anchor)\n", + " 1 0.000 0.000 0.000 0.000 :1037(_resolve_name)\n", + " 1 0.000 0.000 0.000 0.000 :100(split)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/tensor.py:56(TensorVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1077(TransformedBbox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:103(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/axis3d.py:748(ZAxis)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5456(postParse)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1494(__or__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_diagnostic.py:81(ExportDiagnosticEngine)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/__init__.py:106(__version__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2613(Word)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3380(_Backend)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/stackplot.py:1()\n", + " 3 0.000 0.000 0.000 0.000 :381(__subclasshook__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:1787(_is_type)\n", + " 1 0.000 0.000 0.000 0.000 :39(isdir)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:31(iglob)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:1950(InstructionTranslator)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:53(__get__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:360(PngStream)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4066(MatchFirst)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2579(FigureManagerBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:32()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cm.py:59(ColormapRegistry)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:231(_normalize)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:527(_push_exit_callback)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:42(_MissingCustomSymbolicFunction)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1685(TransformWrapper)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method PIL._imaging.map_buffer}\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1689()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_common.py:267(tzrangebase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/collections/__init__.py:585(__init__)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_guards.py:190(source)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_globals.py:22(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:2278(LightSource)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:966(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1255(__mro_entries__)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config_utils.py:208(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/dicts.py:26(ConstDictVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:958(LinearSegmentedColormap)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2204(_Style)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:523(Ticker)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/threading.py:90(RLock)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:228()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1106(__init__)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1720(getEffectiveLevel)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_inductor/config.py:262(cpp)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1267(__init__)\n", + " 32 0.000 0.000 0.000 0.000 {built-in method _operator.index}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:182()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:183()\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:434()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_layout.py:76()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:386(tzfile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/ast.py:67(_raise_malformed_node)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/linalg/linalg.py:117(isComplexType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:279(ConstPointerType)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_layout.py:238()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/category.py:26(StrCategoryConverter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:286(CubicTriInterpolator)\n", + " 3 0.000 0.000 0.000 0.000 {method 'tolist' of 'memoryview' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/mutation_guard.py:10(MutationTracker)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:134(__getattr__)\n", + " 1 0.000 0.000 0.000 0.000 {method 'setimage' of 'ImagingEncoder' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_adapters.py:114(OrphanPath)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/__init__.py:75(register)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:674(get_topmost_subplotspec)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:491(_parse_local_version)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:9(__init__)\n", + " 14 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/_common.py:9(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:172(Stack)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:109(OptimizedModule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/textpath.py:20(TextToPath)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_layoutgrid.py:31(LayoutGrid)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/units.py:108(ConversionInterface)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/mlab.py:770(GaussianKDE)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:138()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1427(exec_body_callback)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:2573()\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:243(generic_jump)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:645(RcParams)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:3597(Exif)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4522(AtLineStart)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:62(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:595(DrawingArea)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:524(__init__)\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:224(__set_name__)\n", + " 12 0.000 0.000 0.000 0.000 :7(abstractmethod)\n", + " 15 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:1238()\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:579(_update_clip_properties)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:1755(have_units)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:198()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:2875(_check_size)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/shlex.py:19(shlex)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:725(_NoopSaveInputs)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_inductor/config.py:169(is_fbcode)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:406(_validate_mathtext_fallback)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:477(QName)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/GifImagePlugin.py:63(GifImageFile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1193(kwargs)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_type_utils.py:292()\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/traceback.py:307(__len__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:787(parents)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1962(MaxNLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:754()\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:726(get_figure)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:548(ColorConverter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:125()\n", + " 16 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:518()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:858(validate_hist_bins)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:72(colorbar_gridspec)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:460(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/comptime.py:112(ComptimeContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/lock.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1167(interval)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:498(_ThetaShift)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/user_defined.py:577(KeyedJaggedTensorVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:149(FigureManagerMac)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/weakref.py:495(popitem)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2704(LogitLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2592(AsinhLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:73(_AxesStack)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:205(load_module)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:394(_ymd)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:190()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/container.py:5(Container)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:2056(__init__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:1023(get_fignums)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:244(DType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:420(major)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:164(_resolve)\n", + " 23 0.000 0.000 0.000 0.000 {built-in method _stat.S_ISLNK}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/output_graph.py:1132(SubgraphTracer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/_structures.py:6(InfinityType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2445(CompositeAffine2D)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3225(ToolContainerBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2369(Ellipse)\n", + " 1 0.000 0.000 0.000 0.000 :1297(_recalculate)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:570(Stack)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_bbox.py:1()\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:790(get_scale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_tritools.py:11(TriAnalyzer)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_logging/_internal.py:115(is_artifact_enabled)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/sarif/version.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:1767(C14NWriterTarget)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:723(PngImageFile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PaletteFile.py:19(PaletteFile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:1059(TiffImageFile)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:38(_ignore_error)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config.py:264(is_fbcode)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/linalg/linalg.py:107(get_linalg_error_extobj)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:218(TensorPropertySource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:106()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:100(add)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/linalg/linalg.py:186(_assert_stacked_square)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_type_utils.py:366()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:71(DefaultDeviceType)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:55()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:238(HandlerLine2DCompound)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_guards.py:186(name)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/output_graph.py:163(FakeRootModule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:494(GetAttrVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:522(Spines)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/backends/registry.py:9(CompiledFn)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/functions.py:560(CollectiveFunctionRewriteVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1458(PercentFormatter)\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:1465()\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:241(__len__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:319(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1402(_fixupChildren)\n", + " 1 0.000 0.000 0.000 0.000 :1081(__subclasshook__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_ops.py:41(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:308(add_module_init_func)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/guards.py:795(Config)\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1895(device_pixel_ratio)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:201(tzlocal)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:219(is_package)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:748(_WedgeBbox)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2833()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:347(__exit__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_type_utils.py:317()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/tensor.py:666(SymNodeVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:1141(OffsetImage)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_inductor/test_operators.py:13(Realize)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1181(single_shot)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1751(ParserState)\n", + " 8 0.000 0.000 0.000 0.000 :1224(__eq__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/torch.py:138(TorchVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1109(LogitFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/__init__.py:99(version_info)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:706(isDefault_majloc)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/tensor.py:1018(TensorSubclassVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_version.py:1()\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:452(set_useOffset)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/_weakrefset.py:173(__eq__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/unittest/mock.py:1602(_get_target)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/output_graph.py:175(WrapperBackend)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:65(_BaseVersion)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:254(iTXt)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:126()\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3380()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/contour.py:1481(QuadContourSet)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:896(ToolHelpBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:1458(DraggableBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:421(buffer_rgba)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:251(CommonListMethodsVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:198(Formatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cm.py:83(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:65(Text)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_layout.py:239()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:707(TextArea)\n", + " 12 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/fromnumeric.py:2519(_cumsum_dispatcher)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/linalg/linalg.py:180(_assert_stacked_2d)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:121(BlockStackEntry)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:534(Patch3DCollection)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:225(_clear)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/external_utils.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:220(_TorchDynamoContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/_structures.py:35(NegativeInfinityType)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1014(minposx)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1444(_AnnotationBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:1167(_tzicalvtz)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:1475(GettzFunc)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:361(HandlerStepPatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:140(PolarAffine)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/types.py:77(resolve_bases)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:884(FXGraphExtractor)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:273(ExportOptions)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3911(Or)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:561(_from_subplot_args)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:714(isDefault_majfmt)\n", + " 8 0.000 0.000 0.000 0.000 {built-in method math.isfinite}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_deprecation.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:45(InputAdapter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:1174(CompileProfiler)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:347(ListVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:94(rrulebase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4591(PrecededBy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:124(Circles)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1748(CircleCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:158(ToolToggleBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:77(destroy_all)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:1388(BboxImage)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3410(set_axis_on)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:186(_get_module)\n", + " 20 0.000 0.000 0.000 0.000 {method '__init_subclass__' of 'object' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_diagnostic.py:43(TorchScriptOnnxExportDiagnostic)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/guards.py:165(GuardCodeList)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:2434(InliningGeneratorInstructionTranslator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1417(TwoSlopeNorm)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:409(SymmetricalLogScale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2159(_BlendedMixin)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4907(Opt)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1467(AxLine)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1192(RRuleLocator)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:201(_is_param_expr)\n", + " 7 0.000 0.000 0.000 0.000 {method 'index' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:265(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:391(OptimizeContext)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:3429(register_save_all)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:85(ImageFile)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:78(limit_range_for_scale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:709(ToolZoom)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:66(Widget)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1410(Hrule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:27(LayoutEngine)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2904(set_canvas)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1778(DateConverter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:232(LinearTriInterpolator)\n", + " 17 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:2744(annotation)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:855(_set_autoscale_on)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/linalg/linalg.py:130(_realType)\n", + " 17 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/dataclasses.py:179(__repr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/tensor.py:971(UnspecializedPythonVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/distributed.py:133(DeviceMeshVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:525(ElementTree)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1752(LinearLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5554(Suppress)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3136(_Base)\n", + " 9 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:2678(get_layout_engine)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/__init__.py:23(_running_with_deploy)\n", + " 6 0.000 0.000 0.000 0.000 {method 'join' of 'bytes' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_constants.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:135(Location)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:764(_get_backend_or_none)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:162(ChunkStream)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:499(AsinhScale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:221(Fonts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:540(UnicodeFonts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:824(AuxTransformBox)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2269(_generateDefaultName)\n", + " 11 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1001()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:543(validate_bbox)\n", + " 3 0.000 0.000 0.000 0.000 {method 'index' of 'tuple' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pstats.py:58(FunctionProfile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/functions.py:101(UserFunctionVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/tensor.py:727(TensorWithTFOverrideVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:494(MapHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:677(_Stack)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5373(Combine)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1368(StarPolygonCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:2239(PolyQuadMesh)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3207(_Curve)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:1188(PcolorImage)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:402(ThetaAxis)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config_utils.py:19(ConfigModuleInstance)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/types.py:63(DynamoGuardHook)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:688(clear)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2863(Char)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/textpath.py:293(TextPath)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:169(_SixMetaPathImporter)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/__init__.py:43(private_class)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:2372(get_origin)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/cuda/__init__.py:68(queue_seed_all)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:386(DequeVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:1112(CheckpointHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:27(classproperty)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2525(BboxTransform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2499(CaselessKeyword)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:457(ToolViewsPositions)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:318(GridSpec)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/data/datapipes/_typing.py:221(__eq__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:367(ExactWeakKeyDictionary)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/user_defined.py:39(UserDefinedClassVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/distributed.py:157(ProcessGroupVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/__init__.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:83()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:12(qualify)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4177(Each)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/pyplot.py:200(install_repl_displayhook)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_adapters.py:48(SpecPath)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/optimizer.py:25(OptimizerVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2663(ScaledTranslation)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/__init__.py:56(fget)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:127()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/unittest/mock.py:68(_is_instance_mock)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:324(ResolvedExportOptions)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset11.py:89(_apply_params)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:191(CheckpointFunction)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/algorithms/_checkpoint/checkpoint_wrapper.py:108(CheckpointWrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/dicts.py:246(DefaultDictVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:221(DisabledSavedTensorsHooksVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:419(AutogradFunctionContextVariable)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:557(validate_sketch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:345(StructOrUnion)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4714(NotAny)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/lines.py:1602(VertexSelector)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/image.py:1325(FigureImage)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:94(bubble)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:730(isDefault_minfmt)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/streamplot.py:259(DomainMap)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_trirefine.py:47(UniformTriRefiner)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:899(_is_typevar_like)\n", + " 2 0.000 0.000 0.000 0.000 {built-in method time.time}\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:793(_reduce_op_symbolic)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/symbolic_convert.py:382(break_graph_if_unsupported)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:704(FlattenInputOutputSignature)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builder.py:1608(SourcelessBuilder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:2175(_backend_module_name)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4501(AtStringStart)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:329(TruetypeFonts)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:545(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:122(set_height_ratios)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:80(_add_doc)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:78(add)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pstats.py:36(SortKey)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:456(TupleVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:22(ContextWrappingVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/distributed.py:82(PlacementVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:233(__getattr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2568(BboxTransformTo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2627(BboxTransformFrom)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2220(_PendingSkip)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4862(_generateDefaultName)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:903(FontConstantsBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:405(XTick)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:1112(_iterinfo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:1215(_Sparse_Matrix_coo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:699(RadialAxis)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:412(Patch3D)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/fx/_compatibility.py:7(compatibility)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset8.py:76(_interpolate)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:2059(_interpolate)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_transformation.py:17(InstructionExnTabEntry)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_analysis.py:174(StackSize)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:315(GetItemSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/operators.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/distributed.py:49(PlacementClassVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:261(LogScale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2689(AffineDeltaTransform)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3241(CharsNotIn)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1373(AsteriskPolygonCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:830(ToolPan)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2044()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:613(num2)\n", + " 8 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:722(isDefault_minloc)\n", + " 3 0.000 0.000 0.000 0.000 {built-in method sys.exc_info}\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset8.py:67(_apply_params)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:62(_MissingStandardSymbolicFunction)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:149(guard_source)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:762(SetElement)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:432(validate_ps_distiller)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:358(Parser)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_factories.py:9(__init__)\n", + " 7 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:851()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:434(__len__)\n", + " 1 0.000 0.000 0.000 0.000 {method 'title' of 'str' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:98(OutputAdapter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/convert_frame.py:75(Tracker)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/functions.py:364(NestedUserFunctionVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:359(CUDAStreamContextVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/distributed.py:12(DistributedVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:1384(TreeBuilder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:453(_E)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:25(BaseTypeByIdentity)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:159(_DummyAxis)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1093(set_label)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:642(ZoomPanBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:527(PaddedBox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:462(YTick)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:985(_DOF_estimator)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:886(__repr__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:304(__init__)\n", + " 3 0.000 0.000 0.000 0.000 {method 'cast' of 'memoryview' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/functions.py:264(UserMethodVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:272(AutocastModeVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/_functional_collectives_impl.py:30(_WaitRegistration)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:1506(XMLParser)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/_util.py:5(is_path)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colorbar.py:146(_ColorbarAxesLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1308(Vlist)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/__init__.py:69(ProjectionRegistry)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1662(_value_and_type_iter)\n", + " 5 0.000 0.000 0.000 0.000 {method 'discard' of 'set' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:274(_FxNodeInsertTypePromotion)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/onnxruntime.py:489(OrtExecutionInfoForAllGraphModules)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:14(generic)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:61(_ColorMapping)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2438(SymmetricalLogLocator)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:1025(minposy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1008(PathCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1068(Char)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:132(TightLayoutEngine)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_adapters.py:83(ChildPath)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1116(DateLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:15(TriInterpolator)\n", + " 2 0.000 0.000 0.000 0.000 :1283(_find_parent_path_names)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:212(InspectSignatureVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:2055(_OrderedSet)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/common.py:88(_generate_etree_functions)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1121(ListedColormap)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4555(FollowedBy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:211(ConstrainedLayoutEngine)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:1399(ArtistList)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_common.py:13(tzname_in_python2)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:92(_OperatorSupportedInNewerOpsetVersion)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:126(_FxGraphToOnnx)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_ndarray.py:47(Flags)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/testing/_internal/logging_tensor.py:93(LoggingTensorReentrant)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:26(SuperVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2719(TransformedPath)\n", + " 3 0.000 0.000 0.000 0.000 {method 'dim' of 'torch._C._TensorBase' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:163(Button)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/__init__.py:85(get_projection_names)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:724(__init__)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1795(is_saving)\n", + " 10 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:71()\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/convert_frame.py:76(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:146(_FxNodeToOnnx)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:166(_FxPass)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:234(_OpLevelDebugging)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:294(_FindOperatorOverloadsInOnnxRegistry)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:80(LocalSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/_device.py:58(DeviceContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:113(GeneratorStateSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:473(ConstantSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:204(RangeVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/codegen.py:33(GraphOutputEntry)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1840(SymLogNorm)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1878(AsinhNorm)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:3473(register_decoder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/common.py:25(DTDForbidden)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:298(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:11(_ParseResultsWithOffset)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:245(ToolSetCursor)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:573(DviFont)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/category.py:138(StrCategoryFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:219(_resultbase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:46(HandlerBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_trifinder.py:27(TrapezoidMapTriFinder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:223(_GeoTransform)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:277(option_image_nocomposite)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/JpegImagePlugin.py:346(JpegImageFile)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method torch._C._mps_is_in_bad_fork}\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:479(__repr__)\n", + " 6 0.000 0.000 0.000 0.000 {built-in method _stat.S_ISDIR}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:206(_UnsupportedFxNodeAnalysis)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:254(_FindOpschemaMatchedSymbolicFunction)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:60(MutableLocal)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/functions.py:80(BaseUserFunctionVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:684(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1910(PowerNorm)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:539(size)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1849(PatchCollection)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:82(adjust_compatible)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:781(get_subplotspec)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:258(_AxisWrapper)\n", + " 4 0.000 0.000 0.000 0.000 :2(__eq__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:207(Graph)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_rules.py:186(_NoSymbolicFunctionForCallFunction)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:557(LargeProtobufExportOutputSerializer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:264(DuplicateWarningChecker)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:413(ODictGetItemSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/tensor.py:869(NumpyNdarrayVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:576(NamedTupleVariable)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:611(_validate_minor_tick_ndivs)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:160(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:29(ScaleBase)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3476(Show)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:664(Vf)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:266(SliderBase)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:647()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/_common.py:6(weekday)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:874(tzrange)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1866(_SwitchableDateConverter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:449(RadialLocator)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method posix.register_at_fork}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/fx/registration.py:18(ONNXFunction)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_transformation.py:347(ExceptionTableEntry)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:1295()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:51(ValidateInStrings)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1568(Locator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/testing.py:20(reset_pyparsing_context)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:97(RasterParse)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:28(LockDraw)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:328(_ttinfo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1707(MicrosecondLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_factories.py:13(__call__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:305(rrule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:372(Line3DCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PpmImagePlugin.py:149(PpmPlainDecoder)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py:1319(disable)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/multiarray.py:1029(unravel_index)\n", + " 4 0.000 0.000 0.000 0.000 {built-in method sys.audit}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/tensor.py:1004(FakeItemVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:126(ComptimeVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:809(NumpyVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:92(_StrongRef)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:285(add)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:123(FuncTransform)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1108(get_zorder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/text.py:1370(OffsetFrom)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:75(VectorParse)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:121(SubplotParams)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:129(_LazyModule)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:668(_register_loader)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:427(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:49(PatchedPropertyBag)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:369(FlattenInputWithTreeSpecValidationStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:914(Exporter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config_utils.py:202(SubConfigProxy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:1711(numpy_method_wrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_analysis.py:128(ReadsWrites)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/guards.py:800(ExprCounter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/types.py:25(GuardFail)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:95(RandomValueSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:130(GlobalSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:173(AttrSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:390(SuperSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/constant.py:164(EnumVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:667(ListIteratorVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/side_effects.py:25(MutableSideEffects)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:103(__eq__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:387(validate_fontstretch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/ElementTree.py:79(DefusedXMLParser)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:490(EnumType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:673(PyDecoder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:722(PyEncoder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:159(FuncScale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2524(CloseMatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3543(WordStart)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5363(TokenConverter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colorbar.py:123(_ColorbarSpine)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1186(add_callback)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1409(MouseEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:420(AxisScaleBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:179(FontMetrics)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:672(DejaVuFonts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1496(Kern)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_bbox.py:31()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:1567(DraggableOffsetBox)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:4002(set_navigate_mode)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:880(add_metaclass)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:1315(_genitem)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/streamplot.py:322(Grid)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:462(PathPatch3D)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:264(buffer_rgba)\n", + " 3 0.000 0.000 0.000 0.000 {method 'copy' of 'mappingproxy' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:336(NullContextVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:1272(XMLPullParser)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2790(TransformedPatchPath)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2583(Sawtooth)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1206(Hlist)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/category.py:168(UnitData)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:656(ConciseDateFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1268(AutoDateLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:430(HandlerRegularPolyCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:118(NavigationToolbar2Mac)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:232(_BackendMac)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:845(_is_valid_dispatch_type)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:442(WithExitFunctionVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffTags.py:23(TagInfo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:601(PyCodec)\n", + " 2 0.000 0.000 0.000 0.000 {method 'pixel_access' of 'ImagingCore' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2299(Literal)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5430(Group)\n", + " 6 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_enums.py:20(_generate_next_value_)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1632(_draw)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1246(Event)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:211(FontInfo)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/__init__.py:81(get_projection_class)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:34(_axis_method_wrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend.py:54(DraggableLegend)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:995(rrulewrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_tricontour.py:8(TriContourSet)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:679(_register_writer)\n", + " 5 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/TiffImagePlugin.py:680(decorator)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:3986(set_navigate)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/lib/function_base.py:1316(_diff_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 {method 'squeeze' of 'numpy.ndarray' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:189(ThreadFlowLocation)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:1730(numpy_operator_wrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:1834(_Anchors)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:75(Unsupported)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:257(NegateSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:367(TypeSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:626(SliceVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:421(CUDAStreamVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/common.py:56(ExternalReferenceForbidden)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:276(PngInfo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:628(LogitScale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:125(LRUMemo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:33(get_fig_manager)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:38(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/spines.py:487(SpinesProxy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:3696(EllipseSelector)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/units.py:135(DecimalConverter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:1253(tzical)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:156(GlobalWeakRefSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:250(AutogradFunctionVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:134(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1915(_Edge_integer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3405(GoToColumn)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:360(ToolQuit)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_tight_bbox.py:37()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:1098(AnchoredText)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:476(GridSpecFromSubplotSpec)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:310(ThetaTick)\n", + " 3 0.000 0.000 0.000 0.000 {method '__array_prepare__' of 'numpy.ndarray' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:343(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/fx/patcher.py:19(ONNXTorchPatcher)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:72(int8)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:182(KeyErrorMsg)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:766(TypingVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:915(GrouperView)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:76(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:333(silent_list)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1991(BoundaryNorm)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:1105(_ListDataStream)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:2119(NoNorm)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:310(FuncScaleLog)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/GimpPaletteFile.py:22(GimpPaletteFile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1687(FixedLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1833(MultipleLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:282(p0)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2472(CaselessLiteral)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/actions.py:7(OnlyOnce)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:304(ToolCursorPosition)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3221(set_history_buttons)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:120(Output)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1139(Accent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1010(Node)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1162(List)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1428(_GlueSpec)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:106(PlaceHolderLayoutEngine)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:110(AxesWidget)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/category.py:118(StrCategoryLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:108(MovedModule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:626(DateFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:521(HandlerErrorbar)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:1156(_DOF_estimator_min_E)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:628(HandlerStem)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:281(ThetaLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:548(RadialTick)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PpmImagePlugin.py:53(PpmImageFile)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:274(release)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:163(StackFrame)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_exporter_states.py:8(ExportTypes)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset13.py:411(_reduce_op_symbolic)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/ctx_manager.py:67(GenericContextWrappingVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:6(Substitution)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:294(ArrayType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:328(StubImageFile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2261(Token)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2397(LArrow)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3762(Wedge)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1033(Box)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:420(PackerBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:1071(_DOF_estimator_geom)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/streamplot.py:380(StreamMask)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/errors.py:38(UnsupportedOperatorError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:543(ProtobufExportOutputSerializer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_analysis.py:169(FixedPointBox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:23(MutableLocalBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/replay_record.py:18(DummyModule)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:163(validate_dpi)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:64(_ArtistPropertiesSubstitution)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageMode.py:22(ModeDescriptor)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:224(RawFunctionType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:328(StructOrUnionOrEnum)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageSequence.py:19(Iterator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:355(StrMethodFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:270(FixedFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2872(AutoMinorLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:332(RubberbandBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:437(ToolYScale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:600(ToolHome)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:609(ToolBack)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:939(ComputerModernFontConstants)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:713(DejaVuSerifFonts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:100(set_width_ratios)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:178(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:1036(tzstr)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:398(HandlerLineCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_trifinder.py:7(TriFinder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:166(HandlerNpoints)\n", + " 3 0.000 0.000 0.000 0.000 {built-in method atexit.register}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:1630(_simple_enum)\n", + " 1 0.000 0.000 0.000 0.000 {method 'pop' of 'collections.OrderedDict' objects}\n", + " 1 0.000 0.000 0.000 0.000 :52(normcase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/unittest/mock.py:1257(_check_spec_arg_typos)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset9.py:2168(wrap_logical_op_with_cast_to)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_funcs.py:51(IndexExpression)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:125(UserError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:1391(suppress_torch_distributed_warnings)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/types.py:45(GuardedCode)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:144(DummyGlobalSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:490(NumpyTensorSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/base.py:94(HasPostInit)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/functions.py:313(WrappedUserMethodVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/common.py:18(DefusedXmlException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:178(UnknownIntegerType)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:96(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1658(IndexLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3569(WordEnd)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:155(Greek)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2284(NoMatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3483(LineEnd)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:845(get_animated)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:380(ToolGrid)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:934(ToolCopyToClipboardBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1448(Glue)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_adapters.py:7(SpecLoaderAdapter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/_base.py:95(_TransformedBoundsLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:1592(DraggableAnnotation)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:1589(ParserError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1501(YearLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/rrule.py:66(weekday)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:208(HandlerNpointsYoffsets)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:314(HandlerPatch)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:37()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:540(_BackendAgg)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:972(__set_name__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_funcs.py:59(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:87(ONNXFakeContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:536(CleanupManager)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:998(_recomputation_hook)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:884(NullVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/common.py:39(EntitiesForbidden)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/_util.py:14(DeferredError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:72(BaseType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/scale.py:89(LinearScale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:262(NullFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2271(BlendedAffine2D)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:192(_should_enable_warnings)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/exceptions.py:256(RecursiveGrammarException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:130(BasicMultilingualPlane)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3506(StringStart)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4443(_Indent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3511(BracketAB)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/widgets.py:1877(SubplotTool)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/style/core.py:217(update_nested_dict)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:876(AutoDateFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/container.py:42(BarContainer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/enum.py:809(__members__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/context.py:264(RuntimeErrorWithDiagnostic)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_exporter_states.py:17(SymbolicContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:174(BindInputStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:1043(OnnxExporterError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:1689(numpy_to_tensor_wrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pstats.py:522(TupleComp)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:180(dynamo_timed)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:48(InvalidBackend)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:757(ExportResult)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:1015(WrapHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:483(LambdaVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:85(VoidType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:192(UnknownFloatType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:1092(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:1100(_fdat)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:257(_set_locator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:164(UnboundedMemo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:143(LatinA)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3775(_ErrorStop)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3436(LineStart)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5467(Dict)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/collections.py:1275(BrokenBarHCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1089(get_label)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:148(SmallFilledCircles)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/contour.py:29(ClabelText)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:3484(ShowBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:370(ToolQuitAll)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:395(ToolMinorGrid)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:410(ToolFullScreen)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:447(ToolXScale)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:618(ToolForward)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2476(Round)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3674(Fancy)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1390(Rule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_managers.py:13(ToolTriggerEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/__init__.py:8(_SubplotBaseMeta)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:572(__init__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:199(__get_module)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:245(_MovedItems)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:91(_LazyDescr)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_factories.py:8(_TzSingleton)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/geo.py:18(ThetaFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/streamplot.py:249(StreamplotSet)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:719(HandlerTuple)\n", + " 4 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:5602(postParse)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:450(_create_exit_wrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1130(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/_beartype.py:61(_create_beartype_decorator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/bytecode_transformation.py:82(_NotProvided)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:152(name)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:353(TupleIteratorGetItemSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:440(NNModuleSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:615(PythonModuleVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:193(InlinedClosureVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:20(MatplotlibDeprecationWarning)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:85(List)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3523(StringEnd)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:1378(_attr)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/types.py:130(_calculate_meta)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/functools.py:421(_unwrap_partial)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/typing.py:1544(__repr__)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/linalg/linalg.py:465(_unary_dispatcher)\n", + " 1 0.000 0.000 0.000 0.000 {method 'popitem' of 'dict' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:26(InputAdaptStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:457(FlattenOutputWithTreeSpecValidationStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/config_utils.py:167(ContextDecorator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:78(int16)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/utils.py:269(reset)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:432(RunOnlyContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:441(DisableContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/testing/_internal/logging_tensor.py:141(GatherTraceback)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/algorithms/_checkpoint/checkpoint_wrapper.py:99(OffloadWrapper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:506(ShapeEnvSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/side_effects.py:38(AttributeMutation)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:183(ClosureVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:282(__init__)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:341(validate_aspect)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementPath.py:350(_SelectorContext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:261(PointerType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/error.py:5(CDefError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/GimpGradientFile.py:66(GradientFile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:8(_lazyclassproperty)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:195(Cyrillic)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:235(Kanji)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:254(Katakana)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:293(Thai)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2273(Empty)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4449(_IndentGreater)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:14(HorizontalHatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1484(PickEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:634(SaveFigureBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1629(Done)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:910(_JSONEncoder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2325(Square)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3473(BracketA)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:731(DejaVuSansFonts)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/figure.py:82(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/importlib/resources/_adapters.py:20(TraversableResourcesLoader)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axis.py:564(_LazyTickList)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/units.py:72(AxisInfo)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:144(MovedAttribute)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1839(ConciseDateConverter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:772(HandlerPolyCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/mpl_toolkits/mplot3d/art3d.py:347(Collection3D)\n", + " 4 0.000 0.000 0.000 0.000 {method 'remove' of 'set' objects}\n", + " 1 0.000 0.000 0.000 0.000 {method 'isdisjoint' of 'set' objects}\n", + " 1 0.000 0.000 0.000 0.000 {built-in method torch._C._dynamo.eval_frame.set_guard_error_hook}\n", + " 2 0.000 0.000 0.000 0.000 {built-in method matplotlib._c_internal_utils.display_is_valid}\n", + " 3 0.000 0.000 0.000 0.000 :2(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/__init__.py:346(ExecutableNotFoundError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/errors.py:26(OnnxExporterError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/errors.py:62(SymbolicValueError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/_beartype.py:51(CallHintViolationWarning)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:495(ExportOutputSerializer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/exporter.py:1035(UnsatisfiedDependencyError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:81(OutputAdaptStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:228(LiftParametersAndBuffersIntoArgsStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:107(CondOpArgsMismatchError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:97(ArgsMismatchError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/testing/_internal/logging_tensor.py:85(LoggingTensorMode)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/types.py:75(ProfilerStartHook)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:464(GlobalStateSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/functions.py:330(WrappedUserFunctionVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/nn_module.py:780(FSDPManagedNNModuleVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/side_effects.py:54(AttributeMutationNew)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:747(_DunderChecker)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:223(deprecate_privatize_attribute)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/__init__.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:590(PyCodecState)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1732(NullLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:304(FuncFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:149(LatinB)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:242(Hiragana)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:308(Hebrew)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4899(_NullToken)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cm.py:95(__iter__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:87(Shapes)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:132(SmallCircles)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:111(_Unset)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1288(DrawEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1315(ResizeEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3595(Simple)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2763(Arc3)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3434(Curve)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3573(CurveBracket)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1563(AutoWidthChar)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:950(STIXFontConstants)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_managers.py:4(ToolEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:467(VPacker)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:340(Module_six_moves_urllib_parse)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1683(SecondLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/container.py:109(StemContainer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/polar.py:241(ThetaFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_trirefine.py:12(TriRefiner)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/BmpImagePlugin.py:362(DibImageFile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/threading.py:1174(native_id)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/infra/_infra.py:263(Invocation)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/registration.py:210(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/types.py:84(ProfilerEndHook)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:452(NotNNModuleSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:297(CondHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/side_effects.py:48(AttributeMutationExisting)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:88(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PngImagePlugin.py:1089(_idat)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:187(TickHelper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1046(LogFormatterMathtext)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:81(_UnboundedCache)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:208(Chinese)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:268(Hangul)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:322(Devanagari)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1533(KeyEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2905(Arc)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3492(BracketB)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3551(BracketCurve)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1061(Hbox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/units.py:161(Registry)\n", + " 3 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:543(__enter__)\n", + " 2 0.000 0.000 0.000 0.000 {method 'toordinal' of 'datetime.date' objects}\n", + " 1 0.000 0.000 0.000 0.000 {method 'move_to_end' of 'collections.OrderedDict' objects}\n", + " 2 0.000 0.000 0.000 0.000 {method '__exit__' of 'posix.ScandirIterator' objects}\n", + " 1 0.000 0.000 0.000 0.000 {method 'append' of 'collections.deque' objects}\n", + " 1 0.000 0.000 0.000 0.000 {built-in method _elementtree._set_factories}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:47(inexact)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:210(MergeKwargsIntoArgsStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:307(RemoveNonTensorInputStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:84(int32)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:90(int64)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:99(uint8)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:114(float32)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:126(complex64)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:55(ResetRequired)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:67(BackendCompilerFailed)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/eval_frame.py:527(_NullDecorator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:1045(_checkpoint_hook)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:198(ParamBufferSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/source.py:458(FSDPNNModuleSource)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:202(NewCellVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:308(_deprecated_parameter_class)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/cbook.py:100(__call__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_docstring.py:50(_ArtistKwdocLoader)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:350(validate_fontsize_None)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/__init__.py:75(UnidentifiedImageError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/ElementTree.py:106(ParseError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:239(FunctionPtrType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:285(NamedPointerType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:2852(AutoLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/exceptions.py:220(ParseException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:136(Latin1)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:300(Arabic)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:3398(PositionToken)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:48(NorthEastHatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:31(VerticalHatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:67(SouthEastHatch)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:9(HatchPatternBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:157(Stars)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:588(ViewsPositionsBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2642(Roundtooth)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2711(SimpleEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2348(Circle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2439(DArrow)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2534(Round4)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2801(Angle3)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2841(Angle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3001(Bar)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3533(BarAB)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dviread.py:782(Tfm)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:959(STIXSansFontConstants)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1054(Vbox)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1476(HCentered)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1523(AutoHeightChar)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_managers.py:20(ToolManagerMessageEvent)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/layout_engine.py:125(execute)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/offsetbox.py:499(HPacker)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/projections/__init__.py:72(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:661(_result)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:373(_tzfile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_factories.py:25(_TzOffsetFactory)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_factories.py:55(_TzStrFactory)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1551(MonthLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1578(WeekdayLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1605(DayLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1633(HourLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/dates.py:1658(MinuteLocator)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/tz.py:1156(_tzicalvtzcomp)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/container.py:77(ErrorbarContainer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:275(HandlerLine2D)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/tri/_triinterpolate.py:1061(_DOF_estimator_user)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/BmpImagePlugin.py:288(BmpRleDecoder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_util.py:22(AxisError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:249(ConvertComplexToRealRepresentationInputStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:281(RemoveNoneInputStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:411(FlattenOutputStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:108(float16)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:138(bool_)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:36(RestartAnalysis)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:567(ShapeVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:622(FunctorchGradHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:792(FunctorchVmapHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:207(NewGlobalVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:204(BaseFunctionType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/ImageFile.py:75(_tilesort)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:332(FormatStrFormatter)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4835(OneOrMore)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:2429(RArrow)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1486(VCentered)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/_factories.py:19(_TzFactory)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:503(HandlerPathCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/__init__.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backends/backend_macosx.py:16(TimerMac)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/numpy/core/multiarray.py:968(ravel_multi_index)\n", + " 1 0.000 0.000 0.000 0.000 {method 'close' of 'generator' objects}\n", + " 2 0.000 0.000 0.000 0.000 {built-in method _stat.S_ISREG}\n", + " 1 0.000 0.000 0.000 0.000 :1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/linalg.py:13(LinAlgError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:39(number)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/errors.py:20(OnnxExporterWarning)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/io_adapter.py:431(ConvertComplexToRealRepresentationOutputStep)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:120(float64)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:132(complex128)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:102(AttributeMutationError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:28(TorchDynamoException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:32(InternalTorchDynamoError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:716(_Handle)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:762(_CheckpointFrame)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:579(ExecutorchCallDelegateHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:1142(ExportTracepointHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/builder.py:148(_missing)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/packaging/version.py:55(InvalidVersion)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/error.py:2(FFIError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/error.py:17(VerificationError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:97(BasePrimitiveType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/GimpGradientFile.py:104(GimpGradientFile)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1030(LogFormatterExponent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/transforms.py:2607(BboxTransformToMaxOnly)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/bezier.py:25(NonIntersectingPathException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/util.py:102(_FifoCache)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2344(_SingleCharLiteral)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:2853(_WordRegex)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/core.py:4672(Located)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/hatch.py:140(LargeCircles)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/artist.py:1076(set_in_layout)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1223(_timer_set_single_shot)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_tools.py:627(ConfigureSubplotsBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:1420(Vrule)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:864(StixSansFonts)\n", + " 2 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/gridspec.py:69()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/streamplot.py:438(TerminateTrajectory)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/PpmImagePlugin.py:279(PpmDecoder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/inspect.py:729(getmro)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/threading.py:1590(main_thread)\n", + " 1 0.000 0.000 0.000 0.000 :1(__create_fn__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:43(integer)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:143(IncorrectUsage)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:994(_StopRecomputationError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:938(AutogradFunctionMethodHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/higher_order_ops.py:1080(OutDtypeHigherOrderVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:897(DeletedVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/optimizer.py:17(ArgMappingException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/rcsetup.py:874(_ignorecase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/colors.py:1796(FuncNorm)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:85(DecompressionBombWarning)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:2844(ImagePointHandler)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:2853(ImageTransformHandler)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/error.py:22(VerificationMissing)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/error.py:28(PkgConfigError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:482(StructType)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/cffi/model.py:486(UnionType)\n", + " 1 0.000 0.000 0.000 0.000 {method 'cleanup' of 'ImagingEncoder' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/ticker.py:1093(LogFormatterSciNotation)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/results.py:8()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1335(CloseEvent)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3463(CurveFilledB)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_blocking_input.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/units.py:52(ConversionError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/isoparser.py:43(__init__)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:402(Module_six_moves_urllib_request)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:454(Module_six_moves_urllib_response)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/legend_handler.py:513(HandlerCircleCollection)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/pathlib.py:43(_is_wildcard_pattern)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/cuda/__init__.py:45()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/glob.py:213(_join)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_util.py:26(UFuncTypeError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:63(complexfloating)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/symbolic_opset13.py:24(_apply_params)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:40(SkipFrame)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:720(_Holder)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/user_defined.py:35(UserDefinedVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:120(DelayGraphBreakVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/optimizer.py:21(GuardInstallException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/decorators.py:100(_disallow_in_graph_helper)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/exceptions.py:240(ParseFatalException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/exceptions.py:247(ParseSyntaxException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/unicode.py:290(CJK)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/_version.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:2574(NonGuiException)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:382(Module_six_moves_urllib_error)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:475(Module_six_moves_urllib_robotparser)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/streamplot.py:434(InvalidIndexError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/streamplot.py:510(OutOfBounds)\n", + " 2 0.000 0.000 0.000 0.000 {method '__prepare__' of 'type' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/collections/__init__.py:658(update)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/contextlib.py:345(__enter__)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method _thread.get_native_id}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/cuda/__init__.py:222(is_initialized)\n", + " 1 0.000 0.000 0.000 0.000 {built-in method matplotlib.backends._macosx.event_loop_is_running}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:51(signedinteger)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:55(unsignedinteger)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/errors.py:32(CheckerError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_numpy/_dtypes.py:59(floating)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:44(TorchRuntimeError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/exc.py:93(RecompileError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/utils/checkpoint.py:917(CheckpointError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/lists.py:707(TupleIteratorVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/variables/misc.py:114(UnknownVariable)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/Image.py:89(DecompressionBombError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/PIL/_version.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/defusedxml/common.py:71(NotSupportedError)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/parsers/__init__.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/pyparsing/exceptions.py:11(ExceptionWordUnicode)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1868(draw)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/font_manager.py:1498()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3443(CurveA)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3453(CurveAB)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3458(CurveFilledA)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3468(CurveFilledAB)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:970(DejaVuSansFontConstants)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/axes/__init__.py:14(SubplotBase)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/six.py:239(exec_module)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/parser/_parser.py:1608(UnknownTimezoneWarning)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/dateutil/tz/__init__.py:11(DeprecatedTzFormatWarning)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/testing/_internal/__init__.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/xml/etree/__init__.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/patches.py:3448(CurveB)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/_mathtext.py:966(DejaVuSerifFontConstants)\n", + " 1 0.000 0.000 0.000 0.000 {method 'islower' of 'bytes' objects}\n", + " 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/__init__.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/allowed_functions.py:249(_allowed_user_defined_function_ids)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/onnx/_internal/diagnostics/_diagnostic.py:107(background_context)\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/_dynamo/backends/__init__.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/torch/distributed/algorithms/_checkpoint/__init__.py:1()\n", + " 1 0.000 0.000 0.000 0.000 /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages/matplotlib/backend_bases.py:1220(_timer_set_interval)\n", + " 1 0.000 0.000 0.000 0.000 :1363(exec_module)\n", + "\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pstats.Stats(str(latest_profile)).sort_stats(\"cumulative\").print_stats()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0d17747", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learning_rate_scheduler_util.py b/learning_rate_scheduler_util.py new file mode 100644 index 0000000..f6b951a --- /dev/null +++ b/learning_rate_scheduler_util.py @@ -0,0 +1,121 @@ +import torch.optim as optim + +SCHEDULER_CHOICES = ("plateau", "cosine", "step", "exponential", "none") + + +def build_scheduler_kwargs_from_args(args): + """Translate CLI scheduler arguments into scheduler kwargs.""" + if args.scheduler == "plateau": + return { + "factor": args.scheduler_factor, + "patience": args.scheduler_patience, + } + if args.scheduler == "cosine": + return { + "eta_min": args.scheduler_eta_min, + } + if args.scheduler == "step": + return { + "step_size": args.scheduler_step_size, + "gamma": args.scheduler_gamma, + } + if args.scheduler == "exponential": + return { + "gamma": args.scheduler_gamma, + } + return {} + + +def suggest_scheduler_config(trial, lr, num_epochs): + """Sample a scheduler configuration for Optuna.""" + scheduler_name = trial.suggest_categorical("scheduler", list(SCHEDULER_CHOICES)) + scheduler_kwargs = {} + + if scheduler_name == "plateau": + max_patience = max(20, min(120, max(1, num_epochs - 1))) + scheduler_kwargs["factor"] = trial.suggest_float( + "scheduler_factor", + 0.2, + 0.8, + ) + scheduler_kwargs["patience"] = trial.suggest_int( + "scheduler_patience", + 20, + max_patience, + ) + elif scheduler_name == "cosine": + eta_min_ratio = trial.suggest_float( + "scheduler_eta_min_ratio", + 1e-4, + 0.2, + log=True, + ) + scheduler_kwargs["eta_min"] = lr * eta_min_ratio + elif scheduler_name == "step": + max_step_size = max(10, num_epochs) + scheduler_kwargs["step_size"] = trial.suggest_int( + "scheduler_step_size", + 10, + max_step_size, + log=True, + ) + scheduler_kwargs["gamma"] = trial.suggest_float( + "scheduler_gamma", + 0.1, + 0.95, + ) + elif scheduler_name == "exponential": + scheduler_kwargs["gamma"] = trial.suggest_float( + "scheduler_gamma", + 0.95, + 0.9999, + ) + + return scheduler_name, scheduler_kwargs + + +def create_lr_scheduler( + optimizer, + scheduler_name, + num_epochs, + scheduler_kwargs=None, +): + """Build the requested learning-rate scheduler.""" + scheduler_kwargs = dict(scheduler_kwargs or {}) + + if scheduler_name == "none": + return None, False + + if scheduler_name == "plateau": + scheduler = optim.lr_scheduler.ReduceLROnPlateau( + optimizer=optimizer, + mode="min", + factor=scheduler_kwargs.get("factor", 0.5), + patience=scheduler_kwargs.get("patience", 50), + ) + return scheduler, True + + if scheduler_name == "cosine": + scheduler = optim.lr_scheduler.CosineAnnealingLR( + optimizer, + T_max=max(1, num_epochs), + eta_min=scheduler_kwargs.get("eta_min", 1e-4), + ) + return scheduler, False + + if scheduler_name == "step": + scheduler = optim.lr_scheduler.StepLR( + optimizer, + step_size=max(1, scheduler_kwargs.get("step_size", 100)), + gamma=scheduler_kwargs.get("gamma", 0.5), + ) + return scheduler, False + + if scheduler_name == "exponential": + scheduler = optim.lr_scheduler.ExponentialLR( + optimizer, + gamma=scheduler_kwargs.get("gamma", 0.99), + ) + return scheduler, False + + raise ValueError(f"Unsupported scheduler: {scheduler_name}") diff --git a/loss_tracking_utils.py b/loss_tracking_utils.py new file mode 100644 index 0000000..5767cd3 --- /dev/null +++ b/loss_tracking_utils.py @@ -0,0 +1,302 @@ +import os +import sqlite3 +from datetime import datetime + + +DB_DIRNAME = "loss_tracking" +DB_FILENAME_PREFIX = "loss_tracking" +BASE_LOSS_HISTORY_FIELDS = ( + "total_loss", + "wirelength_loss", + "overlap_loss", + "learning_rate", +) +OPTIONAL_LOSS_HISTORY_FIELDS = ( + "overlap_count", + "total_overlap_area", + "max_overlap_area", +) +ALL_LOSS_HISTORY_FIELDS = BASE_LOSS_HISTORY_FIELDS + OPTIONAL_LOSS_HISTORY_FIELDS + + +def get_expected_loss_history_fields(track_overlap_metrics=False): + """Return the expected loss-history series for a run configuration.""" + if track_overlap_metrics: + return ALL_LOSS_HISTORY_FIELDS + return BASE_LOSS_HISTORY_FIELDS + + +def create_loss_history(run_metadata=None, track_overlap_metrics=False): + """Create a loss-history container with the expected series predeclared.""" + loss_history = {"run_metadata": dict(run_metadata or {})} + for field_name in get_expected_loss_history_fields(track_overlap_metrics): + loss_history[field_name] = [] + return loss_history + + +def get_loss_tracking_db_dir(output_dir): + """Return the directory that stores loss-tracking SQLite files.""" + return os.path.join(output_dir, DB_DIRNAME) + + +def create_loss_tracking_db(output_dir): + """Create a new SQLite database for a single placement/test invocation.""" + db_dir = get_loss_tracking_db_dir(output_dir) + os.makedirs(db_dir, exist_ok=True) + + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f") + db_path = os.path.join(db_dir, f"{DB_FILENAME_PREFIX}_{timestamp}.sqlite3") + + connection = _connect_db(db_path) + try: + _initialize_schema(connection) + connection.commit() + finally: + connection.close() + + return db_path + + +def _connect_db(db_path): + connection = sqlite3.connect(db_path) + connection.execute("PRAGMA foreign_keys = ON") + return connection + + +def _initialize_schema(connection): + connection.executescript( + """ + CREATE TABLE IF NOT EXISTS test_cases ( + test_id INTEGER PRIMARY KEY, + num_macros INTEGER, + num_std_cells INTEGER, + seed INTEGER, + updated_at TEXT NOT NULL + ); + + CREATE TABLE IF NOT EXISTS runs ( + run_id TEXT PRIMARY KEY, + test_id INTEGER REFERENCES test_cases(test_id) ON DELETE SET NULL, + runner TEXT, + run_label TEXT, + run_started_at TEXT, + saved_at TEXT NOT NULL, + seed INTEGER, + num_macros INTEGER, + num_std_cells INTEGER, + num_epochs INTEGER, + lr REAL, + lambda_wirelength REAL, + lambda_overlap REAL, + log_interval INTEGER, + verbose INTEGER, + total_cells INTEGER, + total_pins INTEGER, + total_edges INTEGER + ); + + CREATE TABLE IF NOT EXISTS loss_history ( + run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE, + epoch INTEGER NOT NULL, + total_loss REAL, + wirelength_loss REAL, + overlap_loss REAL, + learning_rate REAL, + overlap_count INTEGER, + total_overlap_area REAL, + max_overlap_area REAL, + PRIMARY KEY (run_id, epoch) + ); + """ + ) + _ensure_columns( + connection, + "runs", + { + "seed": "INTEGER", + "num_macros": "INTEGER", + "num_std_cells": "INTEGER", + }, + ) + _ensure_columns( + connection, + "loss_history", + { + "learning_rate": "REAL", + "overlap_count": "INTEGER", + "total_overlap_area": "REAL", + "max_overlap_area": "REAL", + }, + ) + + +def _ensure_columns(connection, table_name, columns): + existing_columns = { + row[1] + for row in connection.execute(f"PRAGMA table_info({table_name})") + } + for column_name, column_type in columns.items(): + if column_name not in existing_columns: + connection.execute( + f"ALTER TABLE {table_name} ADD COLUMN {column_name} {column_type}" + ) + + +def _sqlite_scalar(value): + """Convert torch/numpy scalar-like values to sqlite-friendly Python scalars.""" + if value is None: + return None + if isinstance(value, (str, bytes, int, float)): + return value + if isinstance(value, bool): + return int(value) + if hasattr(value, "item"): + return value.item() + return value + + +def save_loss_history_sqlite(loss_history, db_path, run_metadata=None): + """Save loss history values to a normalized SQLite database.""" + os.makedirs(os.path.dirname(db_path), exist_ok=True) + + metadata = dict(loss_history.get("run_metadata", {})) + if run_metadata: + metadata.update(run_metadata) + + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f") + metadata.setdefault("run_id", timestamp) + metadata.setdefault("saved_at", datetime.now().isoformat(timespec="seconds")) + + history_series = { + field_name: loss_history.get(field_name, []) + for field_name in ALL_LOSS_HISTORY_FIELDS + } + + row_count = max( + (len(values) for values in history_series.values()), + default=0, + ) + + connection = _connect_db(db_path) + try: + _initialize_schema(connection) + + test_id = metadata.get("test_id") + if test_id is not None: + connection.execute( + """ + INSERT INTO test_cases ( + test_id, + num_macros, + num_std_cells, + seed, + updated_at + ) + VALUES (?, ?, ?, ?, ?) + ON CONFLICT(test_id) DO UPDATE SET + num_macros = excluded.num_macros, + num_std_cells = excluded.num_std_cells, + seed = excluded.seed, + updated_at = excluded.updated_at + """, + ( + int(test_id), + metadata.get("num_macros"), + metadata.get("num_std_cells"), + metadata.get("seed"), + metadata["saved_at"], + ), + ) + + connection.execute( + """ + INSERT OR REPLACE INTO runs ( + run_id, + test_id, + runner, + run_label, + run_started_at, + saved_at, + seed, + num_macros, + num_std_cells, + num_epochs, + lr, + lambda_wirelength, + lambda_overlap, + log_interval, + verbose, + total_cells, + total_pins, + total_edges + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + ( + metadata["run_id"], + int(test_id) if test_id is not None else None, + metadata.get("runner"), + metadata.get("run_label"), + metadata.get("run_started_at"), + metadata["saved_at"], + metadata.get("seed"), + metadata.get("num_macros"), + metadata.get("num_std_cells"), + metadata.get("num_epochs"), + metadata.get("lr"), + metadata.get("lambda_wirelength"), + metadata.get("lambda_overlap"), + metadata.get("log_interval"), + int(bool(metadata.get("verbose"))) + if metadata.get("verbose") is not None + else None, + metadata.get("total_cells"), + metadata.get("total_pins"), + metadata.get("total_edges"), + ), + ) + + connection.execute( + "DELETE FROM loss_history WHERE run_id = ?", + (metadata["run_id"],), + ) + + history_rows = [] + for epoch in range(row_count): + history_rows.append( + ( + metadata["run_id"], + epoch, + *( + _sqlite_scalar( + history_series[field_name][epoch] + if epoch < len(history_series[field_name]) + else None + ) + for field_name in ALL_LOSS_HISTORY_FIELDS + ), + ) + ) + + connection.executemany( + """ + INSERT INTO loss_history ( + run_id, + epoch, + total_loss, + wirelength_loss, + overlap_loss, + learning_rate, + overlap_count, + total_overlap_area, + max_overlap_area + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + history_rows, + ) + connection.commit() + finally: + connection.close() + + return db_path diff --git a/placement.py b/placement.py index d70412d..25c9fc6 100644 --- a/placement.py +++ b/placement.py @@ -40,10 +40,60 @@ import os from enum import IntEnum +from datetime import datetime import torch import torch.optim as optim +from arg_parse_util import parse_args +from benchmark_test_cases import TEST_CASES_BY_ID +from hyperparameter_search import run_optuna_search +from learning_rate_scheduler_util import ( + build_scheduler_kwargs_from_args, + create_lr_scheduler, +) +from loss_tracking_utils import ( + create_loss_history, + create_loss_tracking_db, + save_loss_history_sqlite, +) +from torch_profiler_util import ( + build_torch_profiler_config_from_args, + create_torch_profiler_session, + run_with_optional_profile, +) + + +def get_best_device(): + """Select the fastest available torch device.""" + if torch.cuda.is_available(): + return torch.device("cuda") + if torch.backends.mps.is_available(): + return torch.device("mps") + return torch.device("cpu") + + +def resolve_device(device_name=None): + """Resolve a requested torch device and validate backend availability.""" + if device_name is None or str(device_name).lower() == "auto": + return get_best_device() + + device = torch.device(device_name) + if device.type == "cuda" and not torch.cuda.is_available(): + raise RuntimeError("CUDA device requested but CUDA is not available.") + if device.type == "mps" and not torch.backends.mps.is_available(): + raise RuntimeError("MPS device requested but MPS is not available.") + return device + + +def seed_torch(seed): + """Seed torch RNGs across supported backends.""" + torch.manual_seed(seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(seed) + + +seed_torch(66) # Feature index enums for cleaner code access class CellFeatureIdx(IntEnum): @@ -82,10 +132,9 @@ class PinFeatureIdx(IntEnum): # Output directory OUTPUT_DIR = os.path.dirname(os.path.abspath(__file__)) - # ======= SETUP ======= -def generate_placement_input(num_macros, num_std_cells): +def generate_placement_input(num_macros, num_std_cells, device=None, verbose=True): """Generate synthetic placement input data. Args: @@ -99,16 +148,18 @@ def generate_placement_input(num_macros, num_std_cells): [cell_instance_index, pin_x, pin_y, x, y, pin_width, pin_height] - edge_list: torch.Tensor of shape [E, 2] with [src_pin_idx, tgt_pin_idx] """ + device = device or get_best_device() total_cells = num_macros + num_std_cells # Step 1: Generate macro areas (uniformly distributed between min and max) macro_areas = ( - torch.rand(num_macros) * (MAX_MACRO_AREA - MIN_MACRO_AREA) + MIN_MACRO_AREA + torch.rand(num_macros, device=device) * (MAX_MACRO_AREA - MIN_MACRO_AREA) + + MIN_MACRO_AREA ) # Step 2: Generate standard cell areas (randomly pick from 1, 2, or 3) - std_cell_areas = torch.tensor(STANDARD_CELL_AREAS)[ - torch.randint(0, len(STANDARD_CELL_AREAS), (num_std_cells,)) + std_cell_areas = torch.tensor(STANDARD_CELL_AREAS, device=device)[ + torch.randint(0, len(STANDARD_CELL_AREAS), (num_std_cells,), device=device) ] # Combine all areas @@ -121,27 +172,39 @@ def generate_placement_input(num_macros, num_std_cells): # Standard cells have fixed height = 1, width = area std_cell_widths = std_cell_areas / STANDARD_CELL_HEIGHT - std_cell_heights = torch.full((num_std_cells,), STANDARD_CELL_HEIGHT) + std_cell_heights = torch.full( + (num_std_cells,), + STANDARD_CELL_HEIGHT, + device=device, + ) # Combine dimensions cell_widths = torch.cat([macro_widths, std_cell_widths]) cell_heights = torch.cat([macro_heights, std_cell_heights]) # Step 4: Calculate number of pins per cell - num_pins_per_cell = torch.zeros(total_cells, dtype=torch.int) + num_pins_per_cell = torch.zeros(total_cells, dtype=torch.int, device=device) # Macros: between sqrt(area) and 2*sqrt(area) pins for i in range(num_macros): sqrt_area = int(torch.sqrt(macro_areas[i]).item()) - num_pins_per_cell[i] = torch.randint(sqrt_area, 2 * sqrt_area + 1, (1,)).item() + num_pins_per_cell[i] = torch.randint( + sqrt_area, + 2 * sqrt_area + 1, + (1,), + device=device, + ).item() # Standard cells: between 3 and 6 pins num_pins_per_cell[num_macros:] = torch.randint( - MIN_STANDARD_CELL_PINS, MAX_STANDARD_CELL_PINS + 1, (num_std_cells,) + MIN_STANDARD_CELL_PINS, + MAX_STANDARD_CELL_PINS + 1, + (num_std_cells,), + device=device, ) # Step 5: Create cell features tensor [area, num_pins, x, y, width, height] - cell_features = torch.zeros(total_cells, 6) + cell_features = torch.zeros(total_cells, 6, device=device) cell_features[:, CellFeatureIdx.AREA] = areas cell_features[:, CellFeatureIdx.NUM_PINS] = num_pins_per_cell.float() cell_features[:, CellFeatureIdx.X] = 0.0 # x position (initialized to 0) @@ -151,7 +214,7 @@ def generate_placement_input(num_macros, num_std_cells): # Step 6: Generate pins for each cell total_pins = num_pins_per_cell.sum().item() - pin_features = torch.zeros(total_pins, 7) + pin_features = torch.zeros(total_pins, 7, device=device) # Fixed pin size for all pins (square pins) PIN_SIZE = 0.1 # All pins are 0.1 x 0.1 @@ -166,12 +229,18 @@ def generate_placement_input(num_macros, num_std_cells): # Offset from edges to ensure pins are fully inside margin = PIN_SIZE / 2 if cell_width > 2 * margin and cell_height > 2 * margin: - pin_x = torch.rand(n_pins) * (cell_width - 2 * margin) + margin - pin_y = torch.rand(n_pins) * (cell_height - 2 * margin) + margin + pin_x = ( + torch.rand(n_pins, device=device) * (cell_width - 2 * margin) + + margin + ) + pin_y = ( + torch.rand(n_pins, device=device) * (cell_height - 2 * margin) + + margin + ) else: # For very small cells, just center the pins - pin_x = torch.full((n_pins,), cell_width / 2) - pin_y = torch.full((n_pins,), cell_height / 2) + pin_x = torch.full((n_pins,), cell_width / 2, device=device) + pin_y = torch.full((n_pins,), cell_height / 2, device=device) # Fill pin features pin_features[pin_idx : pin_idx + n_pins, PinFeatureIdx.CELL_IDX] = cell_idx @@ -197,7 +266,7 @@ def generate_placement_input(num_macros, num_std_cells): edge_list = [] avg_edges_per_pin = 2.0 - pin_to_cell = torch.zeros(total_pins, dtype=torch.long) + pin_to_cell = torch.zeros(total_pins, dtype=torch.long, device=device) pin_idx = 0 for cell_idx, n_pins in enumerate(num_pins_per_cell): pin_to_cell[pin_idx : pin_idx + n_pins] = cell_idx @@ -208,12 +277,17 @@ def generate_placement_input(num_macros, num_std_cells): for pin_idx in range(total_pins): pin_cell = pin_to_cell[pin_idx].item() - num_connections = torch.randint(1, 4, (1,)).item() # 1-3 connections per pin + num_connections = torch.randint( + 1, + 4, + (1,), + device=device, + ).item() # 1-3 connections per pin # Try to connect to pins from different cells for _ in range(num_connections): # Random candidate - other_pin = torch.randint(0, total_pins, (1,)).item() + other_pin = torch.randint(0, total_pins, (1,), device=device).item() # Skip self-connections and existing connections if other_pin == pin_idx or other_pin in adjacency[pin_idx]: @@ -231,22 +305,47 @@ def generate_placement_input(num_macros, num_std_cells): # Convert to tensor and remove duplicates if edge_list: - edge_list = torch.tensor(edge_list, dtype=torch.long) + edge_list = torch.tensor(edge_list, dtype=torch.long, device=device) edge_list = torch.unique(edge_list, dim=0) else: - edge_list = torch.zeros((0, 2), dtype=torch.long) + edge_list = torch.zeros((0, 2), dtype=torch.long, device=device) - print(f"\nGenerated placement data:") - print(f" Total cells: {total_cells}") - print(f" Total pins: {total_pins}") - print(f" Total edges: {len(edge_list)}") - print(f" Average edges per pin: {2 * len(edge_list) / total_pins:.2f}") + if verbose: + print(f"\nGenerated placement data:") + print(f" Total cells: {total_cells}") + print(f" Total pins: {total_pins}") + print(f" Total edges: {len(edge_list)}") + print(f" Average edges per pin: {2 * len(edge_list) / total_pins:.2f}") return cell_features, pin_features, edge_list + +def initialize_cell_positions(cell_features, spread_scale=0.6): + """Initialize cell centers with a random radial spread.""" + total_cells = cell_features.shape[0] + total_area = cell_features[:, CellFeatureIdx.AREA].sum().item() + spread_radius = max((total_area ** 0.5) * spread_scale, 1.0) + + angles = torch.rand(total_cells, device=cell_features.device) * 2 * torch.pi + radii = torch.rand(total_cells, device=cell_features.device) * spread_radius + + cell_features[:, CellFeatureIdx.X] = radii * torch.cos(angles) + cell_features[:, CellFeatureIdx.Y] = radii * torch.sin(angles) + + +def total_wire_length(cell_features, pin_features, edge_list): + # the real goal seem to be to reduce the total wirelength. + # attraction loss can be a training method. + return 0 # ======= OPTIMIZATION CODE (edit this part) ======= def wirelength_attraction_loss(cell_features, pin_features, edge_list): + # Q: Do I change this? + + # Vraj: change this later once the overlap loss is tuned + # Ans: No there are down stream calls that need this implementation to help evaluate the result + + # Keep this code for testing and create a loss function when needed. """Calculate loss based on total wirelength to minimize routing. This is a REFERENCE IMPLEMENTATION showing how to write a differentiable loss function. @@ -263,7 +362,12 @@ def wirelength_attraction_loss(cell_features, pin_features, edge_list): Scalar loss value """ if edge_list.shape[0] == 0: - return torch.tensor(0.0, requires_grad=True) + return torch.tensor( + 0.0, + requires_grad=True, + device=cell_features.device, + dtype=cell_features.dtype, + ) # Update absolute pin positions based on cell positions cell_positions = cell_features[:, 2:4] # [N, 2] @@ -295,8 +399,87 @@ def wirelength_attraction_loss(cell_features, pin_features, edge_list): # Total wirelength total_wirelength = torch.sum(smooth_manhattan) + ret = total_wirelength / edge_list.shape[0] # Normalize by number of edges + # print(ret.shape) + return ret + + +def compute_pairwise_overlap_areas(cell_features): + """Return pairwise overlap areas for all cell pairs.""" + num_cells = cell_features.shape[0] + if num_cells <= 1: + return torch.zeros( + (num_cells, num_cells), + device=cell_features.device, + dtype=cell_features.dtype, + ) + + x_col = cell_features[:, CellFeatureIdx.X] + y_col = cell_features[:, CellFeatureIdx.Y] + widths = cell_features[:, CellFeatureIdx.WIDTH] + heights = cell_features[:, CellFeatureIdx.HEIGHT] + + x_delta = torch.abs(x_col.unsqueeze(1) - x_col.unsqueeze(0)) + y_delta = torch.abs(y_col.unsqueeze(1) - y_col.unsqueeze(0)) + + x_span = (widths.unsqueeze(1) + widths.unsqueeze(0)) / 2 + y_span = (heights.unsqueeze(1) + heights.unsqueeze(0)) / 2 - return total_wirelength / edge_list.shape[0] # Normalize by number of edges + overlap_x = torch.relu(x_span - x_delta) + overlap_y = torch.relu(y_span - y_delta) + return overlap_x * overlap_y + + +def calculate_overlap_metrics_torch(cell_features): + """Calculate overlap metrics with vectorized torch operations.""" + num_cells = cell_features.shape[0] + if num_cells <= 1: + zero = torch.tensor(0.0, device=cell_features.device, dtype=cell_features.dtype) + return { + "overlap_count": 0, + "total_overlap_area": 0.0, + "max_overlap_area": 0.0, + "overlap_percentage": 0.0, + "cells_with_overlap": 0, + "has_zero_overlap": True, + "total_overlap_area_tensor": zero, + "max_overlap_area_tensor": zero, + } + + pairwise_overlap_area = compute_pairwise_overlap_areas(cell_features) + mask = torch.triu( + torch.ones_like(pairwise_overlap_area, dtype=torch.bool), + diagonal=1, + ) + active_overlap_areas = pairwise_overlap_area[mask] + overlapping_pairs = active_overlap_areas > 0 + + overlap_count = int(overlapping_pairs.sum().item()) + total_overlap_area = active_overlap_areas.sum() + max_overlap_area = ( + active_overlap_areas.max() + if active_overlap_areas.numel() > 0 + else total_overlap_area.new_zeros(()) + ) + + overlap_matrix = (pairwise_overlap_area > 0) & mask + overlap_matrix = overlap_matrix | overlap_matrix.transpose(0, 1) + cells_with_overlap = int(overlap_matrix.any(dim=0).sum().item()) + total_area = cell_features[:, CellFeatureIdx.AREA].sum() + overlap_percentage = ( + overlap_count / num_cells * 100.0 if total_area.item() > 0 else 0.0 + ) + + return { + "overlap_count": overlap_count, + "total_overlap_area": float(total_overlap_area.item()), + "max_overlap_area": float(max_overlap_area.item()), + "overlap_percentage": overlap_percentage, + "cells_with_overlap": cells_with_overlap, + "has_zero_overlap": overlap_count == 0, + "total_overlap_area_tensor": total_overlap_area, + "max_overlap_area_tensor": max_overlap_area, + } def overlap_repulsion_loss(cell_features, pin_features, edge_list): @@ -345,7 +528,19 @@ def overlap_repulsion_loss(cell_features, pin_features, edge_list): """ N = cell_features.shape[0] if N <= 1: - return torch.tensor(0.0, requires_grad=True) + return torch.tensor(0.0, requires_grad=True, device=cell_features.device) + + pairwise_overlap_area = compute_pairwise_overlap_areas(cell_features) + mask = torch.triu(torch.ones_like(pairwise_overlap_area), diagonal=1) + + # normalization = torch.sqrt( + # torch.tensor(N, device=pairwise_overlap_area.device, dtype=pairwise_overlap_area.dtype) + # ) + # loss = torch.sum(pairwise_overlap_area * mask) / normalization + overlap_sclar = 200 + loss = torch.log1p(torch.sum(pairwise_overlap_area * mask)) * overlap_sclar + + return loss # TODO: Implement overlap detection and loss calculation here # @@ -356,20 +551,29 @@ def overlap_repulsion_loss(cell_features, pin_features, edge_list): # # Delete this placeholder and add your implementation: - # Placeholder - returns a constant loss (REPLACE THIS!) - return torch.tensor(1.0, requires_grad=True) - - def train_placement( cell_features, pin_features, edge_list, num_epochs=1000, - lr=0.01, - lambda_wirelength=1.0, - lambda_overlap=10.0, + lr=0.1, + lambda_wirelength=3.0, + lambda_overlap=1.0, + scheduler_name="plateau", + scheduler_kwargs=None, + track_loss_history=True, verbose=True, log_interval=100, + run_metadata=None, + torch_profiler_config=None, + torch_profile_output_dir=None, + track_overlap_metrics=False, + early_stop_enabled=True, + early_stop_patience=75, + early_stop_min_delta=1e-4, + early_stop_overlap_threshold=1e-4, + early_stop_zero_overlap_patience=25, + device=None, ): """Train the placement optimization using gradient descent. @@ -381,8 +585,22 @@ def train_placement( lr: Learning rate for Adam optimizer lambda_wirelength: Weight for wirelength loss lambda_overlap: Weight for overlap loss + scheduler_name: Learning-rate scheduler name + scheduler_kwargs: Scheduler-specific keyword arguments + track_loss_history: Whether to collect per-epoch loss history verbose: Whether to print progress log_interval: How often to print progress + run_metadata: Optional metadata describing the run + torch_profiler_config: Optional torch profiler configuration + torch_profile_output_dir: Base directory for torch profiler artifacts + track_overlap_metrics: Whether to collect per-epoch overlap metrics + early_stop_enabled: Whether to stop once overlap-first convergence stalls + early_stop_patience: Plateau patience before zero-overlap is reached + early_stop_min_delta: Minimum improvement to reset patience + early_stop_overlap_threshold: Treat overlap below this as effectively zero + early_stop_zero_overlap_patience: Extra patience after zero-overlap to keep improving wirelength + device: Optional torch device override. When omitted, CPU inputs are moved + to the best available device. Returns: Dictionary with: @@ -390,8 +608,17 @@ def train_placement( - initial_cell_features: Original cell positions (for comparison) - loss_history: Loss values over time """ + if device is None: + device = cell_features.device + if device.type == "cpu": + device = get_best_device() + else: + device = resolve_device(device) + # Clone features and create learnable positions - cell_features = cell_features.clone() + cell_features = cell_features.clone().to(device) + pin_features = pin_features.to(device) + edge_list = edge_list.to(device) initial_cell_features = cell_features.clone() # Make only cell positions require gradients @@ -399,63 +626,225 @@ def train_placement( cell_positions.requires_grad_(True) # Create optimizer + scheduler_kwargs = dict(scheduler_kwargs or {}) optimizer = optim.Adam([cell_positions], lr=lr) + scheduler, scheduler_uses_metric = create_lr_scheduler( + optimizer, + scheduler_name=scheduler_name, + num_epochs=num_epochs, + scheduler_kwargs=scheduler_kwargs, + ) - # Track loss history - loss_history = { - "total_loss": [], - "wirelength_loss": [], - "overlap_loss": [], + history_run_metadata = { + "run_label": "train_placement", + "run_started_at": datetime.now().isoformat(timespec="seconds"), + "device": str(device), + "num_epochs": num_epochs, + "lr": lr, + "lambda_wirelength": lambda_wirelength, + "lambda_overlap": lambda_overlap, + "scheduler_name": scheduler_name, + "scheduler_kwargs": scheduler_kwargs, + "track_loss_history": track_loss_history, + "track_overlap_metrics": track_overlap_metrics, + "early_stop_enabled": early_stop_enabled, + "early_stop_patience": early_stop_patience, + "early_stop_min_delta": early_stop_min_delta, + "early_stop_overlap_threshold": early_stop_overlap_threshold, + "early_stop_zero_overlap_patience": early_stop_zero_overlap_patience, + "log_interval": log_interval, + "verbose": verbose, + "total_cells": int(cell_features.shape[0]), + "total_pins": int(pin_features.shape[0]), + "total_edges": int(edge_list.shape[0]), } - - # Training loop - for epoch in range(num_epochs): - optimizer.zero_grad() - - # Create cell_features with current positions - cell_features_current = cell_features.clone() - cell_features_current[:, 2:4] = cell_positions - - # Calculate losses - wl_loss = wirelength_attraction_loss( - cell_features_current, pin_features, edge_list - ) - overlap_loss = overlap_repulsion_loss( - cell_features_current, pin_features, edge_list + if run_metadata: + history_run_metadata.update(run_metadata) + + loss_history = None + if track_loss_history: + loss_history = create_loss_history( + run_metadata=history_run_metadata, + track_overlap_metrics=track_overlap_metrics, ) - # Combined loss - total_loss = lambda_wirelength * wl_loss + lambda_overlap * overlap_loss - - # Backward pass - total_loss.backward() - - # Gradient clipping to prevent extreme updates - torch.nn.utils.clip_grad_norm_([cell_positions], max_norm=5.0) + best_cell_positions = cell_positions.detach().clone() + best_overlap_score = float("inf") + best_zero_overlap_wl = float("inf") + best_epoch = -1 + epochs_without_improvement = 0 + zero_overlap_epochs_without_improvement = 0 + zero_overlap_reached = False + stopped_early = False + stop_reason = "" - # Update positions - optimizer.step() - - # Record losses - loss_history["total_loss"].append(total_loss.item()) - loss_history["wirelength_loss"].append(wl_loss.item()) - loss_history["overlap_loss"].append(overlap_loss.item()) - - # Log progress - if verbose and (epoch % log_interval == 0 or epoch == num_epochs - 1): - print(f"Epoch {epoch}/{num_epochs}:") - print(f" Total Loss: {total_loss.item():.6f}") - print(f" Wirelength Loss: {wl_loss.item():.6f}") - print(f" Overlap Loss: {overlap_loss.item():.6f}") + # Training loop + profiler_output_dir = torch_profile_output_dir or OUTPUT_DIR + with create_torch_profiler_session( + config=torch_profiler_config, + output_dir=profiler_output_dir, + profile_tag=history_run_metadata.get("profile_tag", ""), + run_metadata=history_run_metadata, + ) as profiler_session: + for epoch in range(num_epochs): + with torch.profiler.record_function("placement/epoch"): + overlap_metrics = None + optimizer.zero_grad() + + with torch.profiler.record_function("placement/forward"): + cell_features_current = cell_features.clone() + cell_features_current[:, 2:4] = cell_positions + + wl_loss = wirelength_attraction_loss( + cell_features_current, pin_features, edge_list + ) + overlap_loss = overlap_repulsion_loss( + cell_features_current, pin_features, edge_list + ) + total_loss = ( + lambda_wirelength * wl_loss + lambda_overlap * overlap_loss + ) + + with torch.profiler.record_function("placement/backward"): + total_loss.backward() + torch.nn.utils.clip_grad_norm_([cell_positions], max_norm=5.0) + + with torch.profiler.record_function("placement/optimizer_step"): + optimizer.step() + if scheduler is not None: + if scheduler_uses_metric: + scheduler.step(total_loss.item()) + else: + scheduler.step() + + should_log_epoch = verbose and ( + epoch % log_interval == 0 or epoch == num_epochs - 1 + ) + should_compute_overlap_metrics = ( + track_overlap_metrics + or early_stop_enabled + or should_log_epoch + ) + updated_cell_features = None + if should_compute_overlap_metrics: + with torch.profiler.record_function("placement/metrics"): + updated_cell_features = cell_features.clone() + updated_cell_features[:, 2:4] = cell_positions.detach() + overlap_metrics = calculate_overlap_metrics_torch( + updated_cell_features + ) + + if early_stop_enabled: + overlap_score = overlap_metrics["total_overlap_area"] + has_zero_overlap = ( + overlap_metrics["overlap_count"] == 0 + or overlap_score <= early_stop_overlap_threshold + ) + if has_zero_overlap: + current_wl = wirelength_attraction_loss( + updated_cell_features, + pin_features, + edge_list, + ).item() + if ( + not zero_overlap_reached + or current_wl < best_zero_overlap_wl - early_stop_min_delta + ): + zero_overlap_reached = True + best_zero_overlap_wl = current_wl + best_cell_positions = cell_positions.detach().clone() + best_epoch = epoch + zero_overlap_epochs_without_improvement = 0 + else: + zero_overlap_epochs_without_improvement += 1 + + if ( + zero_overlap_reached + and zero_overlap_epochs_without_improvement + >= early_stop_zero_overlap_patience + ): + stopped_early = True + stop_reason = "zero_overlap_plateau" + else: + if zero_overlap_reached: + zero_overlap_epochs_without_improvement += 1 + if ( + zero_overlap_epochs_without_improvement + >= early_stop_zero_overlap_patience + ): + stopped_early = True + stop_reason = "zero_overlap_plateau" + else: + if overlap_score < best_overlap_score - early_stop_min_delta: + best_overlap_score = overlap_score + best_cell_positions = cell_positions.detach().clone() + best_epoch = epoch + epochs_without_improvement = 0 + else: + epochs_without_improvement += 1 + + if epochs_without_improvement >= early_stop_patience: + stopped_early = True + stop_reason = "overlap_plateau" + should_collect_overlap_metrics = track_overlap_metrics and loss_history is not None + + if loss_history is not None: + loss_history["total_loss"].append(total_loss.item()) + loss_history["wirelength_loss"].append(wl_loss.item()) + loss_history["overlap_loss"].append(overlap_loss.item()) + loss_history["learning_rate"].append(optimizer.param_groups[0]["lr"]) + if should_collect_overlap_metrics: + loss_history["overlap_count"].append( + overlap_metrics["overlap_count"] + ) + loss_history["total_overlap_area"].append( + overlap_metrics["total_overlap_area"] + ) + loss_history["max_overlap_area"].append( + overlap_metrics["max_overlap_area"] + ) + + if should_log_epoch: + print(f"Epoch {epoch}/{num_epochs}:") + print(f" Total Loss: {total_loss.item():.6f}") + print(f" Wirelength Loss: {wl_loss.item():.6f}") + print(f" Overlap Loss: {overlap_loss.item():.6f}") + print(f" Learning Rate: {optimizer.param_groups[0]['lr']:.6f}") + if overlap_metrics is not None: + print(f" Overlap Count: {overlap_metrics['overlap_count']}") + print( + f" Total Overlap Area: {overlap_metrics['total_overlap_area']:.6f}" + ) + if early_stop_enabled: + print(f" Best Epoch: {best_epoch}") + + if stopped_early: + if verbose: + print( + f"Early stopping at epoch {epoch} " + f"with reason={stop_reason} best_epoch={best_epoch}" + ) + break + + profiler_session.step() # Create final cell features final_cell_features = cell_features.clone() - final_cell_features[:, 2:4] = cell_positions.detach() + final_positions = best_cell_positions if early_stop_enabled else cell_positions.detach() + final_cell_features[:, 2:4] = final_positions + + if loss_history is not None: + loss_history["run_metadata"]["stopped_early"] = stopped_early + loss_history["run_metadata"]["stop_reason"] = stop_reason + loss_history["run_metadata"]["best_epoch"] = best_epoch return { "final_cell_features": final_cell_features, "initial_cell_features": initial_cell_features, "loss_history": loss_history, + "stopped_early": stopped_early, + "stop_reason": stop_reason, + "best_epoch": best_epoch, } @@ -487,10 +876,10 @@ def calculate_overlap_metrics(cell_features): } # Extract cell properties - positions = cell_features[:, 2:4].detach().numpy() # [N, 2] - widths = cell_features[:, 4].detach().numpy() # [N] - heights = cell_features[:, 5].detach().numpy() # [N] - areas = cell_features[:, 0].detach().numpy() # [N] + positions = cell_features[:, 2:4].detach().cpu().numpy() # [N, 2] + widths = cell_features[:, 4].detach().cpu().numpy() # [N] + heights = cell_features[:, 5].detach().cpu().numpy() # [N] + areas = cell_features[:, 0].detach().cpu().numpy() # [N] overlap_count = 0 total_overlap_area = 0.0 @@ -548,9 +937,9 @@ def calculate_cells_with_overlaps(cell_features): return set() # Extract cell properties - positions = cell_features[:, 2:4].detach().numpy() - widths = cell_features[:, 4].detach().numpy() - heights = cell_features[:, 5].detach().numpy() + positions = cell_features[:, 2:4].detach().cpu().numpy() + widths = cell_features[:, 4].detach().cpu().numpy() + heights = cell_features[:, 5].detach().cpu().numpy() cells_with_overlaps = set() @@ -657,9 +1046,9 @@ def plot_placement( (ax2, final_cell_features, "Final Placement"), ]: N = cell_features.shape[0] - positions = cell_features[:, 2:4].detach().numpy() - widths = cell_features[:, 4].detach().numpy() - heights = cell_features[:, 5].detach().numpy() + positions = cell_features[:, 2:4].detach().cpu().numpy() + widths = cell_features[:, 4].detach().cpu().numpy() + heights = cell_features[:, 5].detach().cpu().numpy() # Draw cells for i in range(N): @@ -707,37 +1096,60 @@ def plot_placement( # ======= MAIN FUNCTION ======= -def main(): +def main(args): """Main function demonstrating the placement optimization challenge.""" + torch_profiler_config = build_torch_profiler_config_from_args(args) + device = resolve_device(args.device) + if args.optuna: + run_optuna_search( + args, + get_best_device=lambda: device, + seed_torch=seed_torch, + generate_placement_input=generate_placement_input, + initialize_cell_positions=initialize_cell_positions, + train_placement=train_placement, + calculate_normalized_metrics=calculate_normalized_metrics, + ) + return + print("=" * 70) print("VLSI CELL PLACEMENT OPTIMIZATION CHALLENGE") print("=" * 70) print("\nObjective: Implement overlap_repulsion_loss() to eliminate cell overlaps") print("while minimizing wirelength.\n") + test_case = None + if args.test_case_id is not None: + test_case = TEST_CASES_BY_ID[args.test_case_id] + # Set random seed for reproducibility - torch.manual_seed(42) + seed = test_case["seed"] if test_case is not None else args.seed + seed_torch(seed) # Generate placement problem - num_macros = 3 - num_std_cells = 50 + num_macros = ( + test_case["num_macros"] if test_case is not None else args.num_macros + ) + num_std_cells = ( + test_case["num_std_cells"] if test_case is not None else args.num_std_cells + ) print(f"Generating placement problem:") + if test_case is not None: + print(f" - benchmark test case: {test_case['test_id']}") print(f" - {num_macros} macros") print(f" - {num_std_cells} standard cells") + print(f" - seed: {seed}") + print(f" - device: {device}") cell_features, pin_features, edge_list = generate_placement_input( - num_macros, num_std_cells + num_macros, + num_std_cells, + device=device, ) # Initialize positions with random spread to reduce initial overlaps - total_cells = cell_features.shape[0] - spread_radius = 30.0 - angles = torch.rand(total_cells) * 2 * 3.14159 - radii = torch.rand(total_cells) * spread_radius - - cell_features[:, 2] = radii * torch.cos(angles) - cell_features[:, 3] = radii * torch.sin(angles) + initialize_cell_positions(cell_features) # Calculate initial metrics print("\n" + "=" * 70) @@ -754,13 +1166,49 @@ def main(): print("RUNNING OPTIMIZATION") print("=" * 70) + loss_tracking_db_path = None + if args.track_loss_history: + loss_tracking_db_path = create_loss_tracking_db(OUTPUT_DIR) + result = train_placement( cell_features, pin_features, edge_list, + num_epochs=args.num_epochs, + lr=args.lr, + lambda_wirelength=args.lambda_wirelength, + lambda_overlap=args.lambda_overlap, + scheduler_name=args.scheduler, + scheduler_kwargs=build_scheduler_kwargs_from_args(args), + track_loss_history=args.track_loss_history, verbose=True, log_interval=200, + run_metadata={ + "runner": "placement.main", + "profile_tag": args.profile_tag, + "seed": seed, + "num_macros": num_macros, + "num_std_cells": num_std_cells, + "test_id": None if test_case is None else test_case["test_id"], + }, + torch_profiler_config=torch_profiler_config, + torch_profile_output_dir=OUTPUT_DIR, + track_overlap_metrics=args.track_overlap_metrics, + early_stop_enabled=args.early_stop, + early_stop_patience=args.early_stop_patience, + early_stop_min_delta=args.early_stop_min_delta, + early_stop_overlap_threshold=args.early_stop_overlap_threshold, + early_stop_zero_overlap_patience=args.early_stop_zero_overlap_patience, + device=device, ) + if args.track_loss_history: + loss_history_path = save_loss_history_sqlite( + result["loss_history"], + loss_tracking_db_path, + ) + print(f"Loss history saved to: {loss_history_path}") + else: + print("Loss history tracking disabled.") # Calculate final metrics (both detailed and normalized) print("\n" + "=" * 70) @@ -813,4 +1261,5 @@ def main(): ) if __name__ == "__main__": - main() + args = parse_args() + run_with_optional_profile(lambda: main(args), args, OUTPUT_DIR) diff --git a/profiler_helper.py b/profiler_helper.py new file mode 100644 index 0000000..b5bd1ec --- /dev/null +++ b/profiler_helper.py @@ -0,0 +1,32 @@ +import os +from datetime import datetime + + +def build_profile_path(output_dir, profile_tag): + """Build a timestamped profile output path.""" + profile_dir = os.path.join(output_dir, "profile") + os.makedirs(profile_dir, exist_ok=True) + + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + filename_parts = ["profile"] + if profile_tag: + filename_parts.append(profile_tag) + filename_parts.append(timestamp) + + return os.path.join(profile_dir, "_".join(filename_parts) + ".prof") + + +def run_with_optional_profile(main_fn, args, output_dir): + """Run main_fn(), optionally under cProfile.""" + if not args.profile: + main_fn() + return + + import cProfile + + profiler = cProfile.Profile() + profiler.runcall(main_fn) + + profile_path = build_profile_path(output_dir, args.profile_tag) + profiler.dump_stats(profile_path) + print(f"\nProfile stats dumped to: {profile_path}") diff --git a/test.py b/test.py index f22ff21..db038b6 100644 --- a/test.py +++ b/test.py @@ -6,65 +6,58 @@ of various sizes and reports metrics for leaderboard submission. Usage: - python test_placement.py + python test.py Metrics Reported: - Average Overlap: (num cells with overlaps / total num cells) - Average Wirelength: (total wirelength / num nets) / sqrt(total area) This normalization allows fair comparison across different design sizes. -Note: This test uses the default hyperparameters from train_placement() in -vb_playground.py. The challenge is to implement the overlap loss function, -not to tune hyperparameters. +Note: This test reuses the shared CLI hyperparameter options from placement.py +and evaluates them across the benchmark test cases. """ +import os import time - -import torch +from concurrent.futures import ProcessPoolExecutor, as_completed + +from arg_parse_util import parse_args +from benchmark_test_cases import ACTIVE_TEST_CASES +from learning_rate_scheduler_util import build_scheduler_kwargs_from_args +from torch_profiler_util import ( + build_torch_profiler_config_from_args, + run_with_optional_profile, +) # Import from the challenge file from placement import ( + OUTPUT_DIR, calculate_normalized_metrics, generate_placement_input, + initialize_cell_positions, + plot_placement, + resolve_device, + seed_torch, train_placement, ) - - -# Test case configurations: (test_id, num_macros, num_std_cells, seed) -TEST_CASES = [ - # Small designs - (1, 2, 20, 1001), - (2, 3, 25, 1002), - (3, 2, 30, 1003), - # Medium designs - (4, 3, 50, 1004), - (5, 4, 75, 1005), - (6, 5, 100, 1006), - # Large designs - (7, 5, 150, 1007), - (8, 7, 150, 1008), - (9, 8, 200, 1009), - (10, 10, 2000, 1010), - # Realistic designs - (11, 10, 10000, 1011), - (12, 10, 100000, 1012), -] +from loss_tracking_utils import create_loss_tracking_db, save_loss_history_sqlite def run_placement_test( test_id, num_macros, num_std_cells, + loss_tracking_db_path, + training_config, seed=None, ): """Run placement optimization on a single test case. - Uses default hyperparameters from train_placement() function. - Args: test_id: Test case identifier num_macros: Number of macro cells num_std_cells: Number of standard cells + training_config: Hyperparameters for train_placement seed: Random seed for reproducibility Returns: @@ -72,37 +65,73 @@ def run_placement_test( """ if seed: # Set seed for reproducibility - torch.manual_seed(seed) + seed_torch(seed) + + device = resolve_device(training_config["device"]) # Generate netlist cell_features, pin_features, edge_list = generate_placement_input( - num_macros, num_std_cells + num_macros, + num_std_cells, + device=device, ) # Initialize positions with random spread - total_cells = cell_features.shape[0] - total_area = cell_features[:, 0].sum().item() - spread_radius = (total_area ** 0.5) * 0.6 + initialize_cell_positions(cell_features) - angles = torch.rand(total_cells) * 2 * 3.14159 - radii = torch.rand(total_cells) * spread_radius - - cell_features[:, 2] = radii * torch.cos(angles) - cell_features[:, 3] = radii * torch.sin(angles) - - # Run optimization with default hyperparameters + # Run optimization with the selected hyperparameters start_time = time.time() result = train_placement( cell_features, pin_features, edge_list, + num_epochs=training_config["num_epochs"], + lr=training_config["lr"], + lambda_wirelength=training_config["lambda_wirelength"], + lambda_overlap=training_config["lambda_overlap"], + scheduler_name=training_config["scheduler_name"], + scheduler_kwargs=training_config["scheduler_kwargs"], + track_loss_history=training_config["track_loss_history"], verbose=False, # Suppress per-epoch output + run_metadata={ + "runner": "test.py", + "profile_tag": training_config["profile_tag"], + "test_id": test_id, + "seed": seed, + "num_macros": num_macros, + "num_std_cells": num_std_cells, + }, + torch_profiler_config=training_config["torch_profiler_config"], + torch_profile_output_dir=OUTPUT_DIR, + track_overlap_metrics=training_config["track_overlap_metrics"], + early_stop_enabled=training_config["early_stop_enabled"], + early_stop_patience=training_config["early_stop_patience"], + early_stop_min_delta=training_config["early_stop_min_delta"], + early_stop_overlap_threshold=training_config["early_stop_overlap_threshold"], + early_stop_zero_overlap_patience=training_config[ + "early_stop_zero_overlap_patience" + ], + device=device, ) elapsed_time = time.time() - start_time + loss_history_path = None + if training_config["track_loss_history"]: + loss_history_path = save_loss_history_sqlite( + result["loss_history"], + loss_tracking_db_path, + ) # Calculate final metrics using shared implementation final_cell_features = result["final_cell_features"] metrics = calculate_normalized_metrics(final_cell_features, pin_features, edge_list) + visualization_filename = f"placement_test_{test_id}_result.png" + plot_placement( + result["initial_cell_features"], + final_cell_features, + pin_features, + edge_list, + filename=visualization_filename, + ) return { "test_id": test_id, @@ -111,63 +140,201 @@ def run_placement_test( "total_cells": metrics["total_cells"], "num_nets": metrics["num_nets"], "seed": seed, + "device": str(device), "elapsed_time": elapsed_time, + "loss_history_path": loss_history_path, # Final metrics "num_cells_with_overlaps": metrics["num_cells_with_overlaps"], "overlap_ratio": metrics["overlap_ratio"], "normalized_wl": metrics["normalized_wl"], + "visualization_path": os.path.join(OUTPUT_DIR, visualization_filename), } -def run_all_tests(): - """Run all test cases and compute aggregate metrics. +def run_placement_test_case_with_config(test_case, loss_tracking_db_path, training_config): + """Unpack a test-case tuple for multiprocessing execution with config.""" + test_id, num_macros, num_std_cells, seed = test_case + return run_placement_test( + test_id, + num_macros, + num_std_cells, + loss_tracking_db_path, + training_config, + seed, + ) + + +def _run_tests_serial(test_cases, loss_tracking_db_path, training_config): + """Run test cases sequentially when process pools are unavailable.""" + completed_results = {} + for test_case in test_cases: + result = run_placement_test_case_with_config( + test_case, + loss_tracking_db_path, + training_config, + ) + completed_results[result["test_id"]] = result + + status = "✓ PASS" if result["num_cells_with_overlaps"] == 0 else "✗ FAIL" + print(f"Completed test {result['test_id']}:") + print(f" Device: {result['device']}") + print( + f" Overlap Ratio: {result['overlap_ratio']:.4f} " + f"({result['num_cells_with_overlaps']}/{result['total_cells']} cells)" + ) + print(f" Normalized WL: {result['normalized_wl']:.4f}") + print(f" Time: {result['elapsed_time']:.2f}s") + if result["loss_history_path"] is not None: + print(f" History: {result['loss_history_path']}") + print(f" Image: {result['visualization_path']}") + print(f" Status: {status}") + print() - Uses default hyperparameters from train_placement() function. + return completed_results + + +def run_all_tests(args): + """Run all test cases and compute aggregate metrics. Returns: Dictionary with all test results and aggregate statistics """ + training_config = { + "num_epochs": args.num_epochs, + "lr": args.lr, + "lambda_wirelength": args.lambda_wirelength, + "lambda_overlap": args.lambda_overlap, + "scheduler_name": args.scheduler, + "scheduler_kwargs": build_scheduler_kwargs_from_args(args), + "track_loss_history": args.track_loss_history, + "track_overlap_metrics": args.track_overlap_metrics, + "early_stop_enabled": args.early_stop, + "early_stop_patience": args.early_stop_patience, + "early_stop_min_delta": args.early_stop_min_delta, + "early_stop_overlap_threshold": args.early_stop_overlap_threshold, + "early_stop_zero_overlap_patience": args.early_stop_zero_overlap_patience, + "profile_tag": args.profile_tag, + "torch_profiler_config": build_torch_profiler_config_from_args(args), + "device": args.device, + } + max_workers = args.workers + print("=" * 70) print("PLACEMENT CHALLENGE TEST SUITE") print("=" * 70) - print(f"\nRunning {len(TEST_CASES)} test cases with various netlist sizes...") - print("Using default hyperparameters from train_placement()") + print(f"\nRunning {len(ACTIVE_TEST_CASES)} test cases with various netlist sizes...") + print("Using hyperparameters:") + print(f" num_epochs: {training_config['num_epochs']}") + print(f" lr: {training_config['lr']}") + print(f" lambda_wirelength: {training_config['lambda_wirelength']}") + print(f" lambda_overlap: {training_config['lambda_overlap']}") + print(f" scheduler: {training_config['scheduler_name']}") + print(f" scheduler_kwargs: {training_config['scheduler_kwargs']}") + print(f" device: {training_config['device']}") + print(f" track_loss_history: {training_config['track_loss_history']}") + print(f" track_overlap_metrics: {training_config['track_overlap_metrics']}") + print(f" early_stop_enabled: {training_config['early_stop_enabled']}") + print(f" early_stop_patience: {training_config['early_stop_patience']}") + print(f" early_stop_min_delta: {training_config['early_stop_min_delta']}") + print( + " early_stop_overlap_threshold: " + f"{training_config['early_stop_overlap_threshold']}" + ) + print( + " early_stop_zero_overlap_patience: " + f"{training_config['early_stop_zero_overlap_patience']}" + ) + print(f" workers: {max_workers}") + print(f" torch_profile: {training_config['torch_profiler_config'].enabled}") print() - all_results = [] + loss_tracking_db_path = None + if args.track_loss_history: + loss_tracking_db_path = create_loss_tracking_db(OUTPUT_DIR) + print(f"Writing loss history to: {loss_tracking_db_path}") + print() + else: + print("Loss history tracking disabled.") + print() - for idx, (test_id, num_macros, num_std_cells, seed) in enumerate(TEST_CASES, 1): + for idx, (test_id, num_macros, num_std_cells, seed) in enumerate(ACTIVE_TEST_CASES, 1): size_category = ( "Small" if num_std_cells <= 30 else "Medium" if num_std_cells <= 100 else "Large" ) - print(f"Test {idx}/{len(TEST_CASES)}: {size_category} ({num_macros} macros, {num_std_cells} std cells)") + print( + f"Test {idx}/{len(ACTIVE_TEST_CASES)}: " + f"{size_category} ({num_macros} macros, {num_std_cells} std cells)" + ) print(f" Seed: {seed}") + if max_workers == 1: + print("Running serially") + else: + print(f"Running up to {max_workers} tests concurrently") + print() - # Run test - result = run_placement_test( - test_id, - num_macros, - num_std_cells, - seed, + wall_start_time = time.time() + if max_workers == 1: + completed_results = _run_tests_serial( + ACTIVE_TEST_CASES, + loss_tracking_db_path, + training_config, ) - - all_results.append(result) - - # Print summary - status = "✓ PASS" if result["num_cells_with_overlaps"] == 0 else "✗ FAIL" - print(f" Overlap Ratio: {result['overlap_ratio']:.4f} ({result['num_cells_with_overlaps']}/{result['total_cells']} cells)") - print(f" Normalized WL: {result['normalized_wl']:.4f}") - print(f" Time: {result['elapsed_time']:.2f}s") - print(f" Status: {status}") - print() + else: + try: + with ProcessPoolExecutor(max_workers=max_workers) as executor: + future_to_test_case = { + executor.submit( + run_placement_test_case_with_config, + test_case, + loss_tracking_db_path, + training_config, + ): test_case + for test_case in ACTIVE_TEST_CASES + } + + completed_results = {} + for future in as_completed(future_to_test_case): + result = future.result() + completed_results[result["test_id"]] = result + + status = "✓ PASS" if result["num_cells_with_overlaps"] == 0 else "✗ FAIL" + print(f"Completed test {result['test_id']}:") + print(f" Device: {result['device']}") + print( + f" Overlap Ratio: {result['overlap_ratio']:.4f} " + f"({result['num_cells_with_overlaps']}/{result['total_cells']} cells)" + ) + print(f" Normalized WL: {result['normalized_wl']:.4f}") + print(f" Time: {result['elapsed_time']:.2f}s") + if result["loss_history_path"] is not None: + print(f" History: {result['loss_history_path']}") + print(f" Image: {result['visualization_path']}") + print(f" Status: {status}") + print() + except PermissionError: + print( + "Process pool unavailable in this environment; " + "falling back to serial execution." + ) + print() + completed_results = _run_tests_serial( + ACTIVE_TEST_CASES, + loss_tracking_db_path, + training_config, + ) + + all_results = [ + completed_results[test_id] + for test_id, _, _, _ in ACTIVE_TEST_CASES + ] # Compute aggregate statistics avg_overlap_ratio = sum(r["overlap_ratio"] for r in all_results) / len(all_results) avg_normalized_wl = sum(r["normalized_wl"] for r in all_results) / len(all_results) - total_time = sum(r["elapsed_time"] for r in all_results) + total_time = time.time() - wall_start_time # Print aggregate results print("=" * 70) @@ -185,11 +352,11 @@ def run_all_tests(): } -def main(): +def main(args): """Main entry point for the test suite.""" - # Run all tests with default hyperparameters - run_all_tests() + run_all_tests(args) if __name__ == "__main__": - main() + args = parse_args() + run_with_optional_profile(lambda: main(args), args, OUTPUT_DIR) diff --git a/torch_profiler_util.py b/torch_profiler_util.py new file mode 100644 index 0000000..6401ca7 --- /dev/null +++ b/torch_profiler_util.py @@ -0,0 +1,214 @@ +import json +import os +import re +from dataclasses import asdict, dataclass +from datetime import datetime + +import torch + + +@dataclass(frozen=True) +class TorchProfilerConfig: + enabled: bool = False + wait: int = 1 + warmup: int = 1 + active: int = 3 + repeat: int = 1 + record_shapes: bool = True + profile_memory: bool = True + with_stack: bool = True + acc_events: bool = False + + +def build_profile_path(output_dir, profile_tag): + """Build a timestamped cProfile output path.""" + profile_dir = os.path.join(output_dir, "profile") + os.makedirs(profile_dir, exist_ok=True) + + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + filename_parts = ["profile"] + if profile_tag: + filename_parts.append(profile_tag) + filename_parts.append(timestamp) + + return os.path.join(profile_dir, "_".join(filename_parts) + ".prof") + + +def build_torch_profiler_config_from_args(args): + """Create a serializable torch profiler config from CLI args.""" + return TorchProfilerConfig( + enabled=args.torch_profile, + wait=args.torch_profile_wait, + warmup=args.torch_profile_warmup, + active=args.torch_profile_active, + repeat=args.torch_profile_repeat, + record_shapes=args.torch_profile_record_shapes, + profile_memory=args.torch_profile_memory, + with_stack=args.torch_profile_with_stack, + acc_events=args.torch_profile_acc_events, + ) + + +def run_with_optional_profile(main_fn, args, output_dir): + """Run main_fn(), optionally under cProfile.""" + if not args.profile: + main_fn() + return + + import cProfile + + profiler = cProfile.Profile() + profiler.runcall(main_fn) + + profile_path = build_profile_path(output_dir, args.profile_tag) + profiler.dump_stats(profile_path) + print(f"\nProfile stats dumped to: {profile_path}") + + +class TorchProfilerSession: + """Manage an optional torch.profiler session for a training loop.""" + + def __init__(self, config, output_dir, profile_tag="", run_metadata=None): + self.config = config or TorchProfilerConfig() + self.output_dir = output_dir + self.profile_tag = profile_tag + self.run_metadata = dict(run_metadata or {}) + self.trace_dir = None + self.summary_path = None + self.metadata_path = None + self._activities = None + self._profiler = None + self._profiler_context = None + self._base_name = None + + def __enter__(self): + if not self.config.enabled: + return self + + self._base_name = self._build_base_name() + self.trace_dir = self._build_trace_dir() + self.summary_path = os.path.join( + self.trace_dir, + f"{self._base_name}_key_averages.txt", + ) + self.metadata_path = os.path.join( + self.trace_dir, + f"{self._base_name}_metadata.json", + ) + + profiler_module = torch.profiler + self._activities = [profiler_module.ProfilerActivity.CPU] + if torch.cuda.is_available(): + self._activities.append(profiler_module.ProfilerActivity.CUDA) + + self._profiler_context = profiler_module.profile( + activities=self._activities, + schedule=profiler_module.schedule( + wait=self.config.wait, + warmup=self.config.warmup, + active=self.config.active, + repeat=self.config.repeat, + ), + on_trace_ready=profiler_module.tensorboard_trace_handler( + self.trace_dir, + worker_name=self._base_name, + ), + record_shapes=self.config.record_shapes, + profile_memory=self.config.profile_memory, + with_stack=self.config.with_stack, + acc_events=self.config.acc_events, + ) + self._profiler = self._profiler_context.__enter__() + + self._write_metadata() + print(f"Torch profiler enabled. Writing traces to: {self.trace_dir}") + return self + + def __exit__(self, exc_type, exc_value, traceback): + if not self.config.enabled: + return False + + should_suppress = False + if self._profiler_context is not None: + should_suppress = self._profiler_context.__exit__( + exc_type, + exc_value, + traceback, + ) + self._write_summary() + print(f"Torch profiler summary saved to: {self.summary_path}") + return should_suppress + + def step(self): + """Advance the profiler schedule by one training step.""" + if self._profiler is not None: + self._profiler.step() + + def _build_trace_dir(self): + profile_root = os.path.join(self.output_dir, "torch_profile") + os.makedirs(profile_root, exist_ok=True) + trace_dir = os.path.join(profile_root, self._base_name) + os.makedirs(trace_dir, exist_ok=True) + return trace_dir + + def _build_base_name(self): + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + filename_parts = ["torch_profile"] + if self.profile_tag: + filename_parts.append(self.profile_tag) + + runner = self.run_metadata.get("runner") + if runner: + filename_parts.append(str(runner)) + + test_id = self.run_metadata.get("test_id") + if test_id is not None: + filename_parts.append(f"test_{test_id}") + + filename_parts.append(f"pid_{os.getpid()}") + filename_parts.append(timestamp) + return "_".join(_slugify(part) for part in filename_parts if part) + + def _write_metadata(self): + metadata = { + "created_at": datetime.now().isoformat(timespec="seconds"), + "activities": [activity.name for activity in self._activities], + "config": asdict(self.config), + "run_metadata": self.run_metadata, + } + with open(self.metadata_path, "w", encoding="utf-8") as metadata_file: + json.dump(metadata, metadata_file, indent=2, sort_keys=True) + + def _write_summary(self): + if self._profiler is None or self.summary_path is None: + return + + sort_by = "self_cuda_time_total" + if all(activity.name != "CUDA" for activity in self._activities): + sort_by = "self_cpu_time_total" + + summary = self._profiler.key_averages().table( + sort_by=sort_by, + row_limit=50, + ) + with open(self.summary_path, "w", encoding="utf-8") as summary_file: + summary_file.write(summary) + + +def create_torch_profiler_session( + config, + output_dir, + profile_tag="", + run_metadata=None, +): + """Return a no-op or active torch profiler session for a training loop.""" + return TorchProfilerSession( + config=config, + output_dir=output_dir, + profile_tag=profile_tag, + run_metadata=run_metadata, + ) + + +def _slugify(value): + return re.sub(r"[^A-Za-z0-9._-]+", "-", str(value)).strip("-") or "run"