Jetson Nano: Tolak Ukur Pembelajaran Deep Learning

Jetson Nano dapat menjalankan berbagai jaringan lanjutan, termasuk versi asli lengkap dari kerangka kerja Machine Learning populer seperti TensorFlow, PyTorch, Caffe / Caffe2, Keras, MXNet, dan lainnya. Jaringan ini dapat digunakan untuk membangun mesin otonom dan sistem AI yang kompleks dengan mengimplementasikan kemampuan yang kuat seperti pengenalan gambar, deteksi dan pelokalan objek, estimasi pose, segmentasi semantik, peningkatan video, dan analisis cerdas.

Berikut ini perbandingan Nvidia Jetson Nano

untuk informasi Anda dapat menghubungi kami di ali@epsindo.co.id

ai#nvidia #jetsonnano #nvidiajetson #deeplearning #nvidiajetsonnano #deeplearningmachine #nvidiajetsonnanodeveloperkit #nvidiajakarta #nvidiaindonesia


Nvidia Jetson Nano Developer Kit memberikan kemudahan didalam men-develope Kecerdasan Buatan untuk Image Classification, Object Detection, segmentation, Speech Processing.

NVIDIA Jetson Nano Developer Kit

Sekarang telah tersedia komputer kecil dan kuat yang digunakan untuk Kecerdasan Buatan / AI (Artificial Intelligence) modern, untuk kalangan pembuat, pembelajar, dan pengembang Kecerdasan Buatan.

mengapa harus menggunakan NVIDIA® Jetson Nano ™ Developer Kit, karena NVIDIA® Jetson Nano ™ Developer Kit adalah komputer kecil dan kuat yang memungkinkan Anda menjalankan beberapa jaringan saraf secara paralel untuk aplikasi seperti klasifikasi sebagai berikut:

  • Gambar (image classification)
  • Deteksi objek (object detection)
  • Segmentasi (segmentation)
  • Pemrosesan suara (speech processing)

Semua dalam platform yang mudah digunakan yang beroperasi hanya dalam daya 5 watt, dan tentunya dengan harga yang sangat terjangkau, bagi semua kalangan.

Dengan ukuran yang kecil apakah NVIDIA® Jetson Nano ™ Developer Kit, dapat dengan baik melakukan kinerja seperti klasifikasi diatas, pertanyaan yang sangat menarik dan tentu pertanyaan ini akan banyak dipertanyakan oleh kalangan pembuat, pembelajar, dan pengembang Kecerdasan Buatan.

yuk kita intip spesifikasi NVIDIA® Jetson Nano ™ Developer Kit sebagai berikut:

Apakah sudah kalian Cek spesifikasi dari NVIDIA® Jetson Nano ™ Developer Kit.
untuk ulasan selanjutnya tentang NVIDIA® Jetson Nano ™ Developer Kit, akan kita bahas mengenai platform sdk yang sudah ada didalam NVIDIA® Jetson Nano ™ Developer Kit.

untuk informasi Anda dapat menghubungi kami di ali@epsindo.co.id

ai#nvidia #jetsonnano #nvidiajetson #deeplearning #nvidiajetsonnano #deeplearningmachine #nvidiajetsonnanodeveloperkit #nvidiajakarta #nvidiaindonesia


Build a Hardware-based Face Recognition System for $150 with the Nvidia Jetson Nano and Python

With the Nvidia Jetson Nano, you can build stand-alone hardware systems that run GPU-accelerated deep learning models on a tiny budget. It’s just like a Raspberry Pi, but a lot faster.

 

With the Nvidia Jetson Nano, you can build stand-alone hardware systems that run GPU-accelerated deep learning models on a tiny budget. It’s just like a Raspberry Pi, but a lot faster.

to get you inspired, let’s build a real hardware project with a Jetson Nano. We’ll create a simple version of a doorbell camera that tracks everyone that walks up to the front door of your house. With face recognition, it will instantly know whether the person at your door has ever visited you before — even if they were dressed differently. And if they have visited, it can tell you exactly when and how often.


What is the Nvidia Jetson Nano and how is it different than a Raspberry Pi?

For years, Raspberry Pi has been the easiest way for a software developer to get a taste of building their own hardware devices. The Raspberry Pi is a $35 computer-on-a-board that runs Linux and fully supports Python. And if you plug in a $20 Raspberry Pi camera module, you can use it to build stand-alone computer vision systems. It was a game-changing product that sold over 12 million units in the first five years alone and exposed a new generation of software developers to the world of hardware development.

What is the Nvidia Jetson Nano and how is it different than a Raspberry Pi?

For years, Raspberry Pi has been the easiest way for a software developer to get a taste of building their own hardware devices. The Raspberry Pi is a $35 computer-on-a-board that runs Linux and fully supports Python. And if you plug in a $20 Raspberry Pi camera module, you can use it to build stand-alone computer vision systems. It was a game-changing product that sold over 12 million units in the first five years alone and exposed a new generation of software developers to the world of hardware development.

While the Raspberry Pi is an amazing product, it’s painful to use for deep learning applications. The Raspberry Pi doesn’t have a GPU and its CPU isn’t especially fast at matrix math, so deep learning models usually run very slowly. It just isn’t what the Raspberry Pi was designed to do. Lots of computer vision developers tried to use it anyway but they usually ended up with applications that ran at less than one frame of video a second.

Nvidia noticed this gap in the market and built the Jetson Nano. The Jetson Nano is a Raspberry Pi-style hardware device that has an embedded GPU and is specifically designed to run deep learning models efficiently.

The other really cool part is that the Jetson Nano supports the exact same CUDA libraries for acceleration that almost every Python-based deep learning framework already uses. This means that you can take an existing Python-based deep learning app and often get it running on the Jetson Nano with minimal modifications and still get decent performance. It’s a huge step up from the Raspberry Pi for deep learning projects.

What to Buy

With any hardware project, the first step is to buy all the parts that you’ll need to build the system. Here are the minimal pieces that you’ll need to buy:

1. Nvidia Jetson Nano board

These are currently hard to get and regularly out of stock. Please watch out for scammers and try to buy from an official source to avoid getting scammed. You can often find them in stock direct from Nvidia.

Full disclosure:I got my Jetson Nano board for free from a contact at Nvidia (they were sold out everywhere else) but I have no financial or editorial relationship with Nvidia.

2. MicroUSB power plug

Look for a power adapter that specifically says it supports the Jetson Nano if possible as some USB plugs can’t put out enough power. But an old cell phone charger might work.

3. Raspberry Pi Camera Module v2.x

You can’t use a Raspberry Pi v1.x camera module! The chipset is not supported by the Jetson Nano. It has to be a v2.x camera module to work.

4. A fast microSD card with at least 32GB of space

I got a 128GB card for a few dollars more on Amazon. I recommend going larger so don’t run out of space. If you already have an extra MicroSD card sitting around it, feel free to re-use it.

5. There are also a few other things that you will need but you might already have them sitting around:

  • A microSD card reader for your computer so that you can download and install the Jetson software
  • A wired USB keyboard and a wired USB mouse to control the Jetson Nano
  • Any monitor or TV that accepts HDMI directly (not via an HDMI-to-DVI converter) so you can see what you are doing. You must use a monitor for the initial Jetson Nano setup even if you run without a monitor later.
  • An ethernet cable and somewhere to plug it in. The Jetson Nano bizarrely does not have wifi built-in. You can optionally add a USB wifi adapter, but support is limited to certain models so check before buying one.

Get all that stuff together and you are ready to go! Hopefully, you can get everything for less than $150. The main costs are the Jetson Nano board itself and the camera module.

Of course, you might want to buy or build a case to house the Jetson Nano hardware and hold the camera in place. But that entirely depends on where you want to deploy your system.

Get all that stuff together and you are ready to go! Hopefully, you can get everything for less than $150. The main costs are the Jetson Nano board itself and the camera module.

Of course, you might want to buy or build a case to house the Jetson Nano hardware and hold the camera in place. But that entirely depends on where you want to deploy your system.

Downloading the Jetson Nano Software

Before you start plugging things into the Jetson Nano, you need to download the software image for the Jetson Nano.

Nvidia’s default software image is great! It includes Ubuntu Linux 18.04 with Python 3.6 and OpenCV pre-installed which saves a lot of time.

Here’s how to get the Jetson Nano software onto your SD card:

  1. Download the Jetson Nano Developer Kit SD Card Image from Nvidia.
  2. Download Etcher, the program that writes the Jetson software image to your SD card.
  3. Run Etcher and use it to write the Jetson Nano Developer Kit SD Card Image that you downloaded to your SD card. This takes about 20 minutes or so.

At this point, you have an SD card loaded with the default Jetson Nano software. Time to unbox the rest of the hardware!

Plugging Everything In

First, take your Jetson Nano out of the box:

All that is inside is a Jetson Nano board and a little paper tray that you can use to prop up the board. There’s no manual or cords or anything else inside.

for more information click image below

Written by

Adam Geitgey

View at Medium.com

Zero to Data Science: Making Data Science Teams Productive with Kubernetes and RAPIDS

 

Data collected on a vast scale has fundamentally changed the way organizations do business, driving demand for teams to provide meaningful data science, machine learning, and deep learning-based business insights quickly. Data science leaders, plus the Dev Ops and IT teams supporting them, constantly look for ways to make their teams productive while optimizing their costs and minimizing deployment time.

NVIDIA and our partners have engaged with thousands of organizations across stages of data science maturity. These engagements reveal a common set of ingredients for success in data science:

  • Jupyter notebook/JupyterLab – the de facto interface(s) for data science
  • A set of data science tools that accelerate the time to meaningful results
  • Shared hardware resources to optimize hardware utilization but also allow users to flex on-demand
  • Access from any device (and ideally anywhere) – Laptop or Desktop, PC or workstation, Windows, MacOS or Linux and in the office or at the coffee shop (creativity happens anywhere!)

The DS Cluster – A Multi-Tenant Data Science Workstation

The NVIDIA solutions architect team evaluated many options to bring our customers’ vision to fruition.

NVIDIA-powered data science clusters (DS clusters) enable teams of data scientists with Jupyter Notebooks containing everything they need to tackle complex data science problems from anywhere. These clusters combine the world’s most advanced NVIDIA® GPUs with a tested data science software container available from NVIDIA.

Users simply need an internet browser and a network connection to the cluster. This gives them access to one or more GPUs via a Jupyter notebook loaded with the top data science libraries, putting a remote data science workstation from any device at their fingertips.

Leveraging Kubernetes enables administrators to make available shared resources dedicating resources to a particular user. Administrators pool these resources and make them available on-demand as users request them. This ensures efficient, effective use of compute resources. Since this is a cluster and not a dedicated system, users also have the ability to scale and request more resources than normally available with a fixed resource. A Kubernetes base opens the door to easily add additional service layers over time as a secondary benefit. Expect to hear more in future posts.

The NVIDIA RAPIDS suite of open source data science software libraries, built on CUDA-X AI, gives you the freedom to execute end-to-end data science and analytics pipelines entirely on GPUs, accelerating the time to results.

Deployment

Deploying the DS cluster requires knowledge of Linux and Ansible. However, much of the difficult work has been built into scripts that are part of the DeepOps toolkit. Expect the process to take half- to a full-day after procuring, racking, and networking hardware.

Step 1 – Hardware

The stars of the DS cluster are three NGC-Ready servers, as shown in figure 1. These systems have undergone a rigorous validation program to ensure they meet the performance requirements of NGC containers. With 4 NVIDIA T4 GPUs in each NGC-Ready server, up-to 12 data scientists can be simultaneously supported.

Figure 1. DS cluster hardware

These systems will be the compute nodes in the cluster, sometimes called worker nodes. In this architecture, they also act as the Kubernetes management/master nodes. While double-duty isn’t standard for all environments, this lowers the bar to entry and is an ideal starting point. As teams grow and high availability becomes important, the master services are generally moved to dedicated hardware.

Next, you’ll require a top-of-rack (TOR) switch to connect the systems to each other and to the external network. Since NGC-Ready systems have two NICs and one management interface, the TOR needs a minimum of nine ports. An existing TOR can be used but separation is beneficial from an administration perspective. Regardless, ensure that the TOR you use supports the desired NIC speed.

Finally, you’ll need a system to act as the control node. This system can be a relatively spartan x86 CPU-only system with a single CPU, 32GB RAM, one NIC, and an SSD.

Systems should be racked and networked to ensure they are on the same VLAN/subnet.

Step 2 – Provisioning/control node

You must first install Ubuntu 18.04 on the control node. Be sure to enable SSH and record the user and password used during install. After that’s done, download the DeepOps git repo and run:

./scripts/setup.sh

This installs Ansible and other dependencies.

Lastly, install Maas.io. This will be used to deploy operating systems to the NGC-Ready Systems.

Step 3 – Operating systems

Use Maas.io to deploy Ubuntu 18.04 (NGC-Ready Compatible) on each of the NGC-Ready systems.

Step 4 – Kubernetes and NGC-Ready System Setup

First, create an Ansible inventory where each of the NGC-Ready systems act as both a master/management node and a compute/worker node.

Second, run the following command:

ansible-playbook -l k8s-cluster playbooks/k8s-cluster.yml.

This playbook accomplishes two things: first, it installs the rest of the latest NGC-Ready system setup on each system, ensuring that they are compatible with and optimized for NGC containers and second, it deploys Kubernetes across the NGC-Ready systems via Kubespray. Some additional parameters may be required based on security policies. See the full DeepOps Kubernetes deployment guide for details.

Step 5 – Services

To provide persistent storage, deploy Rook using:

./scripts/k8s_deploy_rook.sh

This provides persistent storage.

Deploy Kubeflow using:

./scripts/k8s_deploy_kubeflow.sh

This provides a convenient GUI for users to launch Jupyter notebooks, execute pipelines, and leverage other data science tools that we’ll explore in future blogs.

Note that Kubeflow requires containers to be configured with a launch command to work properly. This has already been implemented in the DeepOps deployment script for Kubeflow, allowing any NGC container to be compatible.

User experience

As noted earlier, the user experience starts with any internet browser and a network connection to the DS cluster.

After browsing to the Kubeflow notebook URL, users see an interface to create their notebook, shown in figure 2. They enter a name for their notebook, the resources required, including the number of GPUs they need in the extra resources section ({“nvidia.com/gpu”: 1}), and the RAPIDS image (nvcr.io/nvidia/rapidsai/rapidsai:cuda9.2-runtime-ubuntu16.04 for the latest version tested for this post). Finally, they’ll update the custom command to use bin/bash and:

[“-c”,”source activate gdf && jupyter notebook –notebook-dir=/home/jovyan –ip=0.0.0.0 –no-browser –allow-root –port=8888 –NotebookApp.token=” –NotebookApp.password=” –NotebookApp.allow_origin=’*’ –NotebookApp.base_url=${NB_PREFIX}”]

(This is an update to the default command specifically for the NVIDIA RAPIDS container.)

Figure 2. Kubeflow Jupyter Notebook Setup Interface

After a few seconds, the notebook shows up in the list of available notebooks. The user clicks connect, which then connects them to their Jupyter notebook with the RAPIDS libraries loaded, as shown in figure 3.

Figure 3. Jupyter Notebook

Next steps

Whether you’re an enterprise, small business, start-up or educational institution, the DS cluster is a great way to get started with your data science infrastructure. To learn more, please subscribe to our data science newsletter.

We’re also showing the DS cluster in our booth at HPE Discover. Drop by booth #232 to see a DS cluster in action and to learn more about how NVIDIA can help you get one running in your environment.

RAPIDS Accelerates Data Science End-to-End

RAPIDS Accelerates Data Science End-to-End

Today’s data science problems demand a dramatic increase in the scale of data as well as the computational power required to process it. Unfortunately, the end of Moore’s law means that handling large data sizes in today’s data science ecosystem requires scaling out to many CPU nodes, which brings its own problems of communication bottlenecks, energy, and cost (see figure 1).

Figure 1. GPU-powered data science enables much greater interactivity, but affords fewer coffee breaks.

A key part of data science is data exploration. To prepare a dataset for training a machine learning algorithm requires understanding the dataset, cleaning and manipulating data types and formats, filling in gaps in the data, and engineering features for the learning algorithm. These tasks are often grouped under the term Extract, Transform, Load (ETL). ETL is often an iterative, exploratory process. As datasets grow, the interactivity of this process suffers when running on CPUs.

To address the challenges of the modern data science pipeline, today at GTC Europe NVIDIA announced RAPIDS, a suite of open-source software libraries for executing end-to-end data science and analytics pipelines entirely on GPUs. RAPIDS aims to accelerate the entire data science pipeline including data loading, ETL, model training, and inference. This will enable more productive, interactive, and exploratory workflows.

RAPIDS is the result of contributions from the machine learning community and GPU Open Analytics Initiative (GOAI) partners. Established in 2017 with the goal of accelerating end-to-end analytics and data science pipelines on GPUs, GOAI created  the GPU DataFrame based on Apache Arrow data structures. The GPU DataFrame enabled the integration of GPU-accelerated data processing and machine learning libraries without incurring typical serialization and deserialization penalties. RAPIDS builds on and extends the earlier GOAI work.

Boosting Data Science Performance with RAPIDS

RAPIDS achieves speedup factors of 50x or more on typical end-to-end data science workflows. RAPIDS uses NVIDIA CUDA for high-performance GPU execution, exposing that GPU parallelism and high memory bandwidth through user-friendly Python interfaces. RAPIDS focuses on common data preparation tasks for analytics and data science, offering a powerful and familiar DataFrame API. This API integrates with a variety of machine learning algorithms without paying typical serialization costs, enabling acceleration for end-to-end pipelines. RAPIDS also includes support for multi-node, multi-GPU deployments, enabling scaling up and out on much larger dataset sizes.

The RAPIDS container includes a notebook and code that demonstrates a typical end-to-end ETL and ML workflow. The example trains a model to perform home loan risk assessment using all of the loan data for the years 2000 to 2016 in the Fannie Mae loan performance dataset, consisting of roughly 400GB of data in memory. Figure 2 shows a geographical visualization of the loan risk analysis.

Figure 2. Visualization of mortgage data risk assessment

The example loads the data into GPU memory using the RAPIDS CSV reader. The ETL in this example performs a number of operations including extracting months and years from datetime fields, joins of multiple columns between DataFrames, and groupby aggregations for feature engineering. The resulting feature data is then converted and used to train a gradient boosted decision tree model on the GPU using XGBoost.

This workflow runs end-to-end on a single NVIDIA DGX-2 server with 16x Tesla V100 GPUs, 10x faster than 100 AWS r4.2xLarge instances, as the chart in figure 3 shows. Comparing GPU to CPU performance one-to-one, this equates to well over a 50x speedup .

Figure 3. RAPIDS on NVIDIA DGX-2 provides over 50x speedups compared to CPU clusters on a typical data science workflow.

The Need for End-to-End Acceleration

GPU acceleration of classical machine learning algorithms, such as gradient boosting, has already become popular. However, previous efforts at GPU-accelerating data science pipelines have focused on individual machine learning libraries and not other crucial interconnecting pieces of the pipeline. This creates a problem. Let’s say your pipeline has three steps:

  1. Load data
  2. Clean up the data and perform feature engineering
  3. Train a classifier

First you load the data into host memory. Then perform ETL tasks including data clean-up and feature engineering steps such as filtering, imputation, and generating new features. These steps today are largely done using the CPU. After that you must convert the output of the feature engineering step into the internal memory format of the GPU-accelerated machine learning library and then move the data to GPU memory. Now, you run training. You get a huge speedup on the training step, and you’re happy. Finally, you move the data back to host memory and visualize or prepare for deployment.

At the end you get a modest overall speedup, but the copy and convert operations introduce significant overhead due to serialization and deserialization operations and you end up underutilizing the available GPU processing power.

RAPIDS addresses this issue by design. It provides a columnar data structure called a GPU DataFrame, which implements the Apache Arrow columnar data format on the GPU. The RAPIDS GPU DataFrame provides a pandas-like API that will be familiar to data scientists, so they can now build GPU-accelerated workflows more easily.

RAPIDS Software Libraries

Data Scientists using RAPIDS interact with it using the following high-level python packages.

  • cuDF: A GPU DataFrame library with a pandas-like API. cuDF provides operations on data columns including unary and binary operations, filters, joins, and groupbys. cuDF currently comprises the Python library PyGDF, and the C++/CUDA GPU DataFrames implementation in libgdf. These two libraries are being merged into cuDF. See the documentation for more details and examples.
  • cuSKL: A collection of machine learning algorithms that operate on GPU DataFrames. cuSKL enables data scientists, researchers, and software engineers to run traditional ML tasks on GPUs without going into the details of CUDA programming from Python.
  • XGBoost: XGBoost is one of the most popular machine learning packages for training gradient boosted decision trees. Native cuDF support allows you to  pass data directly to XGBoost while remaining in GPU memory.

cuSKL is a library in cuML to make the following lower-level libraries more accessible for Python developers. More information about these libraries is available in the documentation. Figure 4 highlights the overall structure and flow of the pipeline using RAPIDS.

  • cuML: a GPU-accelerated library of machine learning algorithms including Singular Value Decomposition (SVD), Principal Component Analysis (PCA), Density-based Spatial Clustering of Applications with Noise (DBSCAN).
  • ml-prims: A library of low-level math and computational primitives used by cuML.

Figure 4. Data science pipeline with GPUs and RAPIDS

Getting RAPIDS

RAPIDS source code is available on GitHub, and a container is available on NVIDIA GPU Cloud (NGC) and Docker Hub. Let’s quickly walk through getting the container and running it and accessing the mortgage risk analysis workflow notebook.

A complete, ready-to-run docker container image is available on the RAPIDS Docker Hub container registry, making it easy to get started with RAPIDS. Pull the latest RAPIDS container image by running the following command:

$ docker pull nvcr.io/nvidia/rapidsai/rapidsai:latest

You can verify that you have the image with the docker images command:

$ docker images | grep rapids

rapids/rapidsai latest  4b30dcd9849c 2 days ago  8.51GB

Run the RAPIDS container

The container can either automatically launch a jupyter notebook or you can start the container in terminal mode by adding bash at the end of the docker command. Let’s launch the notebook.

$ docker run –runtime=nvidia \

–rm -it \

-p 8888:8888 \

-p 8787:8787 \

-p 8786:8786 \

nvcr.io/nvidia/rapidsai/rapidsai:latest

You will see a bash terminal prompt, where you can activate the conda environment with the following command:

root@0038283a49ef:/# cd rapids && source activate gdf

(gdf) root@0038283a49ef:/rapids#

After running it, note the prompt has (gdf) prepended to indicate the activated conda environment. Next, you need to decompress the provided data with <code>tar -xzvf data/mortgat/tar.gz which results in the following:

(gdf) root@0038283a49ef:/rapids# tar -xzvf data/mortgage.tar.gz

mortgage/

mortgage/acq/

mortgage/acq/Acquisition_2000Q1.txt

mortgage/acq/Acquisition_2001Q4.txt

mortgage/acq/Acquisition_2001Q2.txt

mortgage/acq/Acquisition_2000Q4.txt

mortgage/acq/Acquisition_2000Q3.txt

mortgage/acq/Acquisition_2000Q2.txt

mortgage/acq/Acquisition_2001Q1.txt

mortgage/acq/Acquisition_2001Q3.txt

mortgage/perf/

mortgage/perf/Performance_2001Q2.txt_0

mortgage/perf/Performance_2001Q4.txt_0

mortgage/perf/Performance_2001Q4.txt_1

mortgage/perf/Performance_2001Q3.txt_1”

mortgage/perf/Performance_2000Q1.txt

mortgage/perf/Performance_2001Q1.txt

mortgage/perf/Performance_2000Q4.txt

mortgage/perf/Performance_2000Q3.txt

mortgage/perf/Performance_2000Q2.txt

mortgage/perf/Performance_2001Q3.txt_0

mortgage/perf/Performance_2001Q2.txt_1

mortgage/names.csv

Now you can start the Jupyter notebook server, which you can access from the following URL in your browser: {IPADDR}:8888 (e.g.) 12.34.567.89:8888, where IPADDR is the address of the machine running Docker. Where it says “password or token”, enter “rapids”. You will find a couple of example notebooks in the notebook folder that will run end-to-end ETL and machine learning on the provided data. Figure 5 shows the ETL notebook running. From here you can run and edit the cells in the notebook (Shift+Enter) and see the output of running them.

Figure 5: The RAPIDS Docker container contains example Python notebooks including this mortgage risk ETL notebook that runs on multiple GPUs using Dask.

We’ll walk through the details of the example in detail in a future post to demonstrate the Python APIs and RAPIDS capabilities.

Note that you are free to modify the above to experiment with your own data. For example, you can launch an interactive session with your own data mapped into the container:

docker run –runtime=nvidia \

–rm -it \

-p 8888:8888 \

-p 8787:8787 \

-v /path/to/host/data:/rapids/my_data

nvcr.io/nvidia/rapidsai/rapidsai:latest

This will map data from your host operating system to the container OS in the /rapids/my_data directory. You may need to modify the provided notebooks for the new data paths.
You can get interactive documentation on Python functions in the notebook using the ? prefix on the function name, such as ?pygdf.read_csv. This will print the documentation string for PyGDF’s read_csv function. Check out the RAPIDS documentation for more detailed information, and see the NVIDIA GPU Cloud container registry for more instructions on using the container.

Conclusion

RAPIDS accelerates the complete data science pipeline from data ingestion and manipulation to machine learning training. It does this by:

  1. Adopting the GPU DataFrame as the common data format across all GPU-accelerated libraries
  2. Accelerating data science building blocks such as data manipulation routines offered by pandas, and machine learning algorithms such as XGboost by processing data and retaining the results in the GPU memory.

RAPIDS is now available as a container image on NVIDIA GPU Cloud (NGC) and Docker Hub for use on-premises or on public cloud services such as AWS, Azure, and GCP. The RAPIDS source code is also available on GitHub. Visit the RAPIDS site for more information. If you have questions, comments or feedback please use the comments section below.

By Shashank Prasanna and Mark Harris

#https://devblogs.nvidia.com/gpu-accelerated-analytics-rapids/