MyGit

NVIDIA/warp

Fork: 171 Star: 3016 (更新于 2024-06-18 20:31:08)

license: NOASSERTION

Language: Python .

A Python framework for high performance GPU simulation and graphics

最后发布版本: v1.2.1 ( 2024-06-15 05:16:32)

官方网址 GitHub网址

PyPI version GitHub commit activity Downloads codecov GitHub - Build and Test Discord

NVIDIA Warp

Warp is a Python framework for writing high-performance simulation and graphics code. Warp takes regular Python functions and JIT compiles them to efficient kernel code that can run on the CPU or GPU.

Warp is designed for spatial computing and comes with a rich set of primitives that make it easy to write programs for physics simulation, perception, robotics, and geometry processing. In addition, Warp kernels are differentiable and can be used as part of machine-learning pipelines with frameworks such as PyTorch and JAX.

Please refer to the project Documentation for API and language reference and CHANGELOG.md for release history.

A selection of physical simulations computed with Warp

Installing

Python version 3.9 or newer is recommended. Warp can run on x86-64 and ARMv8 CPUs on Windows, Linux, and macOS. GPU support requires a CUDA-capable NVIDIA GPU and driver (minimum GeForce GTX 9xx).

The easiest way to install Warp is from PyPI:

pip install warp-lang

You can also use pip install warp-lang[extras] to install additional dependencies for running examples and USD-related features.

The binaries hosted on PyPI are currently built with the CUDA 11.8 runtime. We provide binaries built with the CUDA 12.5 runtime on the GitHub Releases page. Copy the URL of the appropriate wheel file (warp-lang-{ver}+cu12-py3-none-{platform}.whl) and pass it to the pip install command, e.g.

pip install https://github.com/NVIDIA/warp/releases/download/v1.2.0/warp_lang-1.2.0+cu12-py3-none-manylinux2014_x86_64.whl

The --force-reinstall option may need to be used to overwrite a previous installation.

Getting Started

An example first program that computes the lengths of random 3D vectors is given below:

import warp as wp
import numpy as np

num_points = 1024

@wp.kernel
def length(points: wp.array(dtype=wp.vec3),
           lengths: wp.array(dtype=float)):

    # thread index
    tid = wp.tid()
    
    # compute distance of each point from origin
    lengths[tid] = wp.length(points[tid])


# allocate an array of 3d points
points = wp.array(np.random.rand(num_points, 3), dtype=wp.vec3)
lengths = wp.zeros(num_points, dtype=float)

# launch kernel
wp.launch(kernel=length,
          dim=len(points),
          inputs=[points, lengths])

print(lengths)

Running Examples

The warp/examples directory contains a number of scripts categorized under different subdirectories that show how to implement different simulation methods using the Warp API. Most examples will generate USD files containing time-sampled animations (stored in the current working directory). Before running examples, users should ensure that the usd-core, matplotlib, and pyglet packages are installed using:

pip install usd-core matplotlib pyglet

Examples can be run from the command-line as follows:

python -m warp.examples.<example_subdir>.<example>

To browse the example source code, you can open the directory where the files are located like this:

python -m warp.examples.browse

Most examples can be run on either the CPU or a CUDA-capable device, but a handful require a CUDA-capable device. These are marked at the top of the example script.

USD files can be viewed or rendered inside NVIDIA Omniverse, Pixar's UsdView, and Blender. Note that Preview in macOS is not recommended as it has limited support for time-sampled animations.

Built-in unit tests can be run from the command-line as follows:

python -m warp.tests

examples/core

dem fluid graph capture marching cubes
mesh nvdb raycast raymarch
sph torch wave

examples/fem

apic fluid convection diffusion diffusion 3d diffusion
mixed elasticity navier stokes stokes transfer stokes

examples/optim

bounce cloth throw diffray drone
inverse kinematics spring cage trajectory walker

examples/sim

cartpole cloth granular granular collision sdf
jacobian ik quadruped rigid chain rigid contact
rigid force rigid gyroscopic rigid soft contact soft body

Building

For developers who want to build the library themselves, the following tools are required:

  • Microsoft Visual Studio 2019 upwards (Windows)
  • GCC 9.4 upwards (Linux)
  • CUDA Toolkit 11.5 or higher
  • Git LFS installed

After cloning the repository, users should run:

python build_lib.py

This will generate the warp.dll / warp.so core library respectively. It will search for the CUDA Toolkit in the default install directory. This path can be overridden by setting the CUDA_PATH environment variable. Alternatively, the path to the CUDA Toolkit can be passed to the build command as --cuda_path="...". After building, the Warp package should be installed using:

pip install -e .

This ensures that subsequent modifications to the library will be reflected in the Python package.

Learn More

Please see the following resources for additional background on Warp:

The underlying technology in Warp has been used in a number of research projects at NVIDIA including the following publications:

  • Accelerated Policy Learning with Parallel Differentiable Simulation - Xu, J., Makoviychuk, V., Narang, Y., Ramos, F., Matusik, W., Garg, A., & Macklin, M. (2022)
  • DiSECt: Differentiable Simulator for Robotic Cutting - Heiden, E., Macklin, M., Narang, Y., Fox, D., Garg, A., & Ramos, F (2021)
  • gradSim: Differentiable Simulation for System Identification and Visuomotor Control - Murthy, J. Krishna, Miles Macklin, Florian Golemo, Vikram Voleti, Linda Petrini, Martin Weiss, Breandan Considine et al. (2021)

Frequently Asked Questions

See the FAQ in the Warp documentation.

Support

Problems, questions, and feature requests can be opened on GitHub Issues.

The Warp team also monitors the #warp channel on the public Omniverse Discord server, come chat to us!

Versioning

Versions take the format X.Y.Z, similar to Python itself:

  • Increments in X are reserved for major reworks of the project causing disruptive incompatibility (or reaching the 1.0 milestone).
  • Increments in Y are for regular releases with a new set of features.
  • Increments in Z are for bug fixes. In principle there are no new features. Can be omitted if 0 or not relevant.

This is similar to Semantic Versioning but less strict around backward compatibility. Like with Python, some breaking changes can be present between minor versions if well documented and gradually introduced.

Note that prior to 0.11.0 this schema was not strictly adhered to.

License

Warp is provided under the NVIDIA Software License, please see LICENSE.md for full license text.

Contributing

Contributions and pull requests from the community are welcome and are taken under the terms described in the 9. Feedback section of the license. CONTRIBUTING.md provides additional information on how to open a pull request for Warp.

Citing

If you use Warp in your research please use the following citation:

@misc{warp2022,
title= {Warp: A High-performance Python Framework for GPU Simulation and Graphics},
author = {Miles Macklin},
month = {March},
year = {2022},
note= {NVIDIA GPU Technology Conference (GTC)},
howpublished = {\url{https://github.com/nvidia/warp}}
}

最近版本更新:(数据更新于 2024-06-18 20:31:09)

2024-06-15 05:16:32 v1.2.1

2024-06-07 11:53:01 v1.2.0

2024-05-08 23:54:50 v1.1.0

2024-03-23 04:42:05 v1.0.2

2024-03-16 01:32:50 v1.0.1

2024-03-08 09:58:06 v1.0.0

2024-03-06 10:49:18 v0.15.1

2024-03-05 13:06:57 v0.15.0

2024-02-17 07:42:10 v0.13.0

2024-01-24 05:39:30 v0.11.0

NVIDIA/warp同语言 Python最近更新仓库

2024-07-21 02:15:32 ultralytics/ultralytics

2024-07-20 08:04:16 marimo-team/marimo

2024-07-20 06:03:39 mem0ai/mem0

2024-07-20 03:13:54 OpenDevin/OpenDevin

2024-07-20 01:38:59 home-assistant/core

2024-07-19 19:26:44 xorbitsai/inference