• Stars
    star
    362
  • Rank 117,671 (Top 3 %)
  • Language
  • License
    MIT License
  • Created over 4 years ago
  • Updated 6 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Vitis-AIâ„¢ Tutorials

See Vitisâ„¢ Development Environment on xilinx.com
See Vitis-AIâ„¢ Development Environment on xilinx.com

Tutorial Name

Latest Supported Vitis AI Version

Description

Running ResNet18 CNN Through Vitis AI 3.0 Flow for ML 3.0 In this Deep Learning (DL) tutorial, you will take a public domain CNN like ResNet18, already trained on the ImageNet dataset, and run it through the Vitis AI 3.0 stack to run ML inference on FPGA devices. You will use Keras on Tensorflow 2.x.
ResNet18 in PyTorch from Vitis AI Library 3.0 In this Deep Learning (DL) tutorial, you will take the ResNet18 CNN, from the Vitis AI 3.0 Library, and use it to classify the different colors of the "car object" inside images by running the inference application on FPGA devices.
Deep Learning with Custom GoogleNet and ResNet in Keras and Xilinx Vitis AI 3.0 Quantize in fixed point some custom CNNs and deploy them on the Xilinx ZCU102 board, using Keras and the Xilinx7Vitis AI tool chain based on TensorFlow (TF).
Partitioning Vitis AI SubGraphs on CPU/DPU 3.0 Learn how to deploy a CNN on the Xilinx VCK190 board using Vitis AI.
FCN8 and UNET Semantic Segmentation with Keras and Xilinx Vitis AI 3.0 Train the FCN8 and UNET Convolutional Neural Networks (CNNs) for Semantic Segmentation in Keras adopting a small custom dataset, quantize the floating point weights files to an 8-bit fixed point representation, and then deploy them on the Xilinx ZCU102 board using Vitis AI.
Pre- and Post-processing Accelerators for Semantic Segmentation with Unet CNN on MPSoC DPU 3.0 A complete example of how using the WAA flow targeting the MPSoC ZCU102 board.
Using the Kaggle ImageNet Subset for Training Neural Networks 2.5 Demonstrates how to use the Kaggle ImageNet Subset for training neural networks for developers and enthusiasts with a non-edu domain who are unable to obtain the ImageNet dataset directly.
RF Modulation Recognition with Vitis AI 2.5 Discusses using Deep Neural Networks to perform automatic modulation recognition so that the receiver may be able to detect and demodulate the signal without this explicit knowledge of the modulation type and encoding method.
Leveraging the Vitis™ AI DPU in the Vivado® Workflow 2.0 Build the Vitis AI Targeted Reference Design (TRD) using the Vivado flow and learn how to build a PetaLinux image from the ZCU102 BSP that is provided in the TRD archive.
Quantization and Pruning of AlexNet CNN trained in Caffe with Cats-vs-Dogs dataset 2.0 Train, prune, and quantize a modified version of the AlexNet convolutional neural network (CNN) with the Kaggle Dogs vs. Cats dataset in order to deploy it on the Xilinx® ZCU102 board.
Vitis AI on VCK5000 Card 2.0 Start from card installation and go through a step-by-step workflow to run the first Vitis AI sample on a VCK5000 card.
VCK190 Custom Lambda Operator 2.0 The general concept behind the custom operator flow is to make Vitis AI and the DPU more extensible—both for supporting custom layers as well as framework layers that are currently unsupported in the toolchain. The custom operator flow enables you to define layers which are unsupported, and ultimately deploy those layers either on the CPU or an accelerator.
LIDAR + Camera Fusion on KV260 2.0 Shows you how to install Ubuntu on the KV260 then build ROS, bring in multiple sensors, and deploy FPGA-accelerated neural network to process the data before displaying the data using RViz. All of this is possible without ever using FPGA tools!
Introduction to Vitis AI 1.4 This tutorial puts in practice the concepts of FPGA acceleration of Machine Learning and illustrates how to
quickly get started deploying both pre-optimized and customized ML models on Xilinx devices.
MNIST Classification using Vitis AI and TensorFlow 1.4 Learn the Vitis AI TensorFlow design process for creating a compiled ELF file that is ready for deployment on the Xilinx DPU accelerator from a simple network model built using Python. This tutorial uses the MNIST test dataset.
Using DenseNetX on the Xilinx DPU Accelerator 1.4 Learn about the Vitis AI TensorFlow design process and how to go from a Python description of the network model to running a compiled model on the Xilinx DPU accelerator.
Using DenseNetX on the Xilinx Alveo U50 Accelerator Card 1.3 Implement a convolutional neural network (CNN) and run it on the DPUv3E accelerator IP.
Vitis AI YOLOv4 1.4 Learn how to train, evaluate, convert, quantize, compile, and deploy YOLOv4 on Xilinx devices using Vitis AI.
TensorFlow2 and Vitis AI design flow 1.4 Learn about the TF2 flow for Vitis AI. In this tutorial, you'll be trained on TF2, including conversion of a dataset into TFRecords, optimization with a plug-in, and compiling and execution on a Xilinx ZCU102 board or Xilinx Alveo U50 Data Center Accelerator card.
PyTorch flow for Vitis AI 1.4 Introduces the Vitis AI TensorFlow design process and illustrates how to go from a python description of the network model to running a compiled model on a Xilinx evaluation board.
RF Modulation Recognition with TensorFlow 2 1.4 Machine learning applications are certainly not limited to image processing! Learn how to apply machine learning with Vitis AI to the recognition of RF modulation from signal data.
Denoising Variational Autoencoder with TensorFlow2 and Vitis-AI 1.4 The Xilinx DPU can accelerate the execution of many different types of operations and layers that are commonly found in convolutional neural networks but occasionally we need to execute models that have fully custom layers. One such layer is the sampling function of a convolutional variational autoencoder. The DPU can accelerate the convolutional encoder and decoder but not the statistical sampling layer - this must be executed in software on a CPU. This tutorial will use the variational autoencoder as an example of how to approach this situation.
Alveo U250 TF2 Classification 1.4 Demonstrates image classification using the Alveo U250 card with Vitis AI 1.4 and the Tensorflow 2.x framework.
Pre- and Post-processing PL Accelerators for ML with Versal DPU 1.4 A complete example of how using the WAA flow with Vitis 2020.2 targeting the VCK190 PP board.
Caffe SSD 1.4 The topics covered in this tutorial include training, quantizing, and compiling SSD using PASCAL VOC 2007/2012 datasets, the Caffe framework, and Vitis AI tools. The model is then deployed on a Xilinx® ZCU102 target board and could also be deployed on other Xilinx development board targets (For example, Kria Starter Kit, ZCU104, and VCK190).
ML Caffe Segmentation 1.4 Describes how to train, quantize, compile, and deploy various segmentation networks using Vitis AI, including ENet, ESPNet, FPN, UNet, and a reduced compute version of UNet that we'll call Unet-lite. The training dataset used for this tutorial is the Cityscapes dataset, and the Caffe framework is used for training the models.
Introduction Tutorial to the Vitis AI Profiler 1.4 Introduces the the Vitis AI Profiler tool flow and will illustrates how to profile an example from the Vitis AI runtime (VART).
PyTorch CityScapes Pruning 1.4 The following is a tutorial for using the Vitis AI Optimizer to prune the Vitis AI Model Zoo FPN Resnet18 segmentation model and a publicly available UNet model against a reduced class version of the Cityscapes dataset. The tutorial aims to provide a starting point and demonstration of the PyTorch pruning capabilities for the segmentation models.
Fine-Tuning TensorFlow2 quantized model 1.4 Learn how to implement the Vitis-AI quantization fine-tuning for TensorFlow2.3.
Vitis AI based Deployment Flow on VCK190 1.4 DPU integration with VCK190 production platform.
TensorFlow AI Optimizer Example Using Low-level Coding Style 1.4 Use AI Optimizer for TensorFlow to prune an AlexNet CNN by 80% while maintaining the original accuracy.
Freezing a Keras Model for use with Vitis AI (UG1380) 1.3 Freeze a Keras model by generating a binary protobuf (.pb) file.
Profiling a CNN Using DNNDK or VART with Vitis AI (UG1487) 1.3 Profile a CNN application running on the ZCU102 target board with Vitis AI.
Moving Seamlessly between Edge and Cloud with Vitis AI (UG1488) 1.3 Compile and run the same identical design and application code on either the Alveo U50 data center accelerator card or the Zynq UltraScale+â„¢ MPSoC ZCU102 evaluation board.

Copyright© 2022 Xilinx

More Repositories

1

PYNQ

Python Productivity for ZYNQ
Jupyter Notebook
1,975
star
2

Vitis-AI

Vitis AI is Xilinx’s development stack for AI inference on Xilinx hardware platforms, including both edge devices and Alveo cards.
Python
1,475
star
3

linux-xlnx

The official Linux kernel from Xilinx
C
1,205
star
4

brevitas

Brevitas: neural network quantization in PyTorch
Python
1,158
star
5

Vitis-Tutorials

Vitis In-Depth Tutorials
C
891
star
6

Vitis_Libraries

Vitis Libraries
C++
853
star
7

embeddedsw

Xilinx Embedded Software (embeddedsw) Development
HTML
766
star
8

finn

Dataflow compiler for QNN inference on FPGAs
Python
715
star
9

BNN-PYNQ

Quantized Neural Networks (QNNs) on PYNQ
Jupyter Notebook
661
star
10

XRT

Run Time for AIE and FPGA based platforms
C++
553
star
11

u-boot-xlnx

The official Xilinx u-boot repository
C
531
star
12

Vitis_Accel_Examples

Vitis_Accel_Examples
Makefile
503
star
13

Vitis-HLS-Introductory-Examples

C++
420
star
14

dma_ip_drivers

Xilinx QDMA IP Drivers
C
400
star
15

HLS

Vitis HLS LLVM source code and examples
378
star
16

PYNQ_Workshop

Jupyter Notebook
354
star
17

SDAccel_Examples

SDAccel Examples
C++
350
star
18

ml-suite

Getting Started with Xilinx ML Suite
Jupyter Notebook
334
star
19

CHaiDNN

HLS based Deep Neural Network Accelerator Library for Xilinx Ultrascale+ MPSoCs
C++
322
star
20

xfopencv

C++
313
star
21

XilinxTclStore

Xilinx Tcl Store
Tcl
310
star
22

mlir-aie

An MLIR-based toolchain for AMD AI Engine-enabled devices.
MLIR
300
star
23

XilinxBoardStore

Python
251
star
24

RapidWright

Build Customized FPGA Implementations for Vivado
Java
248
star
25

QNN-MO-PYNQ

Jupyter Notebook
236
star
26

libsystemctlm-soc

SystemC/TLM-2.0 Co-simulation framework
Verilog
210
star
27

qemu

Xilinx's fork of Quick EMUlator (QEMU) with improved support and modelling for the Xilinx platforms.
C
200
star
28

DPU-PYNQ

DPU on PYNQ
Tcl
198
star
29

device-tree-xlnx

Linux device tree generator for the Xilinx SDK (Vivado > 2014.1)
Tcl
181
star
30

finn-examples

Dataflow QNN inference accelerator examples on FPGAs
Python
174
star
31

PYNQ-ComputerVision

Computer Vision Overlays on Pynq
Jupyter Notebook
173
star
32

XilinxVirtualCable

Xilinx Virtual Cable (XVC) is a TCP/IP-based protocol that acts like a JTAG cable and provides a means to access and debug your FPGA or SoC design without using a physical cable.
C
172
star
33

finn-hlslib

Vitis HLS Library for FINN
C++
172
star
34

graffitist

Graph Transforms to Quantize and Retrain Deep Neural Nets in TensorFlow
Python
169
star
35

open-nic

AMD OpenNIC Project Overview
Shell
166
star
36

SDSoC-Tutorials

SDSoCâ„¢ (Software-Defined System-On-Chip) Environment Tutorials
C++
142
star
37

xilinx-tiny-cnn

C++
141
star
38

FPGA_as_a_Service

Go
136
star
39

xup_vitis_network_example

VNx: Vitis Network Examples
Jupyter Notebook
133
star
40

meta-xilinx

Collection of Yocto Project layers to enable AMD Xilinx products
C
123
star
41

systemctlm-cosim-demo

QEMU libsystemctlm-soc co-simulation demos.
C++
114
star
42

Vitis-In-Depth-Tutorial

C++
113
star
43

Vitis_Embedded_Platform_Source

Tcl
105
star
44

llvm-aie

Fork of LLVM to support AMD AIEngine processors
LLVM
104
star
45

SDAccel-Tutorials

SDAccel Development Environment Tutorials
C++
101
star
46

nanotube

LLVM
101
star
47

Embedded-Design-Tutorials

100
star
48

RecoNIC

RecoNIC is a software/hardware shell used to enable network-attached processing within an RDMA-featured SmartNIC for scale-out computing.
SystemVerilog
94
star
49

RFNoC-HLS-NeuralNet

CMake
92
star
50

PYNQ-DL

Xilinx Deep Learning IP
VHDL
91
star
51

Kria-PYNQ

PYNQ support and examples for Kria SOMs
Jupyter Notebook
90
star
52

PYNQ-HelloWorld

This repository contains a "Hello World" introduction application to the Xilinx PYNQ framework.
Jupyter Notebook
90
star
53

LSTM-PYNQ

C++
86
star
54

kria-vitis-platforms

Kria Vitis platforms and overlays
SystemVerilog
86
star
55

meta-petalinux

meta-petalinux distro layer supporting Xilinx Tools
BitBake
84
star
56

Vivado-Design-Tutorials

Tcl
83
star
57

SDSoC_Examples

C++
82
star
58

ACCL

Alveo Collective Communication Library: MPI-like communication operations for Xilinx Alveo accelerators
C++
81
star
59

logicnets

Python
80
star
60

IIoT-EDDP

The repository contains the design database and documentation for Electric Drives Demonstration Platform
VHDL
79
star
61

mlir-air

C++
77
star
62

AI-Model-Zoo

75
star
63

Applications

C
71
star
64

open-nic-shell

AMD OpenNIC Shell includes the HDL source files
SystemVerilog
70
star
65

XilinxUnisimLibrary

Xilinx Unisim Library in Verilog
Verilog
66
star
66

PYNQ_Composable_Pipeline

PYNQ Composabe Overlays
Tcl
64
star
67

merlin-compiler

C++
57
star
68

PYNQ_RFSOC_Workshop

Open-sourcing the PYNQ & RFSoC workshop materials
Jupyter Notebook
56
star
69

gemx

Matrix Operation Library for FPGA https://xilinx.github.io/gemx/
C++
56
star
70

xup_high_level_synthesis_design_flow

AMD University Program HLS tutorial
Jupyter Notebook
54
star
71

meta-xilinx-tools

Yocto Project layer enables AMD Xilinx tools related metadata for MicroBlaze, Zynq, ZynqMP and Versal devices.
BitBake
54
star
72

RFSoC-PYNQ

Python productivity for RFSoC platforms
Jupyter Notebook
52
star
73

Alveo-PYNQ

Introductory examples for using PYNQ with Alveo
Jupyter Notebook
48
star
74

ResNet50-PYNQ

Quantized ResNet50 Dataflow Acceleration on Alveo, with PYNQ
C++
48
star
75

xup_compute_acceleration

Hands-on experience using the Vitis unified software platform with Xilinx FPGA hardware
C++
46
star
76

Vitis_Model_Composer

Vitis Model Composer Examples and Tutorials
C++
46
star
77

KRS

The Kria Robotics Stack (KRS) is a ROS 2 superset for industry, an integrated set of robot libraries and utilities to accelerate the development, maintenance and commercialization of industrial-grade robotic solutions while using adaptive computing.
HTML
46
star
78

Vitis-AWS-F1-Developer-Labs

C++
45
star
79

PYNQ_Bootcamp

PYNQ Bootcamp 2019-2022 teaching materials.
Jupyter Notebook
44
star
80

PYNQ-Networking

Networking Overlay on PYNQ
Tcl
44
star
81

HLS_packet_processing

C++
43
star
82

blockchainacceleration

Tcl
43
star
83

Get_Moving_With_Alveo

For publishing the source for UG1352 "Get Moving with Alveo"
C++
42
star
84

DSRL

42
star
85

pcie-model

PCI Express controller model
C
41
star
86

XilinxCEDStore

This store contains Configurable Example Designs.
Tcl
41
star
87

inference-server

C++
41
star
88

HLS_arbitrary_Precision_Types

C++
40
star
89

Xilinx_Kria_KV260_Workshop

40
star
90

vcu-ctrl-sw

C
38
star
91

VVAS

Vitis Video Analytics SDK
C
38
star
92

chipscopy

ChipScoPy (ChipScope Python API) is an open source Python API to the various ChipScope services provided by the TCF-based (Target Communication Framework) ChipScope Server (cs_server).
Jupyter Notebook
38
star
93

pyxir

Python
36
star
94

xup_aie_training

Hands-on experience programming AI Engines using Vitis Unified Software Platform
Jupyter Notebook
36
star
95

DSP-PYNQ

A PYNQ overlay demonstrating Pythonic DSP running on Zynq UltraScale+
Tcl
36
star
96

hdmi-modules

Xilinx Soft-IP HDMI Rx/Tx core Linux drivers
C
35
star
97

pytorch-ocr

Python
35
star
98

open-nic-driver

AMD OpenNIC driver includes the Linux kernel driver
C
33
star
99

bootgen

bootgen source code
C++
33
star
100

qemu-devicetrees

Device trees used by QEMU to describe the hardware
Makefile
32
star