cudf
PSRayTracing
cudf | PSRayTracing | |
---|---|---|
23 | 6 | |
7,291 | 240 | |
1.8% | - | |
9.9 | 7.2 | |
about 8 hours ago | 8 days ago | |
C++ | C | |
Apache License 2.0 | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
cudf
-
A Polars exploration into Kedro
The interesting thing about Polars is that it does not try to be a drop-in replacement to pandas, like Dask, cuDF, or Modin, and instead has its own expressive API. Despite being a young project, it quickly got popular thanks to its easy installation process and its “lightning fast” performance.
-
Why we dropped Docker for Python environments
Perhaps the largest for package size is the NVIDIA developed rapids toolkit https://rapids.ai/ . Even still adding things like pandas and some geospatial tools, you rapidly end up with an image well over a gigabyte, despite following cutting edge best practice with docker and python.
-
Introducing TeaScript C++ Library
Yes sure, that is how OpenMP does; but on the other side: you seem to already do some basic type inference, and building an AST, no? Then you know as well the size and type of your vectors, and can execute actions in parallel if there is enough data to be worth parallelizing. Is there anyone who don't want their code to execute faster if it is possible? Those that do work in big data domain do use threads and vectorized instructions without user having to type in any directive; just import different library. Example, numpy or numpy with cuda backend, or similar GPU accelerated libraries like cudf.
-
[D] Can we use Ray for distributed training on vertex ai ? Can someone provide me examples for the same ? Also which dataframe libraries you guys used for training machine learning models on huge datasets (100 gb+) (because pandas can't handle huge data).
Not the answer about Ray: you could use rapids.ai. I'm using it for for dataframe manipulation on GPU
-
Story of my life
To put Data Analytics on GPU Steroids, Try RAPIDS cudf https://rapids.ai/
-
Artificial Intelligence in Python
You can scope out https://rapids.ai/. Nvidia's AI toolkits. They have some handy notebooks to poke at to get you started.
-
[D] [R] Large-scale clustering
try https://rapids.ai/
-
[P] Looking for state of the art clustering algorithms
As a companion to the other comments, I'd like to mention that the RAPIDS library cuML provides GPU-accelerated versions of quite a few of the algorithms mentioned in this thread (HDBSCAN, UMAP, SVM, PCA, {Exact, Approximate} Nearest Neighbors, DBSCAN, KMeans, etc.).
- Integrating multiple point clouds?
- Buka | Sains Data GPU RAPIDS
PSRayTracing
-
Deploy multi-platform applications with C++ (desktop, mobile and web). An example with Dear ImGui
I wouldn't say that CMake isn't that painful for the deployment stage. I have successfully deployed an open source project on Windows, Mac, Linux, Android, and iOS.
-
Introducing TeaScript C++ Library
It's a very old project and a VERY basic engine. TBH, engines like godot do a much better job, have their own scripting language (to hide away C++), but still let you write some native code if need be. For TeaScript, I'd be more interested in using it to have a more dynamic pipeline for this project, but performance there is absolutely critical since it can mean the difference between 2 minutes an 2 hours.
-
What are the hallmarks of well written and high quality C++ code?
Does it work as a drop-in replacement? I've got this project here where I'm looking to squeeze more perf from: https://github.com/define-private-public/PSRayTracing
-
I made a drop in replacement of `std::shared_ptr` to experiment with performance. It wasn't any faster. Why?
While working on a ray tracing implementation, I was interested in replacing out the usage of std::shared_ptr with something else. I've always been told that shared pointers are slow, and this is due to things such as reference counting. The original implementation of this ray tracer used shared pointers quite extensively in the rendering (hot path) code. I didn't want to deviate from the architecture for my implementaiton . Mostly, the pointers are passed around as const-ref objects.
-
Question about branch prediction for clauses that are either `true` for 100% of the time, or `false` for 100% of the time.
Last year I was working on an implementation of the Ray Tracing in one Weekend book series. I noticed there was a fair amount of sub-optimal code in it, so I took the opportunity to rewrite parts of it to be better optimized. One of the other things I added to the CMake configuration were some compile time flags that could be toggled ON/OFF, as to use either the books code, or my code. e.g. WITH_BOOK_AABB_HIT=True, it would use the books' method AABB-Ray intersection. False, it would use my (faster) one. This allowed anyone else to download the code, toggle the change and easily see the effect it had on performance.
-
Stories of what happened when you forgot to initialize a variable
Here's my implementation: https://github.com/define-private-public/PSRayTracing It's different, mainly in structure (cleaner) and that it's much more performant. It also allows you to either use the code I wrote (typically faster) or the book's methods with the flip of a compiler flag.
What are some alternatives?
Numba - NumPy aware dynamic Python compiler using LLVM
RenderFlow - Visualize fluid simulation result with graphics API
chia-plotter
Heap-Layers - Heap Layers: An Extensible Memory Allocation Infrastructure
wif500 - Try to find the WIF key and get a donation 200 btc
UnityRayTracingPlugin - Native plugin for Unity3d that replaces the renderer with a hardware accelerated ray tracer.
Pytorch - Tensors and Dynamic neural networks in Python with strong GPU acceleration
EA Standard Template Library - EASTL stands for Electronic Arts Standard Template Library. It is an extensive and robust implementation that has an emphasis on high performance.
rmm - RAPIDS Memory Manager
TermGL - 2D & 3D graphics engine in the terminal [C/C++]
CUDA.jl - CUDA programming in Julia.
CppCoreGuidelines - The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++