Skip to content

GitLab

Commit 3c15726c authored by yangzhong's avatar yangzhong
Browse files

git init

parents
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 2111 additions and 0 deletions
CONTRIBUTING.md 0 → 100644
View file @ 3c15726c
## Contributing
The best way to contribute to the MLCommons is to get involved with one of our many project communities. You find more information about getting involved with MLCommons [here](https://mlcommons.org/en/get-involved/#getting-started).
Generally we encourage people to become a MLCommons member if they wish to contribute to MLCommons projects, but outside pull requests are very welcome too.
To get started contributing code, you or your organization needs to sign the MLCommons CLA found at the [MLC policies page](https://mlcommons.org/en/policies/). Once you or your organization has signed the corporate CLA, please fill out this [CLA sign up form](https://forms.gle/Ew1KkBVpyeJDuRw67) form to get your specific GitHub handle authorized so that you can start contributing code under the proper license.
MLCommons project work is tracked with issue trackers and pull requests. Modify the project in your own fork and issue a pull request once you want other developers to take a look at what you have done and discuss the proposed changes. Ensure that cla-bot and other checks pass for your Pull requests.
DEPS 0 → 100644
View file @ 3c15726c
vars = {
# Pull in chromium build files and tools for multi-platform build support.
'chromium_git': 'https://chromium.googlesource.com/chromium/src',
'mlpth_root': 'src',
}
deps = {
'{mlpth_root}/build': {
'url': '{chromium_git}/build@e3ed5e43c305b353b49e08ac69e7f4d1c2d88ad2'
},
'{mlpth_root}/buildtools': {
'url': '{chromium_git}/buildtools@106e9fce3799633f42b45ca8bbe9e84e1e235603'
},
'{mlpth_root}/tools/clang': {
'url': '{chromium_git}/tools/clang.git@3114fbc11f9644c54dd0a4cdbfa867bac50ff983',
},
'{mlpth_root}/third_party/pybind': {
'url': 'https://github.com/pybind/pybind11.git@v2.2',
},
}
recursedeps = [
'{mlpth_root}/buildtools',
]
hooks = [
# Pull clang-format binaries using checked-in hashes.
{
'name': 'clang_format_win',
'pattern': '.',
'condition': 'host_os == "win"',
'action': [ 'download_from_google_storage',
'--no_resume',
'--platform=win32',
'--no_auth',
'--bucket', 'chromium-clang-format',
'-s', '{mlpth_root}/buildtools/win/clang-format.exe.sha1',
],
},
{
'name': 'clang_format_mac',
'pattern': '.',
'condition': 'host_os == "mac"',
'action': [ 'download_from_google_storage',
'--no_resume',
'--platform=darwin',
'--no_auth',
'--bucket', 'chromium-clang-format',
'-s', '{mlpth_root}/buildtools/mac/clang-format.sha1',
],
},
{
'name': 'clang_format_linux',
'pattern': '.',
'condition': 'host_os == "linux"',
'action': [ 'download_from_google_storage',
'--no_resume',
'--platform=linux*',
'--no_auth',
'--bucket', 'chromium-clang-format',
'-s', '{mlpth_root}/buildtools/linux64/clang-format.sha1',
],
},
# Pull GN using checked-in hashes.
{
'name': 'gn_win',
'pattern': '.',
'condition': 'host_os == "win"',
'action': [ 'download_from_google_storage',
'--no_resume',
'--platform=win32',
'--no_auth',
'--bucket', 'chromium-gn',
'-s', '{mlpth_root}/buildtools/win/gn.exe.sha1',
],
},
{
'name': 'gn_mac',
'pattern': '.',
'condition': 'host_os == "mac"',
'action': [ 'download_from_google_storage',
'--no_resume',
'--platform=darwin',
'--no_auth',
'--bucket', 'chromium-gn',
'-s', '{mlpth_root}/buildtools/mac/gn.sha1',
],
},
{
'name': 'gn_linux',
'pattern': '.',
'condition': 'host_os == "linux"',
'action': [ 'download_from_google_storage',
'--no_resume',
'--platform=linux*',
'--no_auth',
'--bucket', 'chromium-gn',
'-s', '{mlpth_root}/buildtools/linux64/gn.sha1',
],
},
# Pull sysroots.
{
'name': 'sysroot_arm',
'pattern': '.',
'condition': '(checkout_linux and checkout_arm)',
'action': ['python', '{mlpth_root}/build/linux/sysroot_scripts/install-sysroot.py',
'--arch=arm'],
},
{
'name': 'sysroot_arm64',
'pattern': '.',
'condition': '(checkout_linux and checkout_arm64)',
'action': ['python', '{mlpth_root}/build/linux/sysroot_scripts/install-sysroot.py',
'--arch=arm64'],
},
{
'name': 'sysroot_x86',
'pattern': '.',
'condition': '(checkout_linux and (checkout_x86 or checkout_x64))',
'action': ['python', '{mlpth_root}/build/linux/sysroot_scripts/install-sysroot.py',
'--arch=x86'],
},
{
'name': 'sysroot_mips',
'pattern': '.',
'condition': '(checkout_linux and checkout_mips)',
'action': ['python', '{mlpth_root}/build/linux/sysroot_scripts/install-sysroot.py',
'--arch=mips'],
},
{
'name': 'sysroot_x64',
'pattern': '.',
'condition': 'checkout_linux and checkout_x64',
'action': ['python', '{mlpth_root}/build/linux/sysroot_scripts/install-sysroot.py',
'--arch=x64'],
},
{
# Update the Windows toolchain if necessary.
'name': 'win_toolchain',
'pattern': '.',
'condition': 'checkout_win',
'action': ['python', '{mlpth_root}/build/vs_toolchain.py', 'update'],
},
{
'name': 'fuchsia_sdk',
'pattern': '.',
'condition': 'checkout_fuchsia',
'action': [
'python',
'{mlpth_root}/build/fuchsia/update_sdk.py',
],
},
{
# Note: On Win, this should run after win_toolchain, as it may use it.
'name': 'clang',
'pattern': '.',
# clang not supported on aix
'condition': 'host_os != "aix"',
'action': ['python', '{mlpth_root}//tools/clang/scripts/update.py'],
},
]
LICENSE.md 0 → 100644
View file @ 3c15726c
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
README.md 0 → 100644
View file @ 3c15726c
### Retinanet-pytorch inference
##### 1.修改配置文件
配置路径（根据你的实际路径修改）
数据集:open-images-v6-mlperf validation
例：/public/opendas/DL_DATA/open-images-v6-mlperf/validation
开源权重模型文件：resnext50_32x4d_fpn.pth
在/retinanet_infer_pytorch/vision/classification_and_detection/retinanet_acc.sh启动脚本中修改
##### 2.推理
```
cd /retinanet_infer_pytorch/vision/classification_and_detection/
chmod +x retinanet_acc.sh
bash retinanet_acc.sh
```
SubmissionExample.ipynb 0 → 100644
View file @ 3c15726c
This diff is collapsed.
Submission_Guidelines.md 0 → 100644
View file @ 3c15726c
## Submission Rules
The MLPerf inference submission rules are spread between the [MLCommons policies](https://github.com/mlcommons/policies/blob/master/submission_rules.adoc) and the [MLCommons Inference policies](https://github.com/mlcommons/inference_policies/blob/master/inference_rules.adoc) documents. Further, the rules related to power submissions are given [here](https://github.com/mlcommons/inference_policies/blob/master/power_measurement.adoc). The below points are a summary taken from the official rules to act as a checklist for the submitter - please see the original rules for any clarification.
## Hardware requirements
1. MLCommons inference results can be submitted on any hardware and we have past results from Raspberry Pi to high-end inference servers.
2. Closed category submission for datacenter category needs **ECC RAM** and also needs to have the **networking** capabilities as detailed [here](https://github.com/mlcommons/inference_policies/blob/master/inference_rules.adoc#networking-from-the-v30-round)
3. Power submissions need an [approved power analyzer](https://github.com/mlcommons/inference_policies/blob/master/power_measurement.adoc#74-which-power-analyzers-aka-meters-are-supported).
## Things to Know
1. Closed submission needs performance and accuracy run for all the required scenarios (as per edge/datacenter category) with accuracy within 99% or 99.9% as given in the respective task READMEs. Further, the model weights are not supposed to be altered except for quantization. If any of these constraints are not met, the submission cannot go under closed division but can still be submitted under open division.
2. Reference models are mostly fp32 and reference implementations are just for reference and not meant to be directly used by submitters as they are not optimized for performance.
3. Calibration document due **one week** before the submission deadline
4. Power submission needs a power analyzer (approved by SPEC Power) and EULA signature to get access to SPEC PTDaemon
5. To submit under the `available` category your submission system must be available (in whole or in parts and either publicly or to customers) and the software used must be either open source or an **official or beta release** as on the submission deadline. Submissions using nightly release for example cannot be submitted under the available category.
### Is there an automatic way to run the MLPerf inference benchmarks?
MLPerf inference submissions are expected to be run on various hardware and supported software stacks. Therefore, MLCommons provides only reference implementations to guide submitters in creating optimal implementations for their specific software and hardware configurations. Additionally, all implementations used for MLPerf inference submissions are available in the MLCommons [Inference results](https://github.com/orgs/mlcommons/repositories?q=inference_results_v+sort%3Aname) repositories (under `closed/<submitter>/code` directory), offering further guidance for submitters developing their own implementations.
### Expected time to do benchmark runs
1. Closed submission under datacenter needs offline and server scenario runs with a minimum of ten minutes needed for both.
2. Closed submission under the edge category needs single stream, multi-stream (only for R50 and retinanet), and offline scenarios. A minimum of ten minutes is needed for each scenario.
3. Further two (three for ResNet50) compliance runs are needed for closed division, each taking at least 10 minutes for each scenario.
4. SingleStream, MultiStream and Server scenarios use early stopping and so can always finish around 10 minutes
5. Offline scenario needs a minimum of 24756 input queries to be processed -- can take hours for low-performing models like 3dunet, LLMs, etc.
6. Open division has no accuracy constraints, no required compliance runs, and can be submitted for any single scenario. There is no constraint on the model used except that the model accuracy must be validated on the accuracy dataset used in the corresponding MLPerf inference task [or must be preapproved](https://github.com/mlcommons/inference_policies/blob/master/inference_rules.adoc#412-relaxed-constraints-for-the-open-division).
7. Power submission needs an extra ranging mode to determine the peak current usage and this often doubles the overall experiment run time. If this overhead is too much, ranging run can be reduced to 5 minutes run using mechanisms like [this](https://github.com/mlcommons/cm4mlops/blob/main/script/benchmark-program-mlperf/customize.py#L18).
## Validity of the submission
1. [MLCommons Inference submission checker](https://github.com/mlcommons/inference/blob/master/tools/submission/submission_checker.py) is provided to ensure that all submissions are passing the required checks.
2. In the unlikely event that there is an error on the submission checker for your submission, please raise a GitHub issue [here](https://github.com/mlcommons/inference/issues)
3. Any submission passing the submission checker is valid to go to the review discussions but submitters are still required to answer any queries and fix any issues being reported by other submitters.
### Reviewing other submissions
1. Ensure that the `system_desc_id.json` file is having meaningful responses - `submission_checker` only checks for the existence of the fields.
2. For power submissions, `power settings` and `analyzer table` files are to be submitted, and even though the submission checker checks for the existence of these files, the content of [these files](https://github.com/mlcommons/inference_policies/blob/master/power_measurement.adoc#64-power-management-settings) must be checked manually for validity.
3. README files in the submission directory must be checked to make sure that the instructions are reproducible.
4. For closed datacenter submissions, [ECC RAM and Networking requirements](https://github.com/mlcommons/inference_policies/blob/master/inference_rules.adoc#constraints-for-the-closed-division) must be ensured.
5. Submission checker might be reporting warnings and some of these warnings can warrant an answer from the submitter.
## Changes from MLCommons Inference 4.0
1. One new benchmark in the datacenter category: Mixtral-8x7B. No changes in the edge category.
2. For power submissions, there is no code change.
automotive/3d-object-detection/README.md 0 → 100644
View file @ 3c15726c
## Reference implementation fo automotive 3D detection benchmark
## Dataset and model checkpoints
Contact MLCommons support for accessing the Waymo Open Dataset along with the model checkpoints for the reference implementation. You will need to accept a license agreement and will be given directions to download the data. You will need to place the kitti_format folder under a directory named waymo. There are four total checkpoints 2 for pytorch and 2 for onnx.
## Running with docker
Build the container and mount the inference repo and Waymo dataset directory.
```
docker build -t auto_inference -f dockerfile.gpu .
docker run --gpus=all -it -v <directory to inference repo>/inference/:/inference -v <path to waymo dataset>/waymo:/waymo --rm auto_inference
```
### Run with GPU
```
cd /inference/automotive/3d-object-detection
python main.py --dataset waymo --dataset-path /waymo/kitti_format/ --lidar-path <checkpoint_path>/pp_ep36.pth --segmentor-path <checkpoint_path>/best_deeplabv3plus_resnet50_waymo_os16.pth --mlperf_conf /inference/mlperf.conf
```
### Run with CPU and ONNX
```
python main.py --dataset waymo --dataset-path /waymo/kitti_format/ --lidar-path <checkpoint_path>/pp.onnx --segmentor-path <checkpoint_path>/deeplabv3+.onnx --mlperf_conf /inference/mlperf.conf
```
### Run the accuracy checker
```
python accuracy_waymo.py --mlperf-accuracy-file <path to accuracy file>/mlperf_log_accuracy.json --waymo-dir /waymo/kitti_format/
```
automotive/3d-object-detection/accuracy_waymo.py 0 → 100644
View file @ 3c15726c
"""
Tool to calculate accuracy for loadgen accuracy output found in mlperf_log_accuracy.json
We assume that loadgen's query index is in the same order as
the images in coco's annotations/instances_val2017.json.
"""
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import argparse
import json
import os
import numpy as np
from waymo import Waymo
from tools.evaluate import do_eval
# pylint: disable=missing-docstring
CLASSES = Waymo.CLASSES
LABEL2CLASSES = {v: k for k, v in CLASSES.items()}
def get_args():
"""Parse commandline."""
parser = argparse.ArgumentParser()
parser.add_argument(
"--mlperf-accuracy-file",
required=True,
help="path to mlperf_log_accuracy.json")
parser.add_argument(
"--waymo-dir",
required=True,
help="waymo dataset directory")
parser.add_argument(
"--verbose",
action="store_true",
help="verbose messages")
parser.add_argument(
"--output-file",
default="openimages-results.json",
help="path to output file")
parser.add_argument(
"--use-inv-map",
action="store_true",
help="use inverse label map")
args = parser.parse_args()
return args
def main():
args = get_args()
with open(args.mlperf_accuracy_file, "r") as f:
results = json.load(f)
detections = {}
image_ids = set()
seen = set()
no_results = 0
val_dataset = Waymo(
data_root=args.waymo_dir,
split='val',
painted=True,
cam_sync=False)
for j in results:
idx = j['qsl_idx']
# de-dupe in case loadgen sends the same image multiple times
if idx in seen:
continue
seen.add(idx)
# reconstruct from mlperf accuracy log
# what is written by the benchmark is an array of float32's:
# id, box[0], box[1], box[2], box[3], score, detection_class
# note that id is a index into instances_val2017.json, not the actual
# image_id
data = np.frombuffer(bytes.fromhex(j['data']), np.float32)
for i in range(0, len(data), 14):
dimension = [float(x) for x in data[i:i + 3]]
location = [float(x) for x in data[i + 3:i + 6]]
rotation_y = float(data[i + 6])
bbox = [float(x) for x in data[i + 7:i + 11]]
label = int(data[i + 11])
score = float(data[i + 12])
image_idx = int(data[i + 13])
if image_idx not in detections:
detections[image_idx] = {
'name': [],
'dimensions': [],
'location': [],
'rotation_y': [],
'bbox': [],
'score': []
}
if dimension[0] > 0:
detections[image_idx]['name'].append(LABEL2CLASSES[label])
detections[image_idx]['dimensions'].append(dimension)
detections[image_idx]['location'].append(location)
detections[image_idx]['rotation_y'].append(rotation_y)
detections[image_idx]['bbox'].append(bbox)
detections[image_idx]['score'].append(score)
image_ids.add(image_idx)
with open(args.output_file, "w") as fp:
json.dump(detections, fp, sort_keys=True, indent=4)
format_results = {}
for key in detections.keys():
format_results[key] = {k: np.array(v)
for k, v in detections[key].items()}
map_stats = do_eval(
format_results,
val_dataset.data_infos,
CLASSES,
cam_sync=False)
map_stats['Total'] = np.mean(list(map_stats.values()))
print(map_stats)
if args.verbose:
print("found {} results".format(len(results)))
print("found {} images".format(len(image_ids)))
print("found {} images with no results".format(no_results))
print("ignored {} dupes".format(len(results) - len(seen)))
if __name__ == "__main__":
main()
automotive/3d-object-detection/backend.py 0 → 100644
View file @ 3c15726c
"""
abstract backend class
"""
class Backend:
def __init__(self):
self.inputs = []
self.outputs = []
def version(self):
raise NotImplementedError("Backend:version")
def name(self):
raise NotImplementedError("Backend:name")
def load(self, model_path, inputs=None, outputs=None):
raise NotImplementedError("Backend:load")
def predict(self, feed):
raise NotImplementedError("Backend:predict")
automotive/3d-object-detection/backend_debug.py 0 → 100644
View file @ 3c15726c
import torch
import backend
class BackendDebug(backend.Backend):
def __init__(self, image_size=[3, 1024, 1024], **kwargs):
super(BackendDebug, self).__init__()
self.image_size = image_size
def version(self):
return torch.__version__
def name(self):
return "debug-SUT"
def image_format(self):
return "NCHW"
def load(self):
return self
def predict(self, prompts):
images = []
return images
automotive/3d-object-detection/backend_deploy.py 0 → 100644
View file @ 3c15726c
from typing import Optional, List, Union
import os
import torch
import logging
import backend
from collections import namedtuple
from model.painter import Painter
from model.pointpillars import PointPillars
import numpy as np
from tools.process import keep_bbox_from_image_range
from waymo import Waymo
logging.basicConfig(level=logging.INFO)
log = logging.getLogger("backend-pytorch")
def change_calib_device(calib, cuda):
result = {}
if cuda:
device = 'cuda'
else:
device = 'cpu'
result['R0_rect'] = calib['R0_rect'].to(device=device, dtype=torch.float)
for i in range(5):
result['P' + str(i)] = calib['P' + str(i)
].to(device=device, dtype=torch.float)
result['Tr_velo_to_cam_' +
str(i)] = calib['Tr_velo_to_cam_' +
str(i)].to(device=device, dtype=torch.float)
return result
class BackendDeploy(backend.Backend):
def __init__(
self,
segmentor_path,
lidar_detector_path,
data_path
):
super(BackendDeploy, self).__init__()
self.segmentor_path = segmentor_path
self.lidar_detector_path = lidar_detector_path
# self.segmentation_classes = 18
self.detection_classes = 3
self.data_root = data_path
CLASSES = Waymo.CLASSES
self.LABEL2CLASSES = {v: k for k, v in CLASSES.items()}
def version(self):
return torch.__version__
def name(self):
return "python-SUT"
def load(self):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
PaintArgs = namedtuple(
'PaintArgs', [
'training_path', 'model_path', 'cam_sync'])
painting_args = PaintArgs(
os.path.join(
self.data_root,
'training'),
self.segmentor_path,
False)
self.painter = Painter(painting_args)
self.segmentor = self.painter.model
model = PointPillars(
nclasses=self.detection_classes,
painted=True).to(
device=device)
model.eval()
checkpoint = torch.load(self.lidar_detector_path)
model.load_state_dict(checkpoint["model_state_dict"])
self.lidar_detector = model
return self
def predict(self, inputs):
dimensions, locations, rotation_y, box2d, class_labels, class_scores, ids = [
], [], [], [], [], [], []
with torch.inference_mode():
device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
model_input = inputs[0]
batched_pts = model_input['pts']
scores_from_cam = []
for i in range(len(model_input['images'])):
segmentation_score = self.segmentor(
model_input['images'][i].to(device))[0]
scores_from_cam.append(
self.painter.get_score(segmentation_score).cpu())
points = self.painter.augment_lidar_class_scores_both(
scores_from_cam, batched_pts, model_input['calib_info'])
batch_results = self.lidar_detector(
batched_pts=[points.to(device=device)], mode='val')
for j, result in enumerate(batch_results):
format_result = {
'class': [],
'truncated': [],
'occluded': [],
'alpha': [],
'bbox': [],
'dimensions': [],
'location': [],
'rotation_y': [],
'score': [],
'idx': -1
}
calib_info = model_input['calib_info']
image_info = model_input['image_info']
idx = model_input['image_info']['image_idx']
format_result['idx'] = idx
calib_info = change_calib_device(calib_info, False)
result_filter = keep_bbox_from_image_range(
result, calib_info, 5, image_info, False)
lidar_bboxes = result_filter['lidar_bboxes']
labels, scores = result_filter['labels'], result_filter['scores']
bboxes2d, camera_bboxes = result_filter['bboxes2d'], result_filter['camera_bboxes']
for lidar_bbox, label, score, bbox2d, camera_bbox in \
zip(lidar_bboxes, labels, scores, bboxes2d, camera_bboxes):
format_result['class'].append(label.item())
format_result['truncated'].append(0.0)
format_result['occluded'].append(0)
alpha = camera_bbox[6] - \
np.arctan2(camera_bbox[0], camera_bbox[2])
format_result['alpha'].append(alpha.item())
format_result['bbox'].append(bbox2d.tolist())
format_result['dimensions'].append(camera_bbox[3:6])
format_result['location'].append(camera_bbox[:3])
format_result['rotation_y'].append(camera_bbox[6].item())
format_result['score'].append(score.item())
if len(format_result['dimensions']) > 0:
format_result['dimensions'] = torch.stack(
format_result['dimensions'])
format_result['location'] = torch.stack(
format_result['location'])
dimensions.append(format_result['dimensions'])
locations.append(format_result['location'])
rotation_y.append(format_result['rotation_y'])
class_labels.append(format_result['class'])
class_scores.append(format_result['score'])
box2d.append(format_result['bbox'])
ids.append(format_result['idx'])
return dimensions, locations, rotation_y, box2d, class_labels, class_scores, ids
automotive/3d-object-detection/backend_onnx.py 0 → 100644
View file @ 3c15726c
from typing import Optional, List, Union
import os
import torch
import logging
import backend
from collections import namedtuple
from model.painter import Painter
from model.pointpillars_core import PointPillarsPre, PointPillarsPos
import numpy as np
from tools.process import keep_bbox_from_image_range
from waymo import Waymo
import onnxruntime as ort
logging.basicConfig(level=logging.INFO)
log = logging.getLogger("backend-onnx")
def change_calib_device(calib, cuda):
result = {}
if cuda:
device = 'cuda'
else:
device = 'cpu'
result['R0_rect'] = calib['R0_rect'].to(device=device, dtype=torch.float)
for i in range(5):
result['P' + str(i)] = calib['P' + str(i)
].to(device=device, dtype=torch.float)
result['Tr_velo_to_cam_' +
str(i)] = calib['Tr_velo_to_cam_' +
str(i)].to(device=device, dtype=torch.float)
return result
def to_numpy(tensor):
return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()
class BackendOnnx(backend.Backend):
def __init__(
self,
segmentor_path,
lidar_detector_path,
data_path
):
super(BackendOnnx, self).__init__()
self.segmentor_path = segmentor_path
self.lidar_detector_path = lidar_detector_path
# self.segmentation_classes = 18
self.detection_classes = 3
self.data_root = data_path
CLASSES = Waymo.CLASSES
self.LABEL2CLASSES = {v: k for k, v in CLASSES.items()}
def version(self):
return torch.__version__
def name(self):
return "python-SUT"
def load(self):
device = torch.device("cpu")
PaintArgs = namedtuple(
'PaintArgs', [
'training_path', 'model_path', 'cam_sync'])
painting_args = PaintArgs(
os.path.join(
self.data_root,
'training'),
self.segmentor_path,
False)
self.painter = Painter(painting_args, onnx=True)
self.segmentor = self.painter.model
model_pre = PointPillarsPre()
model_post = PointPillarsPos(self.detection_classes)
model_pre.eval()
model_post.eval()
ort_sess = ort.InferenceSession(self.lidar_detector_path)
self.lidar_detector = ort_sess
self.model_pre = model_pre
self.model_post = model_post
return self
def predict(self, inputs):
dimensions, locations, rotation_y, box2d, class_labels, class_scores, ids = [
], [], [], [], [], [], []
with torch.inference_mode():
model_input = inputs[0]
batched_pts = model_input['pts']
scores_from_cam = []
for i in range(len(model_input['images'])):
input_image_name = self.segmentor.get_inputs()[0].name
input_data = {
input_image_name: to_numpy(
model_input['images'][i])}
segmentation_score = self.segmentor.run(None, input_data)
segmentation_score = [
torch.from_numpy(item) for item in segmentation_score]
scores_from_cam.append(
self.painter.get_score(
segmentation_score[0].squeeze(0)).cpu())
points = self.painter.augment_lidar_class_scores_both(
scores_from_cam, batched_pts, model_input['calib_info'])
pillars, coors_batch, npoints_per_pillar = self.model_pre(batched_pts=[
points])
input_pillars_name = self.lidar_detector.get_inputs()[0].name
input_coors_batch_name = self.lidar_detector.get_inputs()[1].name
input_npoints_per_pillar_name = self.lidar_detector.get_inputs()[
2].name
input_data = {input_pillars_name: to_numpy(pillars),
input_coors_batch_name: to_numpy(coors_batch),
input_npoints_per_pillar_name: to_numpy(npoints_per_pillar)}
result = self.lidar_detector.run(None, input_data)
result = [torch.from_numpy(item) for item in result]
batch_results = self.model_post(result)
for j, result in enumerate(batch_results):
format_result = {
'class': [],
'truncated': [],
'occluded': [],
'alpha': [],
'bbox': [],
'dimensions': [],
'location': [],
'rotation_y': [],
'score': [],
'idx': -1
}
calib_info = model_input['calib_info']
image_info = model_input['image_info']
idx = model_input['image_info']['image_idx']
format_result['idx'] = idx
calib_info = change_calib_device(calib_info, False)
result_filter = keep_bbox_from_image_range(
result, calib_info, 5, image_info, False)
lidar_bboxes = result_filter['lidar_bboxes']
labels, scores = result_filter['labels'], result_filter['scores']
bboxes2d, camera_bboxes = result_filter['bboxes2d'], result_filter['camera_bboxes']
for lidar_bbox, label, score, bbox2d, camera_bbox in \
zip(lidar_bboxes, labels, scores, bboxes2d, camera_bboxes):
format_result['class'].append(label.item())
format_result['truncated'].append(0.0)
format_result['occluded'].append(0)
alpha = camera_bbox[6] - \
np.arctan2(camera_bbox[0], camera_bbox[2])
format_result['alpha'].append(alpha.item())
format_result['bbox'].append(bbox2d.tolist())
format_result['dimensions'].append(camera_bbox[3:6])
format_result['location'].append(camera_bbox[:3])
format_result['rotation_y'].append(camera_bbox[6].item())
format_result['score'].append(score.item())
if len(format_result['dimensions']) > 0:
format_result['dimensions'] = torch.stack(
format_result['dimensions'])
format_result['location'] = torch.stack(
format_result['location'])
dimensions.append(format_result['dimensions'])
locations.append(format_result['location'])
rotation_y.append(format_result['rotation_y'])
class_labels.append(format_result['class'])
class_scores.append(format_result['score'])
box2d.append(format_result['bbox'])
ids.append(format_result['idx'])
return dimensions, locations, rotation_y, box2d, class_labels, class_scores, ids
automotive/3d-object-detection/dataset.py 0 → 100644
View file @ 3c15726c
"""
dataset related classes and methods
"""
# pylint: disable=unused-argument,missing-docstring
import logging
import sys
import time
import numpy as np
import torch
logging.basicConfig(level=logging.INFO)
log = logging.getLogger("dataset")
class Dataset:
def __init__(self):
self.items_inmemory = {}
def preprocess(self, use_cache=True):
raise NotImplementedError("Dataset:preprocess")
def get_item_count(self):
raise NotImplementedError("Dataset:get_item_count")
def get_list(self):
raise NotImplementedError("Dataset:get_list")
def load_query_samples(self, sample_list):
raise NotImplementedError("Dataset:load_query_samples")
def unload_query_samples(self, sample_list):
raise NotImplementedError("Dataset:unload_query_samples")
def get_samples(self, id_list):
raise NotImplementedError("Dataset:get_samples")
def get_item(self, id):
raise NotImplementedError("Dataset:get_item")
def preprocess(list_data):
batched_pts_list, batched_gt_bboxes_list = [], []
batched_labels_list, batched_names_list = [], []
batched_difficulty_list = []
batched_img_list, batched_calib_list = [], []
batched_images = []
for data_dict in list_data:
pts, gt_bboxes_3d = data_dict['pts'], data_dict['gt_bboxes_3d']
gt_labels, gt_names = data_dict['gt_labels'], data_dict['gt_names']
difficulty = data_dict['difficulty']
image_info, calib_info = data_dict['image_info'], data_dict['calib_info']
batched_pts_list.append(torch.from_numpy(pts))
batched_gt_bboxes_list.append(torch.from_numpy(gt_bboxes_3d))
batched_labels_list.append(torch.from_numpy(gt_labels))
batched_names_list.append(gt_names) # List(str)
batched_difficulty_list.append(torch.from_numpy(difficulty))
batched_img_list.append(image_info)
batched_calib_list.append(calib_info)
batched_images.append(data_dict['images'])
rt_data_dict = dict(
batched_pts=batched_pts_list,
batched_gt_bboxes=batched_gt_bboxes_list,
batched_labels=batched_labels_list,
batched_names=batched_names_list,
batched_difficulty=batched_difficulty_list,
batched_img_info=batched_img_list,
batched_calib_info=batched_calib_list,
batched_images=batched_images
)
return rt_data_dict
automotive/3d-object-detection/dockerfile cpu 0 → 100644
View file @ 3c15726c
ARG FROM_IMAGE_NAME=nvcr.io/nvidia/pytorch:23.08-py3
FROM ${FROM_IMAGE_NAME}
ENV DEBIAN_FRONTEND=noninteractive
# apt dependencies
RUN apt-get update
RUN apt-get install -y ffmpeg libsm6 libxext6
# install LDM
COPY . /diffusion
RUN cd /diffusion && \
pip install --no-cache-dir -r requirements.txt
# install loadgen
RUN cd /tmp && \
git clone --recursive https://github.com/mlcommons/inference && \
cd inference/loadgen && \
pip install pybind11 && \
CFLAGS="-std=c++14" python setup.py install && \
rm -rf mlperf
\ No newline at end of file
automotive/3d-object-detection/dockerfile.gpu 0 → 100644
View file @ 3c15726c
ARG FROM_IMAGE_NAME=pytorch/pytorch:2.2.2-cuda11.8-cudnn8-devel
FROM ${FROM_IMAGE_NAME}
ENV DEBIAN_FRONTEND=noninteractive
# apt dependencies
RUN apt-get update
RUN apt-get install -y ffmpeg libsm6 libxext6 git
# install LDM
COPY . /diffusion
RUN cd /diffusion && \
pip install --no-cache-dir -r requirements.txt
# install loadgen
RUN cd /tmp && \
git clone --recursive https://github.com/mlcommons/inference && \
cd inference/loadgen && \
pip install pybind11 && \
CFLAGS="-std=c++14" python setup.py install && \
rm -rf mlperf
RUN pip install tqdm==4.65.0
RUN pip install numba==0.60.0
RUN pip install opencv-python==4.11.0.86
RUN pip install open3d==0.19.0
RUN pip install scikit-image==0.25.0
RUN pip install ninja==1.11.1
RUN pip install shapely==2.0.6
RUN pip install tensorboard==2.18.0
RUN pip install onnxruntime==1.20.1
\ No newline at end of file
automotive/3d-object-detection/main.py 0 → 100644
View file @ 3c15726c
"""
mlperf inference benchmarking tool
"""
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import argparse
import array
import collections
import json
import logging
import os
import sys
import threading
import time
from queue import Queue
import mlperf_loadgen as lg
import numpy as np
import torch
import dataset
import waymo
logging.basicConfig(level=logging.INFO)
log = logging.getLogger("main")
NANO_SEC = 1e9
MILLI_SEC = 1000
SUPPORTED_DATASETS = {
"waymo": (
waymo.Waymo,
dataset.preprocess,
waymo.PostProcessWaymo(),
{} # "image_size": [3, 1024, 1024]},
)
}
SUPPORTED_PROFILES = {
"defaults": {
"dataset": "waymo",
"backend": "pytorch",
"model-name": "pointpainting",
},
}
SCENARIO_MAP = {
"SingleStream": lg.TestScenario.SingleStream,
"MultiStream": lg.TestScenario.MultiStream,
"Server": lg.TestScenario.Server,
"Offline": lg.TestScenario.Offline,
}
def get_args():
parser = argparse.ArgumentParser()
parser.add_argument(
"--dataset",
choices=SUPPORTED_DATASETS.keys(),
help="dataset")
parser.add_argument(
"--dataset-path",
required=True,
help="path to the dataset")
parser.add_argument(
"--profile", choices=SUPPORTED_PROFILES.keys(), help="standard profiles"
)
parser.add_argument(
"--scenario",
default="SingleStream",
help="mlperf benchmark scenario, one of " +
str(list(SCENARIO_MAP.keys())),
)
parser.add_argument(
"--max-batchsize",
type=int,
default=1,
help="max batch size in a single inference",
)
parser.add_argument("--threads", default=1, type=int, help="threads")
parser.add_argument(
"--accuracy",
action="store_true",
help="enable accuracy pass")
parser.add_argument(
"--find-peak-performance",
action="store_true",
help="enable finding peak performance pass",
)
parser.add_argument("--backend", help="Name of the backend")
parser.add_argument("--model-name", help="Name of the model")
parser.add_argument("--output", default="output", help="test results")
parser.add_argument("--qps", type=int, help="target qps")
parser.add_argument("--lidar-path", help="Path to model weights")
parser.add_argument("--segmentor-path", help="Path to model weights")
parser.add_argument(
"--dtype",
default="fp32",
choices=["fp32", "fp16", "bf16"],
help="dtype of the model",
)
parser.add_argument(
"--device",
default="cuda",
choices=["cuda", "cpu"],
help="device to run the benchmark",
)
# file to use mlperf rules compliant parameters
parser.add_argument(
"--mlperf_conf", default="mlperf.conf", help="mlperf rules config"
)
# file for user LoadGen settings such as target QPS
parser.add_argument(
"--user_conf",
default="user.conf",
help="user config for user LoadGen settings such as target QPS",
)
# file for LoadGen audit settings
parser.add_argument(
"--audit_conf", default="audit.config", help="config for LoadGen audit settings"
)
# below will override mlperf rules compliant settings - don't use for
# official submission
parser.add_argument("--time", type=int, help="time to scan in seconds")
parser.add_argument("--count", type=int, help="dataset items to use")
parser.add_argument("--debug", action="store_true", help="debug")
parser.add_argument(
"--performance-sample-count", type=int, help="performance sample count", default=5000
)
parser.add_argument(
"--max-latency", type=float, help="mlperf max latency in pct tile"
)
parser.add_argument(
"--samples-per-query",
default=8,
type=int,
help="mlperf multi-stream samples per query",
)
args = parser.parse_args()
# don't use defaults in argparser. Instead we default to a dict, override that with a profile
# and take this as default unless command line give
defaults = SUPPORTED_PROFILES["defaults"]
if args.profile:
profile = SUPPORTED_PROFILES[args.profile]
defaults.update(profile)
for k, v in defaults.items():
kc = k.replace("-", "_")
if getattr(args, kc) is None:
setattr(args, kc, v)
if args.scenario not in SCENARIO_MAP:
parser.error("valid scanarios:" + str(list(SCENARIO_MAP.keys())))
return args
def get_backend(backend, **kwargs):
if backend == "pytorch":
from backend_deploy import BackendDeploy
backend = BackendDeploy(**kwargs)
elif backend == 'onnx':
from backend_onnx import BackendOnnx
backend = BackendOnnx(**kwargs)
elif backend == "debug":
from backend_debug import BackendDebug
backend = BackendDebug()
else:
raise ValueError("unknown backend: " + backend)
return backend
class Item:
"""An item that we queue for processing by the thread pool."""
def __init__(self, query_id, content_id, inputs, img=None):
self.query_id = query_id
self.content_id = content_id
self.img = img
self.inputs = inputs
self.start = time.time()
class RunnerBase:
def __init__(self, model, ds, threads, post_proc=None, max_batchsize=128):
self.take_accuracy = False
self.ds = ds
self.model = model
self.post_process = post_proc
self.threads = threads
self.take_accuracy = False
self.max_batchsize = max_batchsize
self.result_timing = []
def handle_tasks(self, tasks_queue):
pass
def start_run(self, result_dict, take_accuracy):
self.result_dict = result_dict
self.result_timing = []
self.take_accuracy = take_accuracy
self.post_process.start()
def run_one_item(self, qitem: Item):
# run the prediction
processed_results = []
try:
results = self.model.predict(qitem.inputs)
processed_results = self.post_process(
results, qitem.content_id, qitem.inputs, self.result_dict)
if self.take_accuracy:
self.post_process.add_results(processed_results)
self.result_timing.append(time.time() - qitem.start)
except Exception as ex: # pylint: disable=broad-except
src = [self.ds.get_item_loc(i) for i in qitem.content_id]
log.error("thread: failed on contentid=%s, %s", src, ex)
# since post_process will not run, fake empty responses
processed_results = [[]] * len(qitem.query_id)
finally:
response_array_refs = []
response = []
for idx, query_id in enumerate(qitem.query_id):
response_array = array.array("B", np.array(
processed_results[idx], np.float32).tobytes())
response_array_refs.append(response_array)
bi = response_array.buffer_info()
response.append(lg.QuerySampleResponse(query_id, bi[0], bi[1]))
lg.QuerySamplesComplete(response)
def enqueue(self, query_samples):
idx = [q.index for q in query_samples]
query_id = [q.id for q in query_samples]
if len(query_samples) < self.max_batchsize:
data, label = self.ds.get_samples(idx)
self.run_one_item(Item(query_id, idx, data, label))
else:
bs = self.max_batchsize
for i in range(0, len(idx), bs):
data, label = self.ds.get_samples(idx[i: i + bs])
self.run_one_item(
Item(query_id[i: i + bs], idx[i: i + bs], data, label)
)
def finish(self):
pass
class QueueRunner(RunnerBase):
def __init__(self, model, ds, threads, post_proc=None, max_batchsize=128):
super().__init__(model, ds, threads, post_proc, max_batchsize)
self.tasks = Queue(maxsize=threads * 4)
self.workers = []
self.result_dict = {}
for _ in range(self.threads):
worker = threading.Thread(
target=self.handle_tasks, args=(
self.tasks,))
worker.daemon = True
self.workers.append(worker)
worker.start()
def handle_tasks(self, tasks_queue):
"""Worker thread."""
while True:
qitem = tasks_queue.get()
if qitem is None:
# None in the queue indicates the parent want us to exit
tasks_queue.task_done()
break
self.run_one_item(qitem)
tasks_queue.task_done()
def enqueue(self, query_samples):
idx = [q.index for q in query_samples]
query_id = [q.id for q in query_samples]
if len(query_samples) < self.max_batchsize:
data, label = self.ds.get_samples(idx)
self.tasks.put(Item(query_id, idx, data, label))
else:
bs = self.max_batchsize
for i in range(0, len(idx), bs):
ie = i + bs
data, label = self.ds.get_samples(idx[i:ie])
self.tasks.put(Item(query_id[i:ie], idx[i:ie], data, label))
def finish(self):
# exit all threads
for _ in self.workers:
self.tasks.put(None)
for worker in self.workers:
worker.join()
def main():
args = get_args()
log.info(args)
# find backend
backend = get_backend(
# TODO: pass model, inference and backend arguments
args.backend,
lidar_detector_path=args.lidar_path,
segmentor_path=args.segmentor_path,
data_path=args.dataset_path
)
if args.dtype == "fp16":
dtype = torch.float16
elif args.dtype == "bf16":
dtype = torch.bfloat16
else:
dtype = torch.float32
# --count applies to accuracy mode only and can be used to limit the number of images
# for testing.
count_override = False
count = args.count
if count:
count_override = True
# load model to backend
model = backend.load()
# dataset to use
dataset_class, pre_proc, post_proc, kwargs = SUPPORTED_DATASETS[args.dataset]
ds = dataset_class(
data_root=args.dataset_path,
split='val',
painted=True,
cam_sync=False)
final_results = {
"runtime": model.name(),
"version": model.version(),
"time": int(time.time()),
"args": vars(args),
"cmdline": str(args),
}
mlperf_conf = os.path.abspath(args.mlperf_conf)
if not os.path.exists(mlperf_conf):
log.error("{} not found".format(mlperf_conf))
sys.exit(1)
user_conf = os.path.abspath(args.user_conf)
if not os.path.exists(user_conf):
log.error("{} not found".format(user_conf))
sys.exit(1)
audit_config = os.path.abspath(args.audit_conf)
if args.output:
output_dir = os.path.abspath(args.output)
os.makedirs(output_dir, exist_ok=True)
os.chdir(output_dir)
#
# make one pass over the dataset to validate accuracy
#
count = ds.get_item_count()
# warmup
# TODO: Load warmup samples, the following code is a general
# way of doing this, but might need some fixing
ds.load_query_samples([0])
for i in range(5):
input = ds.get_samples([0])
_ = backend.predict(input[0])
scenario = SCENARIO_MAP[args.scenario]
runner_map = {
lg.TestScenario.SingleStream: RunnerBase,
lg.TestScenario.MultiStream: QueueRunner,
lg.TestScenario.Server: QueueRunner,
lg.TestScenario.Offline: QueueRunner,
}
runner = runner_map[scenario](
model, ds, args.threads, post_proc=post_proc, max_batchsize=args.max_batchsize
)
def issue_queries(query_samples):
runner.enqueue(query_samples)
def flush_queries():
pass
log_output_settings = lg.LogOutputSettings()
log_output_settings.outdir = output_dir
log_output_settings.copy_summary_to_stdout = False
log_settings = lg.LogSettings()
log_settings.enable_trace = args.debug
log_settings.log_output = log_output_settings
settings = lg.TestSettings()
settings.FromConfig(user_conf, args.model_name, args.scenario)
settings.scenario = scenario
settings.mode = lg.TestMode.PerformanceOnly
if args.accuracy:
settings.mode = lg.TestMode.AccuracyOnly
if args.find_peak_performance:
settings.mode = lg.TestMode.FindPeakPerformance
if args.time:
# override the time we want to run
settings.min_duration_ms = args.time * MILLI_SEC
settings.max_duration_ms = args.time * MILLI_SEC
if args.qps:
qps = float(args.qps)
settings.server_target_qps = qps
settings.offline_expected_qps = qps
if count_override:
settings.min_query_count = count
settings.max_query_count = count
if args.samples_per_query:
settings.multi_stream_samples_per_query = args.samples_per_query
if args.max_latency:
settings.server_target_latency_ns = int(args.max_latency * NANO_SEC)
settings.multi_stream_expected_latency_ns = int(
args.max_latency * NANO_SEC)
performance_sample_count = (
args.performance_sample_count
if args.performance_sample_count
else min(count, 500)
)
sut = lg.ConstructSUT(issue_queries, flush_queries)
qsl = lg.ConstructQSL(
count, performance_sample_count, ds.load_query_samples, ds.unload_query_samples
)
log.info("starting {}".format(scenario))
result_dict = {"scenario": str(scenario)}
runner.start_run(result_dict, args.accuracy)
lg.StartTestWithLogSettings(sut, qsl, settings, log_settings, audit_config)
if args.accuracy:
post_proc.finalize(result_dict, ds)
final_results["accuracy_results"] = result_dict
runner.finish()
lg.DestroyQSL(qsl)
lg.DestroySUT(sut)
#
# write final results
#
if args.output:
with open("results.json", "w") as f:
json.dump(final_results, f, sort_keys=True, indent=4)
if __name__ == "__main__":
main()
automotive/3d-object-detection/model/__init__.py 0 → 100644
View file @ 3c15726c
from .anchors import Anchors, anchors2bboxes, bboxes2deltas
from .pointpillars import PointPillars
automotive/3d-object-detection/model/anchors.py 0 → 100644
View file @ 3c15726c
import torch
import math
from tools.process import limit_period, iou2d_nearest
class Anchors():
def __init__(self, ranges, sizes, rotations):
assert len(ranges) == len(sizes)
self.ranges = ranges
self.sizes = sizes
self.rotations = rotations
def get_anchors(self, feature_map_size, anchor_range,
anchor_size, rotations):
'''
feature_map_size: (y_l, x_l)
anchor_range: [x1, y1, z1, x2, y2, z2]
anchor_size: [w, l, h]
rotations: [0, 1.57]
return: shape=(y_l, x_l, 2, 7)
'''
device = feature_map_size.device
x_centers = torch.linspace(
anchor_range[0],
anchor_range[3],
feature_map_size[1] + 1,
device=device)
y_centers = torch.linspace(
anchor_range[1],
anchor_range[4],
feature_map_size[0] + 1,
device=device)
z_centers = torch.linspace(
anchor_range[2],
anchor_range[5],
1 + 1,
device=device)
x_shift = (x_centers[1] - x_centers[0]) / 2
y_shift = (y_centers[1] - y_centers[0]) / 2
z_shift = (z_centers[1] - z_centers[0]) / 2
x_centers = x_centers[:feature_map_size[1]] + \
x_shift # (feature_map_size[1], )
y_centers = y_centers[:feature_map_size[0]] + \
y_shift # (feature_map_size[0], )
z_centers = z_centers[:1] + z_shift # (1, )
# [feature_map_size[1], feature_map_size[0], 1, 2] * 4
meshgrids = torch.meshgrid(x_centers, y_centers, z_centers, rotations)
meshgrids = list(meshgrids)
for i in range(len(meshgrids)):
# [feature_map_size[1], feature_map_size[0], 1, 2, 1]
meshgrids[i] = meshgrids[i][..., None]
anchor_size = anchor_size[None, None, None, None, :]
repeat_shape = [
feature_map_size[1],
feature_map_size[0],
1,
len(rotations),
1]
# [feature_map_size[1], feature_map_size[0], 1, 2, 3]
anchor_size = anchor_size.repeat(repeat_shape)
meshgrids.insert(3, anchor_size)
# [1, feature_map_size[0], feature_map_size[1], 2, 7]
anchors = torch.cat(
meshgrids,
dim=-
1).permute(
2,
1,
0,
3,
4).contiguous()
return anchors.squeeze(0)
def get_multi_anchors(self, feature_map_size):
'''
feature_map_size: (y_l, x_l)
ranges: [[x1, y1, z1, x2, y2, z2], [x1, y1, z1, x2, y2, z2], [x1, y1, z1, x2, y2, z2]]
sizes: [[w, l, h], [w, l, h], [w, l, h]]
rotations: [0, 1.57]
return: shape=(y_l, x_l, 3, 2, 7)
'''
device = feature_map_size.device
ranges = torch.tensor(self.ranges, device=device)
sizes = torch.tensor(self.sizes, device=device)
rotations = torch.tensor(self.rotations, device=device)
multi_anchors = []
for i in range(len(ranges)):
anchors = self.get_anchors(feature_map_size=feature_map_size,
anchor_range=ranges[i],
anchor_size=sizes[i],
rotations=rotations)
multi_anchors.append(anchors[:, :, None, :, :])
multi_anchors = torch.cat(multi_anchors, dim=2)
return multi_anchors
def anchors2bboxes(anchors, deltas):
'''
anchors: (M, 7), (x, y, z, w, l, h, theta)
deltas: (M, 7)
return: (M, 7)
'''
da = torch.sqrt(anchors[:, 3] ** 2 + anchors[:, 4] ** 2)
x = deltas[:, 0] * da + anchors[:, 0]
y = deltas[:, 1] * da + anchors[:, 1]
z = deltas[:, 2] * anchors[:, 5] + anchors[:, 2] + anchors[:, 5] / 2
w = anchors[:, 3] * torch.exp(deltas[:, 3])
l = anchors[:, 4] * torch.exp(deltas[:, 4])
h = anchors[:, 5] * torch.exp(deltas[:, 5])
z = z - h / 2
theta = anchors[:, 6] + deltas[:, 6]
bboxes = torch.stack([x, y, z, w, l, h, theta], dim=1)
return bboxes
def bboxes2deltas(bboxes, anchors):
'''
bboxes: (M, 7), (x, y, z, w, l, h, theta)
anchors: (M, 7)
return: (M, 7)
'''
da = torch.sqrt(anchors[:, 3] ** 2 + anchors[:, 4] ** 2)
dx = (bboxes[:, 0] - anchors[:, 0]) / da
dy = (bboxes[:, 1] - anchors[:, 1]) / da
zb = bboxes[:, 2] + bboxes[:, 5] / 2 # bottom center
za = anchors[:, 2] + anchors[:, 5] / 2 # bottom center
dz = (zb - za) / anchors[:, 5] # bottom center
dw = torch.log(bboxes[:, 3] / anchors[:, 3])
dl = torch.log(bboxes[:, 4] / anchors[:, 4])
dh = torch.log(bboxes[:, 5] / anchors[:, 5])
dtheta = bboxes[:, 6] - anchors[:, 6]
deltas = torch.stack([dx, dy, dz, dw, dl, dh, dtheta], dim=1)
return deltas
def anchor_target(batched_anchors, batched_gt_bboxes,
batched_gt_labels, assigners, nclasses):
'''
batched_anchors: [(y_l, x_l, 3, 2, 7), (y_l, x_l, 3, 2, 7), ... ]
batched_gt_bboxes: [(n1, 7), (n2, 7), ...]
batched_gt_labels: [(n1, ), (n2, ), ...]
return:
dict = {batched_anchors_labels: (bs, n_anchors),
batched_labels_weights: (bs, n_anchors),
batched_anchors_reg: (bs, n_anchors, 7),
batched_reg_weights: (bs, n_anchors),
batched_anchors_dir: (bs, n_anchors),
batched_dir_weights: (bs, n_anchors)}
'''
assert len(batched_anchors) == len(
batched_gt_bboxes) == len(batched_gt_labels)
batch_size = len(batched_anchors)
n_assigners = len(assigners)
batched_labels, batched_label_weights = [], []
batched_bbox_reg, batched_bbox_reg_weights = [], []
batched_dir_labels, batched_dir_labels_weights = [], []
for i in range(batch_size):
anchors = batched_anchors[i]
gt_bboxes, gt_labels = batched_gt_bboxes[i], batched_gt_labels[i]
# what we want to get next ?
# 1. identify positive anchors and negative anchors -> cls
# 2. identify the regresstion values -> reg
# 3. indentify the direction -> dir_cls
multi_labels, multi_label_weights = [], []
multi_bbox_reg, multi_bbox_reg_weights = [], []
multi_dir_labels, multi_dir_labels_weights = [], []
d1, d2, d3, d4, d5 = anchors.size()
for j in range(n_assigners): # multi anchors
assigner = assigners[j]
pos_iou_thr, neg_iou_thr, min_iou_thr = \
assigner['pos_iou_thr'], assigner['neg_iou_thr'], assigner['min_iou_thr']
cur_anchors = anchors[:, :, j, :, :].reshape(-1, 7)
overlaps = iou2d_nearest(gt_bboxes, cur_anchors)
if overlaps.shape[0] == 0:
max_overlaps = torch.zeros_like(
cur_anchors[:, 0], dtype=cur_anchors.dtype)
max_overlaps_idx = torch.zeros_like(
cur_anchors[:, 0], dtype=torch.long)
else:
max_overlaps, max_overlaps_idx = torch.max(overlaps, dim=0)
gt_max_overlaps, _ = torch.max(overlaps, dim=1)
assigned_gt_inds = - \
torch.ones_like(cur_anchors[:, 0], dtype=torch.long)
# a. negative anchors
assigned_gt_inds[max_overlaps < neg_iou_thr] = 0
# b. positive anchors
# rule 1
assigned_gt_inds[max_overlaps >=
pos_iou_thr] = max_overlaps_idx[max_overlaps >= pos_iou_thr] + 1
# rule 2
# support one bbox to multi anchors, only if the anchors are with the highest iou.
# rule2 may modify the labels generated by rule 1
for i in range(len(gt_bboxes)):
if gt_max_overlaps[i] >= min_iou_thr:
assigned_gt_inds[overlaps[i] == gt_max_overlaps[i]] = i + 1
pos_flag = assigned_gt_inds > 0
neg_flag = assigned_gt_inds == 0
# 1. anchor labels
# -1 is not optimal, for some bboxes are with labels -1
assigned_gt_labels = torch.zeros_like(
cur_anchors[:, 0], dtype=torch.long) + nclasses
assigned_gt_labels[pos_flag] = gt_labels[assigned_gt_inds[pos_flag] - 1].long()
assigned_gt_labels_weights = torch.zeros_like(cur_anchors[:, 0])
assigned_gt_labels_weights[pos_flag] = 1
assigned_gt_labels_weights[neg_flag] = 1
# 2. anchor regression
assigned_gt_reg_weights = torch.zeros_like(cur_anchors[:, 0])
assigned_gt_reg_weights[pos_flag] = 1
assigned_gt_reg = torch.zeros_like(cur_anchors)
positive_anchors = cur_anchors[pos_flag]
corr_gt_bboxes = gt_bboxes[assigned_gt_inds[pos_flag] - 1]
assigned_gt_reg[pos_flag] = bboxes2deltas(
corr_gt_bboxes, positive_anchors)
# 3. anchor direction
assigned_gt_dir_weights = torch.zeros_like(cur_anchors[:, 0])
assigned_gt_dir_weights[pos_flag] = 1
assigned_gt_dir = torch.zeros_like(
cur_anchors[:, 0], dtype=torch.long)
dir_cls_targets = limit_period(
corr_gt_bboxes[:, 6].cpu(), 0, 2 * math.pi).to(corr_gt_bboxes)
dir_cls_targets = torch.floor(dir_cls_targets / math.pi).long()
assigned_gt_dir[pos_flag] = torch.clamp(
dir_cls_targets, min=0, max=1)
multi_labels.append(assigned_gt_labels.reshape(d1, d2, 1, d4))
multi_label_weights.append(
assigned_gt_labels_weights.reshape(
d1, d2, 1, d4))
multi_bbox_reg.append(assigned_gt_reg.reshape(d1, d2, 1, d4, -1))
multi_bbox_reg_weights.append(
assigned_gt_reg_weights.reshape(
d1, d2, 1, d4))
multi_dir_labels.append(assigned_gt_dir.reshape(d1, d2, 1, d4))
multi_dir_labels_weights.append(
assigned_gt_dir_weights.reshape(
d1, d2, 1, d4))
multi_labels = torch.cat(multi_labels, dim=-2).reshape(-1)
multi_label_weights = torch.cat(
multi_label_weights, dim=-2).reshape(-1)
multi_bbox_reg = torch.cat(multi_bbox_reg, dim=-3).reshape(-1, d5)
multi_bbox_reg_weights = torch.cat(
multi_bbox_reg_weights, dim=-2).reshape(-1)
multi_dir_labels = torch.cat(multi_dir_labels, dim=-2).reshape(-1)
multi_dir_labels_weights = torch.cat(
multi_dir_labels_weights, dim=-2).reshape(-1)
batched_labels.append(multi_labels)
batched_label_weights.append(multi_label_weights)
batched_bbox_reg.append(multi_bbox_reg)
batched_bbox_reg_weights.append(multi_bbox_reg_weights)
batched_dir_labels.append(multi_dir_labels)
batched_dir_labels_weights.append(multi_dir_labels_weights)
rt_dict = dict(
batched_labels=torch.stack(
batched_labels, 0), # (bs, y_l * x_l * 3 * 2)
batched_label_weights=torch.stack(
batched_label_weights, 0), # (bs, y_l * x_l * 3 * 2)
batched_bbox_reg=torch.stack(
batched_bbox_reg, 0), # (bs, y_l * x_l * 3 * 2, 7)
batched_bbox_reg_weights=torch.stack(
batched_bbox_reg_weights, 0), # (bs, y_l * x_l * 3 * 2)
batched_dir_labels=torch.stack(
batched_dir_labels, 0), # (bs, y_l * x_l * 3 * 2)
batched_dir_labels_weights=torch.stack(
batched_dir_labels_weights, 0) # (bs, y_l * x_l * 3 * 2)
)
return rt_dict
automotive/3d-object-detection/model/painter.py 0 → 100644
View file @ 3c15726c
import onnxruntime as ort
import argparse
import model.segmentation as network
import os
import numpy as np
import torch
from torchvision import transforms
from PIL import Image
import copy
import sys
from tqdm import tqdm
sys.path.append('..')
def get_calib_from_file(calib_file):
"""Read in a calibration file and parse into a dictionary."""
data = {}
with open(calib_file, 'r') as f:
lines = [line for line in f.readlines() if line.strip()]
for line in lines:
key, value = line.split(':', 1)
# The only non-float values in these files are dates, which
# we don't care about anyway
try:
if key == 'R0_rect':
data['R0'] = torch.tensor([float(x)
for x in value.split()]).reshape(3, 3)
else:
data[key] = torch.tensor([float(x)
for x in value.split()]).reshape(3, 4)
except ValueError:
pass
return data
def to_numpy(tensor):
return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()
class Painter:
def __init__(self, args, onnx=False):
self.root_split_path = args.training_path
self.save_path = os.path.join(args.training_path, "painted_lidar/")
self.onnx = onnx
if not os.path.exists(self.save_path):
os.mkdir(self.save_path)
self.seg_net_index = 0
self.model = None
print(f'Using Segmentation Network -- deeplabv3plus')
checkpoint_file = args.model_path
if self.onnx:
model = ort.InferenceSession(checkpoint_file)
self.input_image_name = model.get_inputs()[0].name
else:
model = network.modeling.__dict__['deeplabv3plus_resnet50'](
num_classes=19, output_stride=16)
checkpoint = torch.load(checkpoint_file)
model.load_state_dict(checkpoint["model_state"])
model.eval()
device = torch.device(
'cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
self.model = model
self.cam_sync = args.cam_sync
def get_lidar(self, idx):
lidar_file = os.path.join(
self.root_split_path, 'velodyne/' + ('%s.bin' % idx))
return torch.from_numpy(np.fromfile(
str(lidar_file), dtype=np.float32).reshape(-1, 6))
def get_image(self, idx, camera):
filename = os.path.join(self.root_split_path,
camera + ('%s.jpg' % idx))
input_image = Image.open(filename)
preprocess = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(
mean=[
0.485, 0.456, 0.406], std=[
0.229, 0.224, 0.225]),
])
input_tensor = preprocess(input_image)
# create a mini-batch as expected by the model
input_batch = input_tensor.unsqueeze(0)
if torch.cuda.is_available():
input_batch = input_batch.to('cuda')
# move the input and model to GPU for speed if available
if torch.cuda.is_available():
input_batch = input_batch.to('cuda')
return input_batch
def get_model_output(self, input_batch):
with torch.no_grad():
output = self.model(input_batch)[0]
return output
def get_score(self, model_output):
sf = torch.nn.Softmax(dim=2)
output_permute = model_output.permute(1, 2, 0)
output_permute = sf(output_permute)
output_reassign = torch.zeros(
output_permute.size(0), output_permute.size(1), 6).to(
device=model_output.device)
output_reassign[:, :, 0] = torch.sum(
output_permute[:, :, :11], dim=2) # background
output_reassign[:, :, 1] = output_permute[:, :, 18] # bicycle
output_reassign[:, :, 2] = torch.sum(
output_permute[:, :, [13, 14, 15, 16]], dim=2) # vehicles
output_reassign[:, :, 3] = output_permute[:, :, 11] # person
output_reassign[:, :, 4] = output_permute[:, :, 12] # rider
output_reassign[:, :, 5] = output_permute[:, :, 17] # motorcycle
return output_reassign
def get_calib_fromfile(self, idx, device):
calib_file = os.path.join(
self.root_split_path, 'calib/' + ('%s.txt' % idx))
calib = get_calib_from_file(calib_file)
calib['P0'] = torch.cat([calib['P0'], torch.tensor(
[[0., 0., 0., 1.]])], axis=0).to(device=device)
calib['P1'] = torch.cat([calib['P1'], torch.tensor(
[[0., 0., 0., 1.]])], axis=0).to(device=device)
calib['P2'] = torch.cat([calib['P2'], torch.tensor(
[[0., 0., 0., 1.]])], axis=0).to(device=device)
calib['P3'] = torch.cat([calib['P3'], torch.tensor(
[[0., 0., 0., 1.]])], axis=0).to(device=device)
calib['P4'] = torch.cat([calib['P4'], torch.tensor(
[[0., 0., 0., 1.]])], axis=0).to(device=device)
calib['R0_rect'] = torch.zeros(
[4, 4], dtype=calib['R0'].dtype, device=device)
calib['R0_rect'][3, 3] = 1.
calib['R0_rect'][:3, :3] = calib['R0'].to(device=device)
calib['Tr_velo_to_cam_0'] = torch.cat([calib['Tr_velo_to_cam_0'], torch.tensor(
[[0., 0., 0., 1.]], )], axis=0).to(device=device)
calib['Tr_velo_to_cam_1'] = torch.cat([calib['Tr_velo_to_cam_1'], torch.tensor(
[[0., 0., 0., 1.]], )], axis=0).to(device=device)
calib['Tr_velo_to_cam_2'] = torch.cat([calib['Tr_velo_to_cam_2'], torch.tensor(
[[0., 0., 0., 1.]], )], axis=0).to(device=device)
calib['Tr_velo_to_cam_3'] = torch.cat([calib['Tr_velo_to_cam_3'], torch.tensor(
[[0., 0., 0., 1.]], )], axis=0).to(device=device)
calib['Tr_velo_to_cam_4'] = torch.cat([calib['Tr_velo_to_cam_4'], torch.tensor(
[[0., 0., 0., 1.]], )], axis=0).to(device=device)
return calib
def cam_to_lidar(self, pointcloud, projection_mats, camera_num):
"""
Takes in lidar in velo coords, returns lidar points in camera coords
:param pointcloud: (n_points, 4) np.array (x,y,z,r) in velodyne coordinates
:return lidar_cam_coords: (n_points, 4) np.array (x,y,z,r) in camera coordinates
"""
lidar_velo_coords = copy.deepcopy(pointcloud)
# copy reflectances column
reflectances = copy.deepcopy(lidar_velo_coords[:, -1])
lidar_velo_coords[:, -1] = 1 # for multiplying with homogeneous matrix
lidar_cam_coords = projection_mats['Tr_velo_to_cam_' +
str(camera_num)].matmul(lidar_velo_coords.transpose(0, 1))
lidar_cam_coords = lidar_cam_coords.transpose(0, 1)
lidar_cam_coords[:, -1] = reflectances
return lidar_cam_coords
def project_points_mask(self, lidar_cam_points,
projection_mats, class_scores, camera_num):
points_projected_on_mask = projection_mats['P' + str(camera_num)].matmul(
projection_mats['R0_rect'].matmul(lidar_cam_points.transpose(0, 1)))
points_projected_on_mask = points_projected_on_mask.transpose(0, 1)
points_projected_on_mask = points_projected_on_mask / \
(points_projected_on_mask[:, 2].reshape(-1, 1))
true_where_x_on_img = (0 < points_projected_on_mask[:, 0]) & (
points_projected_on_mask[:, 0] < class_scores[camera_num].shape[1]) # x in img coords is cols of img
true_where_y_on_img = (0 < points_projected_on_mask[:, 1]) & (
points_projected_on_mask[:, 1] < class_scores[camera_num].shape[0])
true_where_point_on_img = true_where_x_on_img & true_where_y_on_img & (
lidar_cam_points[:, 2] > 0)
# filter out points that don't project to image
points_projected_on_mask = points_projected_on_mask[true_where_point_on_img]
# using floor so you don't end up indexing num_rows+1th row or col
points_projected_on_mask = torch.floor(points_projected_on_mask).int()
# drops homogenous coord 1 from every point, giving (N_pts, 2) int
# array
points_projected_on_mask = points_projected_on_mask[:, :2]
return (points_projected_on_mask, true_where_point_on_img)
def augment_lidar_class_scores_both(
self, class_scores, lidar_raw, projection_mats):
"""
Projects lidar points onto segmentation map, appends class score each point projects onto.
"""
# lidar_cam_coords = self.cam_to_lidar(lidar_raw, projection_mats)
################################
lidar_cam_coords = self.cam_to_lidar(
lidar_raw[:, :4], projection_mats, 0)
lidar_cam_coords[:, -1] = 1 # homogenous coords for projection
points_projected_on_mask_0, true_where_point_on_img_0 = self.project_points_mask(
lidar_cam_coords, projection_mats, class_scores, 0)
lidar_cam_coords = self.cam_to_lidar(
lidar_raw[:, :4], projection_mats, 1)
lidar_cam_coords[:, -1] = 1 # homogenous coords for projection
points_projected_on_mask_1, true_where_point_on_img_1 = self.project_points_mask(
lidar_cam_coords, projection_mats, class_scores, 1)
lidar_cam_coords = self.cam_to_lidar(
lidar_raw[:, :4], projection_mats, 2)
lidar_cam_coords[:, -1] = 1
points_projected_on_mask_2, true_where_point_on_img_2 = self.project_points_mask(
lidar_cam_coords, projection_mats, class_scores, 2)
lidar_cam_coords = self.cam_to_lidar(
lidar_raw[:, :4], projection_mats, 3)
lidar_cam_coords[:, -1] = 1
points_projected_on_mask_3, true_where_point_on_img_3 = self.project_points_mask(
lidar_cam_coords, projection_mats, class_scores, 3)
lidar_cam_coords = self.cam_to_lidar(
lidar_raw[:, :4], projection_mats, 4)
lidar_cam_coords[:, -1] = 1
points_projected_on_mask_4, true_where_point_on_img_4 = self.project_points_mask(
lidar_cam_coords, projection_mats, class_scores, 4)
true_where_point_on_both_0_1 = true_where_point_on_img_0 & true_where_point_on_img_1
true_where_point_on_both_0_2 = true_where_point_on_img_0 & true_where_point_on_img_2
true_where_point_on_both_1_3 = true_where_point_on_img_1 & true_where_point_on_img_3
true_where_point_on_both_2_4 = true_where_point_on_img_2 & true_where_point_on_img_4
true_where_point_on_img = true_where_point_on_img_1 | true_where_point_on_img_0 | true_where_point_on_img_2 | true_where_point_on_img_3 | true_where_point_on_img_4
point_scores_0 = class_scores[0][points_projected_on_mask_0[:, 1],
points_projected_on_mask_0[:, 0]].reshape(-1, class_scores[0].shape[2])
point_scores_1 = class_scores[1][points_projected_on_mask_1[:, 1],
points_projected_on_mask_1[:, 0]].reshape(-1, class_scores[1].shape[2])
point_scores_2 = class_scores[2][points_projected_on_mask_2[:, 1],
points_projected_on_mask_2[:, 0]].reshape(-1, class_scores[2].shape[2])
point_scores_3 = class_scores[3][points_projected_on_mask_3[:, 1],
points_projected_on_mask_3[:, 0]].reshape(-1, class_scores[3].shape[2])
point_scores_4 = class_scores[4][points_projected_on_mask_4[:, 1],
points_projected_on_mask_4[:, 0]].reshape(-1, class_scores[4].shape[2])
augmented_lidar = torch.cat((lidar_raw[:, :5], torch.zeros(
(lidar_raw.shape[0], class_scores[1].shape[2])).to(device=lidar_raw.device)), axis=1)
augmented_lidar[true_where_point_on_img_0, -
class_scores[0].shape[2]:] += point_scores_0
augmented_lidar[true_where_point_on_img_1, -
class_scores[1].shape[2]:] += point_scores_1
augmented_lidar[true_where_point_on_img_2, -
class_scores[2].shape[2]:] += point_scores_2
augmented_lidar[true_where_point_on_img_3, -
class_scores[3].shape[2]:] += point_scores_3
augmented_lidar[true_where_point_on_img_4, -
class_scores[4].shape[2]:] += point_scores_4
augmented_lidar[true_where_point_on_both_0_1, -class_scores[0].shape[2]:] = 0.5 * \
augmented_lidar[true_where_point_on_both_0_1, -
class_scores[0].shape[2]:]
augmented_lidar[true_where_point_on_both_0_2, -class_scores[0].shape[2]:] = 0.5 * \
augmented_lidar[true_where_point_on_both_0_2, -
class_scores[0].shape[2]:]
augmented_lidar[true_where_point_on_both_1_3, -class_scores[1].shape[2]:] = 0.5 * \
augmented_lidar[true_where_point_on_both_1_3, -
class_scores[1].shape[2]:]
augmented_lidar[true_where_point_on_both_2_4, -class_scores[2].shape[2]:] = 0.5 * \
augmented_lidar[true_where_point_on_both_2_4, -
class_scores[2].shape[2]:]
if self.cam_sync:
augmented_lidar = augmented_lidar[true_where_point_on_img]
return augmented_lidar
automotive/3d-object-detection/model/pointpillars.py 0 → 100644
View file @ 3c15726c
This diff is collapsed.
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment