diff --git "a/blogs_splitted_dataset.jsonl" "b/blogs_splitted_dataset.jsonl"
new file mode 100644--- /dev/null
+++ "b/blogs_splitted_dataset.jsonl"
@@ -0,0 +1,5982 @@
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch Trace Analysis for the Masses\"\nauthor: Anupam Bhatnagar, Xizhou Feng,  Brian Coutinho, Yifan Liu, Sung-Han Lin, Louis Feng, and Yuzhen Huang\n---","__index_level_0__":0}
+{"text":"We are excited to announce the public release of Holistic Trace Analysis (HTA), an open source performance analysis and visualization Python library for PyTorch users. HTA takes as input [Kineto traces](https:\/\/github.com\/pytorch\/kineto) collected by the [PyTorch profiler](https:\/\/pytorch.org\/blog\/introducing-pytorch-profiler-the-new-and-improved-performance-tool\/), which are complex and challenging to interpret, and up-levels the performance information contained in these traces. It was initially developed internally at Meta to understand and debug performance problems for large-scale distributed training jobs on GPUs. The multidisciplinary team has made a number of enhancements to HTA\u2019s features and scaled them to support state-of-the-art ML workloads. ","__index_level_0__":1}
+{"text":"ML researchers and systems engineers often struggle to computationally scale up their models because they are not aware of the performance bottlenecks in their workloads. The resources requested for a job (e.g. GPUs, memory) are often misaligned with the resources actually required due to lack of visibility \u201cunder the hood\u201d. To achieve the best performance from the hardware stack, it is imperative to understand the resource utilization and bottlenecks for distributed training workloads.","__index_level_0__":2}
+{"text":"The initial HTA implementation was specifically targeted at Deep Learning Based Recommendation Models (DLRM). To make the features in HTA generic and applicable to use cases such as analyzing Vision and NLP models, we decided to refactor the HTA codebase and make the library available to the larger community. This new codebase has implemented several important ideas which lead to significant efficiency and performance improvements. ","__index_level_0__":3}
+{"text":"In this blog, we present several features implemented in the open source version of HTA, which can be used as a Python script as well as interactively in a Jupyter notebook. HTA provides the following features:","__index_level_0__":4}
+{"text":"1. **Breakdown by Dimensions**\n    1. **Temporal**: Breakdown of GPU time in terms of time spent in computation, communication, memory events, and idle time on a single node and across all ranks.\n    1. **Idle Time**: Breakdown of GPU idle time into waiting for the host, waiting for another kernel or attributed to an unknown cause.\n    1. **Kernel**: Find kernels with the longest duration on each rank.\n    1. **Communication Computation Overlap**: Calculate the percentage of time when communication overlaps computation.\n1. **Statistical Analysis**\n    1. **Kernel Duration Distribution**: Distribution of average time taken by longest kernels across different ranks.\n    1. **CUDA Kernel Launch**: Distributions of GPU kernels with very small duration, large duration, and excessive launch time.\n    1. **Augmented Counters (Memory bandwidth, Queue length)**: Augmented trace files which provide insights into memory copy bandwidth and number of outstanding operations on each CUDA stream.\n1. **Patterns**\n    1. **Frequent CUDA Kernels**: Find the CUDA kernels most frequently launched by any given PyTorch or user defined operator.\n1. **Trace Comparison**\n    1. **Trace Diff**: A trace comparison tool to identify and visualize the differences between traces.","__index_level_0__":5}
+{"text":"HTA source code is available to users via [Github](https:\/\/github.com\/facebookresearch\/HolisticTraceAnalysis). Users can request new features or build their own analysis using the core libraries and data structures provided in the codebase in addition to the features mentioned above.","__index_level_0__":6}
+{"text":"## GPU Training Performance Debugging 101","__index_level_0__":7}
+{"text":"To understand the GPU performance in distributed training jobs, we consider how the model operators interact with the GPU devices and how such interactions are reflected in certain measurable metrics. ","__index_level_0__":8}
+{"text":"At a high level, we can break down the GPU operations in a model execution into three broad categories, henceforth referred to as kernel types: \n1. **Computation (COMP)** - Compute kernels execute compiled routines for matrix multiplication and similar numeric calculations. They are responsible for all of the number-crunching necessary for model execution. \n1. **Communication (COMM)** - Communication kernels are routines which are responsible for exchanging and synchronizing data between different GPU devices in a distributed training job. The NVIDIA Collective Communication Library (NCCL) is a widely used communication library and all its kernels have the prefix \u201cnccl\u201d. Example NCCL kernels include NCCL_AllGather, NCCL_ReduceScatter, NCCL_AllReduce, etc. \n1. **Memory (MEM)** - Memory kernels manage the memory allocations\/deallocations on the GPU devices and data movement between the memory space on the host and the GPUs. The memory kernels include Memcpy_H2D, Memcpy_D2H, Memcpy_D2D, Memset, etc. Here, H represents the Host and D represents the GPU Device. Thus, H2D, D2H, D2D stands for Host to Device, Device to Host and Device to Device respectively. ","__index_level_0__":9}
+{"text":"Because a modern GPU device like the NVIDIA A100 GPU is a massively parallel device which is capable of running multiple kernels simultaneously, it is possible to overlap the computation, communication, and memory kernels to reduce the model execution time. One common technique to achieve the overlap is to utilize multiple CUDA streams. A CUDA stream is a sequence of operations that execute on a GPU device in the order in which they are issued by the host code. Different CUDA streams can be interleaved and even run concurrently, thus achieving the effect of kernel overlap. ","__index_level_0__":10}
+{"text":"To help understand the above concepts, Figure 1 provides a timeline of the GPU kernels in a sample distributed training job on 8 GPUs for one iteration. In the figure below, each rank represents one GPU and the kernels on each GPU run on 6 CUDA streams. In the right column of the figure, you can see names of the GPU kernels used. In the middle of the figure, you see the overlap between compute and communicate kernels. This figure is created using the [plot_timeline example notebook](https:\/\/github.com\/facebookresearch\/HolisticTraceAnalysis\/blob\/main\/examples\/plot_timeline.ipynb) available in HTA.","__index_level_0__":11}
+{"text":"![Figure 1. An example of the execution timeline of GPU Kernels across multiple ranks](\/assets\/images\/trace-image6.png){:width=\"100%\"}","__index_level_0__":12}
+{"text":"*Figure 1. An example of the execution timeline of GPU Kernels across multiple ranks*\n{: style=\"text-align: center;\"}","__index_level_0__":13}
+{"text":"The performance of multiple GPU training jobs is affected by multiple factors. Among these factors, how does a model execution create and orchestrate the GPU kernels plays a critical role. HTA provides insights on how the model execution interacts with the GPU devices and highlights the opportunities for performance improvement.","__index_level_0__":14}
+{"text":"With the features we built in HTA, we aim to provide users insights into \u201cwhat is happening under the hood in a distributed GPU training?\u201d We briefly describe these features in the next few paragraphs.","__index_level_0__":15}
+{"text":"## Features in Holistic Trace Analysis ","__index_level_0__":16}
+{"text":"For most users, understanding the performance of GPU training jobs is nontrivial. Thus, we built this library to simplify the task of trace analysis and provide the user useful insights by examining the model execution traces. As the first step, we developed features which are important and generic enough so that most users can benefit from this library.","__index_level_0__":17}
+{"text":"**Temporal Breakdown**: We begin by asking whether the GPU is spending time on computation, communication, memory events, or is it idle? To answer this question, the temporal breakdown feature presents a breakdown in terms of these categories. To achieve high training efficiency the code should maximize time used by computation kernels and minimize idle time and non-compute time (time used by communication or memory kernels). This is accomplished by implementing concurrent execution of computation kernels with communication or memory kernels. *Note that, during concurrent execution of computation kernels with communication\/memory kernels the time spent by communication\/memory kernels is accounted for under compute time.*","__index_level_0__":18}
+{"text":"![Figure 2: Temporal Breakdown across 8 GPUs](\/assets\/images\/trace-image3.png){:width=\"100%\"}","__index_level_0__":19}
+{"text":"*Figure 2: Temporal Breakdown across 8 GPUs*\n{: style=\"text-align: center;\"}","__index_level_0__":20}
+{"text":"**Kernel Breakdown**: It is natural to ask which kernels are taking the most amount of time. The next feature breaks down the time spent within each kernel type (COMM, COMP, MEM) and sorts them by duration. We present this information for each kernel type and for each rank as a pie chart. See figure 3 below. ","__index_level_0__":21}
+{"text":"![Figure 3: Pie chart of top computation and communication kernels](\/assets\/images\/trace-image1.png){:width=\"100%\"}","__index_level_0__":22}
+{"text":"*Figure 3: Pie chart of top computation and communication kernels*\n{: style=\"text-align: center;\"}","__index_level_0__":23}
+{"text":"**Kernel Duration Distribution**: Subsequently, one can also ask - for any given kernel, what is the distribution of the time spent across the ranks? To answer this, HTA generates bar graphs for the average duration of a given kernel across all ranks. Additionally, the error bars in the bar graphs show the minimum and maximum amount of time taken by a given kernel on a given rank. Figure 4 below shows a discrepancy between average duration on rank 0 as compared to other ranks. This anomalous behavior on rank 0 guides the user on where to look for possible bugs.","__index_level_0__":24}
+{"text":"![Figure 4: Average duration of NCCL AllReduce Kernel across 8 ranks](\/assets\/images\/trace-image4.png){:width=\"100%\"}","__index_level_0__":25}
+{"text":"*Figure 4: Average duration of NCCL AllReduce Kernel across 8 ranks*\n{: style=\"text-align: center;\"}","__index_level_0__":26}
+{"text":"**Communication Computation Overlap**: In distributed training, a significant amount of time is spent in communication and synchronization events among multiple GPU devices. To achieve high GPU efficiency (i.e. TFLOPS\/GPU) it is vital to keep the GPU doing actual computation work. In other words, a GPU should not be blocked because of waiting for data from other GPUs. One way to measure the extent to which computation is blocked by data dependencies is to calculate the computation-communication overlap. Higher GPU efficiency is observed if communication events overlap computation events. Lack of communication and computation overlap will lead to the GPU being idle, thus the efficiency would be low. Thus, the communication computation overlap feature calculates the percentage of time communication and computation overlap in a job for each rank and generates a bar graph representation. See figure below. More precisely, we measure the following ratio","__index_level_0__":27}
+{"text":"(time spent in computation while communicating) \/ (time spent in communication)\n{: style=\"text-align: center;\"}","__index_level_0__":28}
+{"text":"\n![Figure 5: Communication computation overlap](\/assets\/images\/trace-image5.png){:width=\"100%\"}","__index_level_0__":29}
+{"text":"*Figure 5: Communication computation overlap*\n{: style=\"text-align: center;\"}","__index_level_0__":30}
+{"text":"**Augmented Counters (Queue length, Memory bandwidth)**: To aid in debugging, HTA calculates the memory bandwidth statistics for D2H, H2D and D2D memory copy (memcpy) and memory set (memset) events. Additionally, HTA also computes the number of outstanding CUDA operations on each CUDA stream. We refer to this as queue length. When the queue length on a stream is 1024 or larger new events cannot be scheduled on that stream and the CPU will stall until the GPU events have processed. Additionally, HTA generates a new trace file containing tracks with the memory bandwidth and queue length time series. See Figure 6 below.","__index_level_0__":31}
+{"text":"![Figure 6: Memory Bandwidth and Queue Length](\/assets\/images\/trace-image2.png){:width=\"100%\"}","__index_level_0__":32}
+{"text":"*Figure 6: Memory Bandwidth and Queue Length*\n{: style=\"text-align: center;\"}","__index_level_0__":33}
+{"text":"These primary features give us a peek into the system performance and help answer \u201cwhat is happening in the system?\u201d. As HTA evolves, we hope to address \u201cwhy is X happening?\u201d and also suggest possible solutions to overcome the bottlenecks.","__index_level_0__":34}
+{"text":"## Installation and Usage","__index_level_0__":35}
+{"text":"### Installation","__index_level_0__":36}
+{"text":"For installing the HTA please refer to the [README](https:\/\/github.com\/facebookresearch\/HolisticTraceAnalysis\/blob\/main\/README.md). In brief, the user is required to clone the [repo](https:\/\/github.com\/facebookresearch\/HolisticTraceAnalysis) and install the necessary Python packages via pip.","__index_level_0__":37}
+{"text":"This version of Holistic Trace Analysis is currently in beta and we recommend using HTA in a Jupyter notebook. A [demo notebook](https:\/\/github.com\/facebookresearch\/HolisticTraceAnalysis\/blob\/main\/examples\/trace_analysis_demo.ipynb) is provided for your convenience. To get started, import the hta package in a Jupyter notebook, create a TraceAnalysis object and off we go in exactly two lines of code.","__index_level_0__":39}
+{"text":"```python\nfrom hta.trace_analysis import TraceAnalysis\nanalyzer = TraceAnalysis(trace_dir = \u201c\/trace\/folder\/path\u201d)\n```","__index_level_0__":40}
+{"text":"### Requirements","__index_level_0__":41}
+{"text":"- All trace files for a training or inference job must be stored in a unique folder.\n- Trace files are in json or gzipped json format.","__index_level_0__":42}
+{"text":"#### Q. How can I install HTA?","__index_level_0__":44}
+{"text":"Please see the [README](https:\/\/github.com\/facebookresearch\/HolisticTraceAnalysis\/blob\/main\/README.md) in the root directory of the repository.","__index_level_0__":45}
+{"text":"#### Q. Is there any documentation on the features and API in HTA?","__index_level_0__":46}
+{"text":"The documentation and detailed API is available [here](https:\/\/hta.readthedocs.io\/).","__index_level_0__":47}
+{"text":"#### Q. Can you implement feature X?","__index_level_0__":48}
+{"text":"Depending on how widely the feature is needed and the level of effort required to implement it we would consider developing the feature. Please open a [Github Issue](https:\/\/github.com\/facebookresearch\/HolisticTraceAnalysis\/issues) and tag it with the feature-request label.","__index_level_0__":49}
+{"text":"#### Q. Can I modify the code?","__index_level_0__":50}
+{"text":"Please do and [send a PR](https:\/\/github.com\/facebookresearch\/HolisticTraceAnalysis\/pulls) along the way, if you think it would be useful for others.","__index_level_0__":51}
+{"text":"#### Q. How can I collect traces in PyTorch?","__index_level_0__":52}
+{"text":"Please refer to this tutorial [here](https:\/\/pytorch.org\/tutorials\/intermediate\/tensorboard_profiler_tutorial.html#use-profiler-to-record-execution-events).","__index_level_0__":53}
+{"text":"#### Q. Can HTA be used at production scale?","__index_level_0__":54}
+{"text":"Yes, please see a use case study [here](https:\/\/pytorch.org\/blog\/performance-debugging-of-production-pytorch-models-at-meta\/).\n \n source: https:\/\/pytorch.org\/blog\/trace-analysis-for-masses\/ \n category: pytorch blogs","__index_level_0__":55}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch adds new dev tools as it hits production scale'\nauthor: The PyTorch Team\n---","__index_level_0__":56}
+{"text":"_This is a partial re-post of the original blog post on the Facebook AI Blog. The full post can be [viewed here](https:\/\/ai.facebook.com\/blog\/pytorch-adds-new-dev-tools-as-it-hits-production-scale\/)_","__index_level_0__":57}
+{"text":"Since its release just a few months ago, [PyTorch 1.0](http:\/\/pytorch.org\/) has been rapidly adopted as a powerful, flexible deep learning platform that enables engineers and researchers to move quickly from research to production. We are highlighting some of the ways the AI engineering and research community is using PyTorch 1.0. We\u2019re also sharing new details about the latest release, PyTorch 1.1, and showcasing some of the new development tools created by the community.","__index_level_0__":58}
+{"text":"Building on the initial launch of PyTorch in 2017, we partnered with the AI community to ship the stable release of PyTorch 1.0 [last December](https:\/\/code.fb.com\/ai-research\/pytorch-developer-ecosystem-expands-1-0-stable-release\/). Along with enhanced production-oriented capabilities and deep integration with leading cloud platforms, PyTorch 1.0 expands on the open source library\u2019s core features, with the addition of PyTorch JIT (Just in time compilation) that seamlessly transitions between eager mode and graph mode to provide both flexibility and speed.","__index_level_0__":59}
+{"text":"Leading businesses across industries are beginning to use PyTorch to both facilitate their research and then also deploy at large scale for applications such as translation, computer vision, conversational interfaces, pharmaceutical research, factory optimization, and automated driving research. Community adoption of PyTorch has also continued to expand. Stanford, UC Berkeley, Caltech, and other universities are using PyTorch as a fundamental tool for their machine learning (ML) courses; new ecosystem projects have launched to support development on PyTorch; and major cloud platforms have expanded their integration with PyTorch.","__index_level_0__":60}
+{"text":"## Using PyTorch across industries","__index_level_0__":61}
+{"text":"Many leading businesses are moving to PyTorch 1.0 to accelerate development and deployment of new AI systems. Here are some examples:","__index_level_0__":62}
+{"text":"- Airbnb leveraged PyTorch's rich libraries and APIs for conversational AI and deployed a Smart Reply to help the company\u2019s service agents respond more effectively to customers.\n- [ATOM](https:\/\/atomscience.org\/) is building a platform to generate and optimize new drug candidates significantly faster and with greater success than conventional processes. Using machine learning frameworks such as PyTorch, ATOM was able to design a variational autoencoder for representing diverse chemical structures and designing new drug candidates.\n- Genentech is utilizing PyTorch\u2019s flexible control structures and dynamic graphs to train deep learning models that will aid in the development of individualized cancer therapy.\n- Microsoft is using PyTorch across its organization to develop ML models at scale and deploy them via the ONNX Runtime. Using PyTorch, Microsoft Cognition has built distributed language models that scale to billions of words and are now in production in offerings such as Cognitive Services.\n- Toyota Research Institute (TRI) is developing a two-pronged approach toward automated driving with Toyota Guardian and Toyota Chauffeur technologies. The Machine Learning Team at TRI is creating new deep learning algorithms to leverage Toyota's 10 million sales per year data advantage. The flexibility of PyTorch has vastly accelerated their pace of exploration and its new production features will enable faster deployment towards their safety critical applications.","__index_level_0__":63}
+{"text":"Following the release of PyTorch 1.0 in December 2018, we\u2019re now announcing the availability of v1.1, which improves performance, adds new model understanding and visualization tools to improve usability, and provides new APIs.","__index_level_0__":64}
+{"text":"Key features of PyTorch v1.1 include:","__index_level_0__":65}
+{"text":"- [TensorBoard](https:\/\/www.tensorflow.org\/tensorboard): First-class and native support for visualization and model debugging with TensorBoard, a web application suite for inspecting and understanding training runs and graphs. PyTorch now natively supports TensorBoard with a simple \u201cfrom torch.utils.tensorboard import SummaryWriter\u201d command.\n- JIT compiler: Improvements to just-in-time (JIT) compilation. These include various bug fixes as well as expanded capabilities in TorchScript, such as support for dictionaries, user classes, and attributes.\n- New APIs: Support for Boolean tensors and better support for custom recurrent neural networks.\n- Distributed Training: Improved performance for common models such as CNNs, added support for multi device modules including the ability to split models across GPUs while still using Distributed Data Parallel (DDP) and support for modules where not all parameters are used in every iteration (e.g. control flow, like adaptive softmax, etc). See the latest tutorials [here](https:\/\/pytorch.org\/tutorials\/intermediate\/model_parallel_tutorial.html).","__index_level_0__":66}
+{"text":"We\u2019ve also continued to partner with the community to foster projects and tools aimed at supporting ML engineers for needs ranging from improved model understanding to auto-tuning using AutoML methods. With the release of Ax and BoTorch (below), we will be sharing some of our core algorithms, including meta-learning for efficiently optimizing hyperparameters from based on historical tasks. We are excited to see this work open-sourced for the community to build on.","__index_level_0__":67}
+{"text":"This ecosystem includes open source projects and tools that have been deployed at production scale, as well as products and services from our partnership with industry leaders who share our vision of an open and collaborative AI community. Here are a few of the latest tools:","__index_level_0__":68}
+{"text":"- [BoTorch](https:\/\/ai.facebook.com\/blog\/open-sourcing-ax-and-botorch-new-ai-tools-for-adaptive-experimentation\/): BoTorch is a research framework built on top of PyTorch to provide Bayesian optimization, a sample-efficient technique for sequential optimization of costly-to-evaluate black-box functions.\n- [Ax](https:\/\/ai.facebook.com\/blog\/open-sourcing-ax-and-botorch-new-ai-tools-for-adaptive-experimentation\/): Ax is an ML platform for managing adaptive experiments. It enables researchers and engineers to systematically explore large configuration spaces in order to optimize machine learning models, infrastructure, and products.\n- [PyTorch-BigGraph](https:\/\/ai.facebook.com\/blog\/open-sourcing-pytorch-biggraph-for-faster-embeddings-of-extremely-large-graphs\/): PBG is a distributed system for creating embeddings of very large graphs with billions of entities and trillions of edges. It includes support for sharding and negative sampling and it offers sample use cases based on Wikidata embeddings.\n- [Google AI Platform Notebooks](https:\/\/cloud.google.com\/ai-platform-notebooks\/): AI Platform Notebooks is a new, hosted JupyterLab service from Google Cloud Platform. Data scientists can quickly create virtual machines running JupyterLab with the latest version of PyTorch preinstalled. It is also tightly integrated with GCP services such as BigQuery, Cloud Dataproc, Cloud Dataflow, and AI Factory, making it easy to execute the full ML cycle without ever leaving JupyterLab.","__index_level_0__":69}
+{"text":"We\u2019re also excited to see many interesting new projects from the broader PyTorch community. Highlights include:","__index_level_0__":70}
+{"text":"- [BigGAN-PyTorch](https:\/\/github.com\/ajbrock\/BigGAN-PyTorch):This is a full PyTorch reimplementation that uses gradient accumulation to provide the benefits of big batches on as few as four GPUs.\n- [GeomLoss](http:\/\/www.kernel-operations.io\/geomloss\/index.html): A Python API that defines PyTorch layers for geometric loss functions between sampled measures, images, and volumes. It includes MMD, Wasserstein, Sinkhorn, and more.","__index_level_0__":71}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/geomloss.jpg\" width=\"100%\">\n<\/div>","__index_level_0__":72}
+{"text":"- [PyTorch Geometric](https:\/\/github.com\/rusty1s\/pytorch_geometric): A deep learning extension library for PyTorch that offers several methods for deep learning on graphs and other irregular structures (also known as [geometric deep learning](http:\/\/geometricdeeplearning.com)) from a variety of published papers.\n- [Curve-GCN](https:\/\/github.com\/fidler-lab\/curve-gcn): A real-time, interactive image annotation approach that uses an end-to-end-trained graph convolutional network (GCN). It supports object annotation by either polygons or splines, facilitating labeling efficiency for both line-based and curved objects. Curve-GCN runs 10x faster than traditional methods, such as Polygon-RNN++.","__index_level_0__":73}
+{"text":"## Udacity, fast.ai, and others develop new PyTorch resources","__index_level_0__":74}
+{"text":"PyTorch is ideal for teaching ML development because it enables rapid experimentation through its flexible, dynamic programming environment and user-friendly Pythonic interface. In addition, Google Colab now offers an interactive Jupyter Notebook environment that natively supports PyTorch, allowing developers to run any PyTorch tutorial immediately with free CPU and GPU resources.","__index_level_0__":75}
+{"text":"University-level classes \u2014 including [Stanford NLP](http:\/\/web.stanford.edu\/class\/cs224n), [UC Berkeley](https:\/\/inst.eecs.berkeley.edu\/~cs280\/sp18\/) Computer Vision, and [Caltech](http:\/\/cast.caltech.edu) Robotics courses \u2014 are now being taught on PyTorch. In addition, massive open online courses (MOOCs) are training thousands of new PyTorch developers.","__index_level_0__":76}
+{"text":"Today, we\u2019re announcing a [new Udacity course](https:\/\/blog.udacity.com\/2019\/05\/announcing-the-secure-and-private-ai-scholarship-challenge-with-facebook.html), building upon the Intro to Deep Learning course launched last year. This new course, led by Andrew Trask of Oxford University and OpenMined, covers important concepts around privacy in AI, including methods such as differential privacy and federated learning. Facebook will also be providing scholarships to support students as they continue their ML education in Udacity\u2019s full Nanodegree programs.","__index_level_0__":77}
+{"text":"The [fast.ai](https:\/\/www.fast.ai) community is also continuing to invest energy and resources in PyTorch. In June, fast.ai will launch a new course called Deep Learning from the Foundations, which will show developers how to go all the way from writing matrix multiplication from scratch to how to train and implement a state-of-the-art ImageNet model. The course will include deep dives into the underlying implementation of methods in the PyTorch and fast.ai libraries, and will use the code to explain and illustrate the academic papers that underlie these methods.","__index_level_0__":78}
+{"text":"As part of the course, fast.ai will also release new software modules, including fastai.audio, which brings the power of fast.ai\u2019s deep abstractions and curated algorithms to the new PyTorch.audio module, and show how fastai.vision can be used to [create stunning high-resolution videos](https:\/\/www.fast.ai\/2019\/05\/03\/decrappify) from material such as old classic movies, and from cutting-edge microscopy sequences through a collaboration with the [Salk Institute](https:\/\/www.salk.edu). In addition, fast.ai is contributing its new X-ResNet module, including a suite of models pretrained on ImageNet.","__index_level_0__":79}
+{"text":"## Getting started with PyTorch","__index_level_0__":80}
+{"text":"Everyone in the AI community \u2014 including those new to ML development as well as researchers and engineers looking for ways to accelerate their end-to-end workflows \u2014 can experiment with PyTorch instantly by visiting [pytorch.org](https:\/\/pytorch.org) and launching a [tutorial](https:\/\/pytorch.org\/tutorials) in Colab. There are also many easy ways to [get started](https:\/\/pytorch.org\/get-started\/locally) both locally and on popular cloud platforms.\n \n source: https:\/\/pytorch.org\/blog\/pytorch-adds-new-dev-tools\/ \n category: pytorch blogs","__index_level_0__":81}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Introducing Accelerated PyTorch Training on Mac\"\nauthor: PyTorch\nfeatured-img: \"\/assets\/images\/METAPT-002-BarGraph-02-static.png\"\n---","__index_level_0__":82}
+{"text":"In collaboration with the Metal engineering team at Apple, we are excited to announce support for GPU-accelerated PyTorch training on Mac. Until now, PyTorch training on Mac only leveraged the CPU, but with the upcoming  PyTorch v1.12 release, developers and researchers can take advantage of Apple silicon GPUs for significantly faster model training. This unlocks the ability to perform machine learning workflows like prototyping and fine-tuning locally, right on Mac.","__index_level_0__":83}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/intro-graphic-accelerated-pytorch-training-revised.png\" width=\"100%\">\n<\/p>","__index_level_0__":84}
+{"text":"## Metal Acceleration","__index_level_0__":85}
+{"text":"Accelerated GPU training is enabled using Apple\u2019s Metal Performance Shaders (MPS) as a backend for PyTorch. The MPS backend extends the PyTorch framework, providing scripts and capabilities to set up and run operations on Mac. MPS optimizes compute performance with kernels that are fine-tuned for the unique characteristics of each Metal GPU family. The new device maps machine learning computational graphs and primitives on the MPS Graph framework and tuned kernels provided by MPS. ","__index_level_0__":86}
+{"text":"## Training Benefits on Apple Silicon","__index_level_0__":87}
+{"text":"Every Apple silicon Mac has a unified memory architecture, providing the GPU with direct access to the full memory store. This makes Mac a great platform for machine learning, enabling users to train larger networks or batch sizes locally. This reduces costs associated with cloud-based development or the need for additional local GPUs. The Unified Memory architecture also reduces data retrieval latency, improving end-to-end performance. ","__index_level_0__":88}
+{"text":"In the graphs below, you can see the performance speedup from accelerated GPU training and evaluation compared to the CPU baseline:","__index_level_0__":89}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/METAPT-002-BarGraph-02.gif\" width=\"100%\">\n<\/p>","__index_level_0__":90}
+{"text":"<p align = \"center\">\nAccelerated GPU training and evaluation speedups over CPU-only (times faster)\n<\/p>","__index_level_0__":91}
+{"text":"\n## Getting Started","__index_level_0__":92}
+{"text":"To get started, just install the latest [Preview (Nightly) build](https:\/\/pytorch.org\/get-started\/locally\/) on your Apple silicon Mac running macOS 12.3 or later with a native version (arm64) of Python.\n \nYou can also learn more about Metal and MPS on [Apple\u2019s Metal page](https:\/\/developer.apple.com\/metal\/).","__index_level_0__":93}
+{"text":"\\* _Testing conducted by Apple in April 2022 using production Mac Studio systems with Apple M1 Ultra, 20-core CPU, 64-core GPU 128GB of RAM, and 2TB SSD. Tested with macOS Monterey 12.3, prerelease PyTorch 1.12, ResNet50 (batch size=128), HuggingFace BERT (batch size=64), and VGG16 (batch size=64). Performance tests are conducted using specific computer systems and reflect the approximate performance of Mac Studio._\n \n source: https:\/\/pytorch.org\/blog\/introducing-accelerated-pytorch-training-on-mac\/ \n category: pytorch blogs","__index_level_0__":94}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Accelerating Hugging Face and TIMM models with PyTorch 2.0\"\nauthor: Mark Saroufim\nfeatured-img: \"assets\/images\/pytorch-2.0-feature-img.png\"\n---","__index_level_0__":95}
+{"text":"`torch.compile()` makes it easy to experiment with different compiler backends to make PyTorch code faster with a single line decorator `torch.compile()`. It works either directly over an nn.Module as a drop-in replacement for `torch.jit.script()` but without requiring you to make any source code changes. We expect this one line code change to provide you with between 30%-2x training time speedups on the vast majority of models that you\u2019re already running.","__index_level_0__":96}
+{"text":"opt_module = torch.compile(module)","__index_level_0__":98}
+{"text":"torch.compile supports arbitrary PyTorch code, control flow, mutation and comes with experimental support for dynamic shapes. We\u2019re so excited about this development that we call it PyTorch 2.0.","__index_level_0__":100}
+{"text":"What makes this announcement different for us is we\u2019ve already benchmarked some of the most popular open source PyTorch models and gotten substantial speedups ranging from 30% to 2x [https:\/\/github.com\/pytorch\/torchdynamo\/issues\/681](https:\/\/github.com\/pytorch\/torchdynamo\/issues\/681).","__index_level_0__":101}
+{"text":"There are no tricks here, we\u2019ve pip installed popular libraries like [https:\/\/github.com\/huggingface\/transformers](https:\/\/github.com\/huggingface\/transformers), [https:\/\/github.com\/huggingface\/accelerate](https:\/\/github.com\/huggingface\/accelerate) and [https:\/\/github.com\/rwightman\/pytorch-image-models](https:\/\/github.com\/rwightman\/pytorch-image-models) and then ran torch.compile() on them and that\u2019s it.","__index_level_0__":102}
+{"text":"It\u2019s rare to get both performance and convenience, but this is why the core team finds PyTorch 2.0 so exciting. The Hugging Face team is also excited, in their words:","__index_level_0__":103}
+{"text":"Ross Wightman the primary maintainer of TIMM: \u201cPT 2.0 works out of the box with majority of timm models for inference and train workloads and no code changes\u201d","__index_level_0__":104}
+{"text":"Sylvain Gugger the primary maintainer of transformers and accelerate: \"With just one line of code to add, PyTorch 2.0 gives a speedup between 1.5x and 2.x in training Transformers models. This is the most exciting thing since mixed precision training was introduced!\"","__index_level_0__":105}
+{"text":"This tutorial will show you exactly how to replicate those speedups so you can be as excited as to PyTorch 2.0 as we are.","__index_level_0__":106}
+{"text":"## Requirements and Setup","__index_level_0__":107}
+{"text":"For GPU (newer generation GPUs will see drastically better performance)","__index_level_0__":108}
+{"text":"```\npip3 install numpy --pre torch --force-reinstall --extra-index-url https:\/\/download.pytorch.org\/whl\/nightly\/cu117","__index_level_0__":109}
+{"text":"```\npip3 install --pre torch --extra-index-url https:\/\/download.pytorch.org\/whl\/nightly\/cpu","__index_level_0__":112}
+{"text":"Optional: Verify Installation","__index_level_0__":114}
+{"text":"```\ngit clone https:\/\/github.com\/pytorch\/pytorch\ncd tools\/dynamo\npython verify_dynamo.py\n```","__index_level_0__":115}
+{"text":"Optional: Docker installation","__index_level_0__":116}
+{"text":"We also provide all the required dependencies in the PyTorch nightly\nbinaries which you can download with","__index_level_0__":117}
+{"text":"```\ndocker pull ghcr.io\/pytorch\/pytorch-nightly","__index_level_0__":118}
+{"text":"And for ad hoc experiments just make sure that your container has access\nto all your GPUs","__index_level_0__":120}
+{"text":"```\ndocker run --gpus all -it ghcr.io\/pytorch\/pytorch-nightly:latest \/bin\/bash","__index_level_0__":121}
+{"text":"## Getting started","__index_level_0__":123}
+{"text":"### a toy exmaple","__index_level_0__":124}
+{"text":"Let\u2019s start with a simple example and make things more complicated step\nby step. Please note that you\u2019re likely to see more significant speedups the newer your GPU is.","__index_level_0__":125}
+{"text":"```python\nimport torch\ndef fn(x, y):\n    a = torch.sin(x).cuda()\n    b = torch.sin(y).cuda()\n    return a + b\nnew_fn = torch.compile(fn, backend=\"inductor\")\ninput_tensor = torch.randn(10000).to(device=\"cuda:0\")\na = new_fn(input_tensor, input_tensor)\n```","__index_level_0__":126}
+{"text":"This example won\u2019t actually run faster but it\u2019s educational.","__index_level_0__":127}
+{"text":"example that features `torch.cos()` and `torch.sin()` which are examples of pointwise ops as in they operate element by element on a vector. A more famous pointwise op you might actually want to use would be something like `torch.relu()`.","__index_level_0__":128}
+{"text":"Pointwise ops in eager mode are suboptimal because each one would need to read a tensor from memory, make some changes and then write back those changes.","__index_level_0__":129}
+{"text":"The single most important optimization that PyTorch 2.0 does for you is fusion.","__index_level_0__":130}
+{"text":"So back to our example we can turn 2 reads and 2 writes into 1 read and 1 write which is crucial especially for newer GPUs where the bottleneck is memory bandwidth (how quickly you can send data to a GPU) instead of compute (how quickly your GPU can crunch floating point operations)","__index_level_0__":131}
+{"text":"The second most important optimization that PyTorch 2.0 does for you is CUDA graphs","__index_level_0__":132}
+{"text":"CUDA graphs help eliminate the overhead from launching individual kernels from a python program.","__index_level_0__":133}
+{"text":"torch.compile() supports many different backends but one that we\u2019re particularly excited about is Inductor which generates Triton kernels [https:\/\/github.com\/openai\/triton](https:\/\/github.com\/openai\/triton) which are written in Python yet outperform the vast majority of handwritten CUDA kernels. Suppose our example above was called trig.py we can actually inspect the code generated triton kernels by running.","__index_level_0__":134}
+{"text":"```\nTORCH_COMPILE_DEBUG=1 python trig.py\n```","__index_level_0__":135}
+{"text":"@pointwise(size_hints=[16384], filename=__file__, meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': 0, 'constants': {}, 'configs': [instance_descriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]})\n@triton.jit\ndef kernel(in_ptr0, out_ptr0, xnumel, XBLOCK : tl.constexpr):\n    xnumel = 10000\n    xoffset = tl.program_id(0) * XBLOCK\n    xindex = xoffset + tl.reshape(tl.arange(0, XBLOCK), [XBLOCK])\n    xmask = xindex < xnumel\n    x0 = xindex\n    tmp0 = tl.load(in_ptr0 + (x0), xmask)\n    tmp1 = tl.sin(tmp0)\n    tmp2 = tl.sin(tmp1)\n    tl.store(out_ptr0 + (x0 + tl.zeros([XBLOCK], tl.int32)), tmp2, xmask)","__index_level_0__":137}
+{"text":"And you can verify that fusing the two `sins` did actually occur because the two `sin` operations occur within a single Triton kernel and the temporary variables are held in registers with very fast access.","__index_level_0__":139}
+{"text":"### a real model","__index_level_0__":140}
+{"text":"As a next step let\u2019s try a real model like resnet50 from the PyTorch hub.","__index_level_0__":141}
+{"text":"```python\nimport torch\nmodel = torch.hub.load('pytorch\/vision:v0.10.0', 'resnet18', pretrained=True)\nopt_model = torch.compile(model, backend=\"inductor\")\nmodel(torch.randn(1,3,64,64))","__index_level_0__":142}
+{"text":"If you actually run you may be surprised that the first run is slow and that\u2019s because the model is being compiled. Subsequent runs will be faster so it's common practice to warm up your model before you start benchmarking it.","__index_level_0__":144}
+{"text":"You may have noticed how we also passed in the name of a compiler explicitly here with \u201cinductor\u201d but it\u2019s not the only available backend, you can run in a REPL `torch._dynamo.list_backends()` to see the full list of available backends. For fun you should try out `aot_cudagraphs` or `nvfuser`.","__index_level_0__":145}
+{"text":"### Hugging Face models","__index_level_0__":146}
+{"text":"Let\u2019s do something a bit more interesting now, our community frequently\nuses pretrained models from transformers [https:\/\/github.com\/huggingface\/transformers](https:\/\/github.com\/huggingface\/transformers) or TIMM [https:\/\/github.com\/rwightman\/pytorch-image-models](https:\/\/github.com\/rwightman\/pytorch-image-models) and one of our design goals for PyTorch 2.0 was that any new compiler stack needs to work out of the box with the vast majority of models people actually run.","__index_level_0__":147}
+{"text":"So we\u2019re going to directly download a pretrained model from the Hugging Face hub and optimize it","__index_level_0__":148}
+{"text":"import torch\nfrom transformers import BertTokenizer, BertModel\n# Copy pasted from here https:\/\/huggingface.co\/bert-base-uncased\ntokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\nmodel = BertModel.from_pretrained(\"bert-base-uncased\").to(device=\"cuda:0\")\nmodel = torch.compile(model) # This is the only line of code that we changed\ntext = \"Replace me by any text you'd like.\"\nencoded_input = tokenizer(text, return_tensors='pt').to(device=\"cuda:0\")\noutput = model(**encoded_input)","__index_level_0__":150}
+{"text":"If you remove the `to(device=\"cuda:0\")` from the model and `encoded_input` then PyTorch 2.0 will generate C++ kernels that will be optimized for running on your CPU. You can inspect both Triton or C++ kernels for BERT, they\u2019re obviously more complex than the trigonometry example we had above but you can similarly skim it and understand if you understand PyTorch.","__index_level_0__":152}
+{"text":"The same code also works just fine if used with [https:\/\/github.com\/huggingface\/accelerate](https:\/\/github.com\/huggingface\/accelerate) and DDP","__index_level_0__":153}
+{"text":"Similarly let\u2019s try out a TIMM example","__index_level_0__":154}
+{"text":"```python\nimport timm\nimport torch\nmodel = timm.create_model('resnext101_32x8d', pretrained=True, num_classes=2)\nopt_model = torch.compile(model, backend=\"inductor\")\nopt_model(torch.randn(64,3,7,7))\n```","__index_level_0__":155}
+{"text":"Our goal with PyTorch was to build a breadth-first compiler that would speed up the vast majority of actual models people run in open source. The Hugging Face Hub ended up being an extremely valuable benchmarking tool for us, ensuring that any optimization we work on actually helps accelerate models people want to run.","__index_level_0__":156}
+{"text":"So please try out PyTorch 2.0, enjoy the free perf and if you\u2019re not seeing it then please open an issue and we will make sure your model is supported [https:\/\/github.com\/pytorch\/torchdynamo\/issues](https:\/\/github.com\/pytorch\/torchdynamo\/issues)","__index_level_0__":157}
+{"text":"After all, we can\u2019t claim we\u2019re created a breadth-first unless YOUR models actually run faster.\n \n source: https:\/\/pytorch.org\/blog\/Accelerating-Hugging-Face-and-TIMM-models\/ \n category: pytorch blogs","__index_level_0__":158}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 1.6 now includes Stochastic Weight Averaging'\nauthor: Pavel Izmailov, Andrew Gordon Wilson and Vincent Queneneville-Belair\n---","__index_level_0__":159}
+{"text":"Do you use stochastic gradient descent (SGD) or Adam? Regardless of the procedure you use to train your neural network, you can likely achieve significantly better generalization at virtually no additional cost with a simple new technique now natively supported in PyTorch 1.6, Stochastic Weight Averaging (SWA) [1]. Even if you have already trained your model, it\u2019s easy to realize the benefits of SWA by running SWA for a small number of epochs starting with a pre-trained model. [Again](https:\/\/twitter.com\/MilesCranmer\/status\/1282140440892932096) and [again](https:\/\/twitter.com\/leopd\/status\/1285969855062192129), researchers are  discovering that SWA improves the performance of well-tuned models in a wide array of practical applications with little cost or effort!","__index_level_0__":160}
+{"text":"\nSWA has a wide range of applications and features:\n* SWA significantly improves performance compared to standard training techniques in computer vision (e.g., VGG, ResNets, Wide ResNets and DenseNets on ImageNet and CIFAR benchmarks [1, 2]).\n* SWA provides state-of-the-art performance on key benchmarks in semi-supervised learning and domain adaptation [2].\n* SWA was shown to improve performance in language modeling (e.g., AWD-LSTM on WikiText-2 [4]) and policy-gradient methods in deep reinforcement learning [3].\n* SWAG, an extension of SWA, can approximate Bayesian model averaging in Bayesian deep learning and achieves state-of-the-art uncertainty calibration results in various settings. Moreover, its recent generalization MultiSWAG provides significant additional performance gains and mitigates double-descent [4, 10]. Another approach, Subspace Inference, approximates the Bayesian posterior in a small subspace of the parameter space around the SWA solution [5].\n* SWA for low precision training, SWALP, can match the performance of full-precision SGD training, even with all numbers quantized down to 8 bits, including gradient accumulators [6].\n* SWA in parallel, SWAP, was shown to greatly speed up the training of neural networks by using large batch sizes and, in particular, set a record by training a neural network to 94% accuracy on CIFAR-10 in 27 seconds [11].","__index_level_0__":161}
+{"text":"\n<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swapytorch1.png\" width=\"100%\">\n<\/div>","__index_level_0__":162}
+{"text":"**Figure 1**. *Illustrations of SWA and SGD with a Preactivation ResNet-164 on CIFAR-100 [1]. **Left**: test error surface for three FGE samples and the corresponding SWA solution (averaging in weight space). **Middle** and **Right**: test error and train loss surfaces showing the weights proposed by SGD (at convergence) and SWA, starting from the same initialization of SGD after 125 training epochs. Please see [1] for details on how these figures were constructed*.","__index_level_0__":163}
+{"text":"In short, SWA performs an equal average of the weights traversed by SGD (or any stochastic optimizer) with a modified learning rate schedule (see the left panel of Figure 1.). SWA solutions end up in the center of a wide flat region of loss, while SGD tends to converge to the boundary of the low-loss region, making it susceptible to the shift between train and test error surfaces (see the middle and right panels of Figure 1). We emphasize that SWA **can be used with any optimizer, such as Adam, and is not specific to SGD**.","__index_level_0__":164}
+{"text":"Previously, SWA was in PyTorch contrib. In PyTorch 1.6, we provide a new convenient implementation of SWA in [torch.optim.swa_utils](https:\/\/pytorch.org\/docs\/stable\/optim.html#stochastic-weight-averaging).","__index_level_0__":165}
+{"text":"## Is this just Averaged SGD?","__index_level_0__":166}
+{"text":"At a high level, averaging SGD iterates dates back several decades in convex optimization [7, 8], where it is sometimes referred to as Polyak-Ruppert averaging, or averaged SGD. **But the details matter**. Averaged SGD is often used in conjunction with a decaying learning rate, and an exponential moving average (EMA), typically for convex optimization. In convex optimization, the focus has been on improved rates of convergence. In deep learning, this form of averaged SGD smooths the trajectory of SGD iterates but does not perform very differently.","__index_level_0__":167}
+{"text":"By contrast, SWA uses an **equal average** of SGD iterates with a modified **cyclical or high constant learning rate** and exploits the flatness of training objectives [8] specific to **deep learning** for **improved generalization**. ","__index_level_0__":168}
+{"text":"## How does Stochastic Weight Averaging Work?","__index_level_0__":169}
+{"text":"There are two important ingredients that make SWA work. First, SWA uses a **modified learning rate** schedule so that SGD (or other optimizers such as Adam) continues to bounce around the optimum and explore diverse models instead of simply converging to a single solution. For example, we can use the standard decaying learning rate strategy for the first 75% of training time and then set the learning rate to a reasonably high constant value for the remaining 25% of the time (see Figure 2 below). The second ingredient is to take an average of the weights **(typically an equal average)** of the networks traversed by SGD. For example, we can maintain a running average of the weights obtained at the end of every epoch within the last 25% of training time (see Figure 2). After training is complete, we then set the weights of the network to the computed SWA averages.","__index_level_0__":170}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/nswapytorch2.jpg\" width=\"100%\">\n<\/div>","__index_level_0__":171}
+{"text":"**Figure 2**. *Illustration of the learning rate schedule adopted by SWA. Standard decaying schedule is used for the first 75% of the training and then a high constant value is used for the remaining 25%. The SWA averages are formed during the last 25% of training*.","__index_level_0__":172}
+{"text":"One important detail is the batch normalization. Batch normalization layers compute running statistics of activations during training. Note that the SWA averages of the weights are never used to make predictions during training. So the batch normalization layers do not have the activation statistics computed at the end of training. We can compute these statistics by doing a single forward pass on the train data with the SWA model.","__index_level_0__":173}
+{"text":"While we focus on SGD for simplicity in the description above, SWA can be combined with any optimizer. You can also use cyclical learning rates instead of a high constant value (see e.g., [2]).","__index_level_0__":174}
+{"text":"## How to use SWA in PyTorch?","__index_level_0__":175}
+{"text":"In `torch.optim.swa_utils` we implement all the SWA ingredients to make it convenient to use SWA with any model. In particular, we implement `AveragedModel` class for SWA models, `SWALR` learning rate scheduler, and `update_bn` utility function to update SWA batch normalization statistics at the end of training. ","__index_level_0__":176}
+{"text":"In the example below, `swa_model` is the SWA model that accumulates the averages of the weights. We train the model for a total of 300 epochs, and we switch to the SWA learning rate schedule and start to collect SWA averages of the parameters at epoch 160. ","__index_level_0__":177}
+{"text":"```python\nfrom torch.optim.swa_utils import AveragedModel, SWALR\nfrom torch.optim.lr_scheduler import CosineAnnealingLR","__index_level_0__":178}
+{"text":"loader, optimizer, model, loss_fn = ...\nswa_model = AveragedModel(model)\nscheduler = CosineAnnealingLR(optimizer, T_max=100)\nswa_start = 5\nswa_scheduler = SWALR(optimizer, swa_lr=0.05)","__index_level_0__":179}
+{"text":"for epoch in range(100):\n      for input, target in loader:\n          optimizer.zero_grad()\n          loss_fn(model(input), target).backward()\n          optimizer.step()\n      if epoch > swa_start:\n          swa_model.update_parameters(model)\n          swa_scheduler.step()\n      else:\n          scheduler.step()","__index_level_0__":180}
+{"text":"# Update bn statistics for the swa_model at the end\ntorch.optim.swa_utils.update_bn(loader, swa_model)\n# Use swa_model to make predictions on test data \npreds = swa_model(test_input)\n```","__index_level_0__":181}
+{"text":"Next, we explain each component of `torch.optim.swa_utils` in detail.","__index_level_0__":182}
+{"text":"`AveragedModel` class serves to compute the weights of the SWA model. You can create an averaged model by running  `swa_model = AveragedModel(model)`. You can then update the parameters of the averaged model by `swa_model.update_parameters(model)`. By default, `AveragedModel` computes a running equal average of the parameters that you provide, but you can also use custom averaging functions with the `avg_fn` parameter. In the following example, `ema_model` computes an exponential moving average.","__index_level_0__":183}
+{"text":"```python\nema_avg = lambda averaged_model_parameter, model_parameter, num_averaged:\\\n0.1 * averaged_model_parameter + 0.9 * model_parameter\nema_model = torch.optim.swa_utils.AveragedModel(model, avg_fn=ema_avg)\n```","__index_level_0__":184}
+{"text":"In practice, we find an equal average with the modified learning rate schedule in Figure 2 provides the best performance.","__index_level_0__":185}
+{"text":"`SWALR` is a learning rate scheduler that anneals the learning rate to a fixed value, and then keeps it constant. For example, the following code creates a scheduler that linearly anneals the learning rate from its initial value to `0.05` in `5` epochs within each parameter group.","__index_level_0__":186}
+{"text":"```python\nswa_scheduler = torch.optim.swa_utils.SWALR(optimizer, \nanneal_strategy=\"linear\", anneal_epochs=5, swa_lr=0.05)","__index_level_0__":187}
+{"text":"```\nWe also implement cosine annealing to a fixed value (`anneal_strategy=\"cos\"`). In practice, we typically switch to `SWALR` at epoch `swa_start`  (e.g. after 75% of the training epochs), and simultaneously start to compute the running averages of the weights:","__index_level_0__":188}
+{"text":"```python\nscheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)\nswa_start = 75\nfor epoch in range(100):\n      # <train epoch>\n      if i > swa_start:\n          swa_model.update_parameters(model)\n          swa_scheduler.step()\n      else:\n          scheduler.step()\n```","__index_level_0__":189}
+{"text":"Finally, `update_bn` is a utility function that computes the batchnorm statistics for the SWA model on a given dataloader `loader`:\n```\ntorch.optim.swa_utils.update_bn(loader, swa_model) \n```\n`update_bn` applies the `swa_model` to every element in the dataloader and computes the activation statistics for each batch normalization layer in the model.","__index_level_0__":190}
+{"text":"Once you computed the SWA averages and updated the batch normalization layers, you can apply `swa_model` to make predictions on test data.","__index_level_0__":191}
+{"text":"## Why does it work?","__index_level_0__":192}
+{"text":"There are large flat regions of the loss surface [9]. In Figure 3 below, we show a visualization of the loss surface in a subspace of the parameter space containing a path connecting two independently trained SGD solutions, such that the loss is similarly low at every point along the path. SGD converges near the boundary of these regions because there isn\u2019t much gradient signal to move inside, as the points in the region all have similarly low values of loss. By increasing the learning rate, SWA spins around this flat region, and then by averaging the iterates, moves towards the center of the flat region.","__index_level_0__":193}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swapytorch3.jpg\" width=\"100%\">\n<\/div>","__index_level_0__":194}
+{"text":"**Figure 3**: *visualization of mode connectivity for ResNet-20 with no skip connections on CIFAR-10 dataset. The visualization is created in collaboration with Javier Ideami [(https:\/\/losslandscape.com\/)](https:\/\/losslandscape.com\/). For more details, see this [blogpost](https:\/\/izmailovpavel.github.io\/curves_blogpost\/)*.","__index_level_0__":195}
+{"text":"We expect solutions that are centered in the flat region of the loss to generalize better than those near the boundary. Indeed, train and test error surfaces are not perfectly aligned in the weight space. Solutions that are centered in the flat region are not as susceptible to the shifts between train and test error surfaces as those near the boundary. In Figure 4 below, we show the train loss and test error surfaces along the direction connecting the SWA and SGD solutions. As you can see, while the SWA solution has a higher train loss compared to the SGD solution, it is centered in a region of low loss and has a substantially better test error.","__index_level_0__":196}
+{"text":"\n<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swapytorch4.png\" width=\"100%\">\n<\/div>","__index_level_0__":197}
+{"text":"**Figure 4**. *Train loss and test error along the line connecting the SWA solution (circle) and SGD solution (square). The SWA solution is centered in a wide region of low train loss, while the SGD solution lies near the boundary. Because of the shift between train loss and test error surfaces, the SWA solution leads to much better generalization*.","__index_level_0__":198}
+{"text":"## What are the results achieved with SWA?","__index_level_0__":199}
+{"text":"We release a GitHub [repo](https:\/\/github.com\/izmailovpavel\/torch_swa_examples) with examples using the PyTorch implementation of SWA for training DNNs. For example, these examples can be used to achieve the following results on CIFAR-100:","__index_level_0__":200}
+{"text":"\n {:.table.table-striped.table-bordered}\n |  | VGG-16 | ResNet-164 | WideResNet-28x10 | \n| ------------- | ------------- |  ------------- |  ------------- |\n| SGD | 72.8 \u00b1 0.3 | 78.4 \u00b1 0.3 | 81.0 \u00b1 0.3 | \n| SWA | 74.4 \u00b1 0.3 | 79.8 \u00b1 0.4 | 82.5 \u00b1 0.2 |","__index_level_0__":201}
+{"text":"\n## Semi-Supervised Learning","__index_level_0__":202}
+{"text":"In a follow-up [paper](https:\/\/arxiv.org\/abs\/1806.05594) SWA was applied to semi-supervised learning, where it improved the best reported results in multiple settings [2]. For example, with SWA you can get  95% accuracy on CIFAR-10 if you only have the training labels for 4k training data points (the previous best reported result on this problem was 93.7%). This paper also explores averaging multiple times within epochs, which can accelerate convergence and find still flatter solutions in a given time.","__index_level_0__":203}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swapytorch5.png\" width=\"100%\">\n<\/div>\n**Figure 5**. Performance of fast-SWA on semi-supervised learning with CIFAR-10. fast-SWA achieves record results in every setting considered.","__index_level_0__":204}
+{"text":"## Reinforcement Learning","__index_level_0__":205}
+{"text":"In another follow-up [paper](http:\/\/www.gatsby.ucl.ac.uk\/~balaji\/udl-camera-ready\/UDL-24.pdf) SWA was shown to improve the performance of policy gradient methods A2C and DDPG on several Atari games and MuJoCo environments [3]. This application is also an instance of where SWA is used with Adam. Recall that SWA is not specific to SGD and can benefit essentially any optimizer.","__index_level_0__":206}
+{"text":"\n{:.table.table-striped.table-bordered}\n | Environment Name | A2C | A2C + SWA | \n| ------------- | ------------- |  ------------- |  \n| Breakout | 522 \u00b1 34 | 703 \u00b1 60 |\n| Qbert | 18777 \u00b1 778 | 21272 \u00b1 655 |\n| SpaceInvaders | 7727 \u00b1 1121 | 21676 \u00b1 8897 |\n| Seaquest | 1779 \u00b1 4 | 1795 \u00b1 4 |\n| BeamRider | 9999 \u00b1 402 | 11321 \u00b1 1065 |\n| CrazyClimber | 147030 \u00b1 10239 | 139752 \u00b1 11618 |","__index_level_0__":207}
+{"text":"\n## Low Precision Training","__index_level_0__":208}
+{"text":"We can filter through quantization noise by combining weights that have been rounded down with weights that have been rounded up. Moreover, by averaging weights to find a flat region of the loss surface, large perturbations of the weights will not affect the quality of the solution (Figures 9 and 10). Recent [work](https:\/\/arxiv.org\/abs\/1904.11943) shows that by adapting SWA to the low precision setting, in a method called SWALP, one can match the performance of full-precision SGD even with all training in 8 bits [5]. This is quite a practically important result, given that (1) SGD training in 8 bits performs notably worse than full precision SGD, and (2) low precision training is significantly harder than predictions in low precision after training (the usual setting). For example, a ResNet-164 trained on CIFAR-100 with float (16-bit) SGD achieves 22.2% error, while 8-bit SGD achieves 24.0% error. By contrast, SWALP with 8 bit training achieves 21.8% error.","__index_level_0__":209}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/nswapytorch6.png\" width=\"100%\">\n<\/div>\n**Figure 9**. *Quantizing a solution leads to a perturbation of the weights which has a greater effect on the quality of the sharp solution (left) compared to wide solution (right)*.  ","__index_level_0__":210}
+{"text":"\n<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swapytorch7.png\" width=\"100%\">\n<\/div>\n**Figure 10**. *The difference between standard low precision training and SWALP*.","__index_level_0__":211}
+{"text":"Another [work](https:\/\/arxiv.org\/abs\/2002.00343), SQWA, presents an approach for quantization and fine-tuning of neural networks in low precision [12]. In particular, SQWA achieved state-of-the-art results for DNNs quantized to 2 bits on CIFAR-100 and ImageNet.","__index_level_0__":212}
+{"text":"## Calibration and Uncertainty Estimates","__index_level_0__":213}
+{"text":"By finding a centred solution in the loss, SWA can also improve calibration and uncertainty representation. Indeed, SWA can be viewed as an approximation to an ensemble, resembling a Bayesian model average, but with a single model [1].","__index_level_0__":214}
+{"text":"SWA can be viewed as taking the first moment of SGD iterates with a modified learning rate schedule. We can directly generalize SWA by also taking the second moment of iterates to form a Gaussian approximate posterior over the weights, further characterizing the loss geometry with SGD iterates.  This approach,[SWA-Gaussian (SWAG)](https:\/\/arxiv.org\/abs\/1902.02476) is a simple, scalable and convenient approach to uncertainty estimation and calibration in Bayesian deep learning [4]. The SWAG distribution approximates the shape of the true posterior: Figure 6 below shows the SWAG distribution and the posterior log-density for ResNet-20 on CIFAR-10.","__index_level_0__":215}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/nswapytorch8.png\" width=\"100%\">\n<\/div>\n**Figure 6**. *SWAG posterior approximation and the loss surface for a ResNet-20 without skip-connections trained on CIFAR-10 in the subspace formed by the two largest eigenvalues of the SWAG covariance matrix. The shape of SWAG distribution is aligned with the posterior: the peaks of the two distributions coincide, and both distributions are wider in one direction than in the orthogonal direction. Visualization created in collaboration with* [Javier Ideami](https:\/\/losslandscape.com\/).","__index_level_0__":216}
+{"text":"Empirically, SWAG performs on par or better than popular alternatives including MC dropout, KFAC Laplace, and temperature scaling on uncertainty quantification, out-of-distribution detection, calibration and transfer learning in computer vision tasks. Code for SWAG is available [here](https:\/\/github.com\/wjmaddox\/swa_gaussian). ","__index_level_0__":217}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swapytorch9.png\" width=\"100%\">\n<\/div>\n**Figure 7**. *MultiSWAG generalizes SWAG and deep ensembles, to perform Bayesian model averaging over multiple basins of attraction, leading to significantly improved performance. By contrast, as shown here, deep ensembles select different modes, while standard variational inference (VI) marginalizes (model averages) within a single basin*.","__index_level_0__":218}
+{"text":"MultiSWAG [9] uses multiple independent SWAG models to form a mixture of Gaussians as an approximate posterior distribution. Different basins of attraction contain highly complementary explanations of the data. Accordingly, marginalizing over these multiple basins provides a significant boost in accuracy and uncertainty representation. MultiSWAG can be viewed as a generalization of deep ensembles, but with performance improvements.","__index_level_0__":219}
+{"text":"\nIndeed, we see in Figure 8 that MultiSWAG entirely mitigates double descent -- more flexible models have monotonically improving performance -- and provides significantly improved generalization over SGD. For example, when the ResNet-18 has layers of width 20, Multi-SWAG achieves under 30% error whereas SGD achieves over 45%, more than a 15% gap! ","__index_level_0__":220}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swapytorch10.png\" width=\"100%\">\n<\/div>\n**Figure 8**. *SGD, SWAG, and Multi-SWAG on CIFAR-100 for a ResNet-18 with varying widths. We see Multi-SWAG in particular mitigates double descent and provides significant accuracy improvements over SGD*.","__index_level_0__":221}
+{"text":"Reference [10] also considers Multi-SWA, which uses multiple independently trained SWA solutions in an ensemble, providing performance improvements over deep ensembles without any additional computational cost. Code for MultiSWA and MultiSWAG is available [here](https:\/\/github.com\/izmailovpavel\/understandingbdl).","__index_level_0__":222}
+{"text":"Another [method](https:\/\/arxiv.org\/abs\/1907.07504), Subspace Inference, constructs a low-dimensional subspace around the SWA solution and marginalizes the weights in this subspace to approximate the Bayesian model average [5]. Subspace Inference uses the statistics from the SGD iterates to construct both the SWA solution and the subspace. The method achieves strong performance in terms of prediction accuracy and uncertainty calibration both in classification and regression problems. Code is available [here](https:\/\/github.com\/wjmaddox\/drbayes).","__index_level_0__":223}
+{"text":"## Try it Out!","__index_level_0__":224}
+{"text":"One of the greatest open questions in deep learning is why SGD manages to find good solutions, given that the training objectives are highly multimodal, and there are many settings of parameters that achieve no training loss but poor generalization. By understanding geometric features such as flatness, which relate to generalization, we can begin to resolve these questions and build optimizers that provide even better generalization, and many other useful features, such as uncertainty representation. We have presented SWA, a simple drop-in replacement for standard optimizers such as SGD and Adam, which can in principle, benefit anyone training a deep neural network. SWA has been demonstrated to have a strong performance in several areas, including computer vision, semi-supervised learning, reinforcement learning, uncertainty representation, calibration, Bayesian model averaging, and low precision training. ","__index_level_0__":225}
+{"text":"\nWe encourage you to try out SWA! SWA is now as easy as any standard training in PyTorch. And even if you have already trained your model, you can use SWA to significantly improve performance by running it for a small number of epochs from a pre-trained model. ","__index_level_0__":226}
+{"text":"\n[1] Averaging Weights Leads to Wider Optima and Better Generalization; Pavel Izmailov, Dmitry Podoprikhin, Timur Garipov, Dmitry Vetrov, Andrew Gordon Wilson; Uncertainty in Artificial Intelligence (UAI), 2018.","__index_level_0__":227}
+{"text":"[2] There Are Many Consistent Explanations of Unlabeled Data: Why You Should Average; Ben Athiwaratkun, Marc Finzi, Pavel Izmailov, Andrew Gordon Wilson; \nInternational Conference on Learning Representations (ICLR), 2019.","__index_level_0__":228}
+{"text":"[3] Improving Stability in Deep Reinforcement Learning with Weight Averaging; Evgenii Nikishin, Pavel Izmailov, Ben Athiwaratkun, Dmitrii Podoprikhin, \nTimur Garipov, Pavel Shvechikov, Dmitry Vetrov, Andrew Gordon Wilson; UAI 2018 Workshop: Uncertainty in Deep Learning, 2018.","__index_level_0__":229}
+{"text":"[4]  A Simple Baseline for Bayesian Uncertainty in Deep Learning\nWesley Maddox, Timur Garipov, Pavel Izmailov, Andrew Gordon Wilson; Neural Information Processing Systems (NeurIPS), 2019.","__index_level_0__":230}
+{"text":"[5] Subspace Inference for Bayesian Deep Learning\nPavel Izmailov, Wesley Maddox, Polina Kirichenko, Timur Garipov, Dmitry Vetrov, Andrew Gordon Wilson\nUncertainty in Artificial Intelligence (UAI), 2019.","__index_level_0__":231}
+{"text":"[6] SWALP : Stochastic Weight Averaging in Low Precision Training\nGuandao Yang, Tianyi Zhang, Polina Kirichenko, Junwen Bai, \nAndrew Gordon Wilson, Christopher De Sa; International Conference on Machine Learning  (ICML), 2019.","__index_level_0__":232}
+{"text":"[7] David Ruppert. Efficient estimations from a slowly convergent Robbins-Monro process; Technical report, Cornell University Operations Research and Industrial Engineering, 1988.","__index_level_0__":233}
+{"text":"[8] Acceleration of stochastic approximation by averaging. Boris T Polyak and Anatoli B Juditsky; SIAM Journal on Control and Optimization, 30(4):838\u2013855, 1992.","__index_level_0__":234}
+{"text":"[9] Loss Surfaces, Mode Connectivity, and Fast Ensembling of DNNs\nTimur Garipov, Pavel Izmailov, Dmitrii Podoprikhin, Dmitry Vetrov, \nAndrew Gordon Wilson. Neural Information Processing Systems (NeurIPS), 2018.","__index_level_0__":235}
+{"text":"[10] Bayesian Deep Learning and a Probabilistic Perspective of Generalization\nAndrew Gordon Wilson, Pavel Izmailov. ArXiv preprint, 2020.","__index_level_0__":236}
+{"text":"[11] Stochastic Weight Averaging in Parallel: Large-Batch Training That Generalizes Well\nGupta, Vipul, Santiago Akle Serrano, and Dennis DeCoste; International Conference on Learning Representations (ICLR). 2019.","__index_level_0__":237}
+{"text":"[12] SQWA: Stochastic Quantized Weight Averaging for Improving the Generalization Capability of Low-Precision Deep Neural Networks\nShin, Sungho, Yoonho Boo, and Wonyong Sung; arXiv preprint 2020.","__index_level_0__":238}
+{"text":" \n source: https:\/\/pytorch.org\/blog\/pytorch-1.6-now-includes-stochastic-weight-averaging\/ \n category: pytorch blogs","__index_level_0__":239}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Introducing TorchRec, and other domain library updates in PyTorch 1.11\"\nauthor: Team PyTorch\nfeatured-img: \"assets\/images\/pytorch-logo.jpg\"\n---","__index_level_0__":240}
+{"text":"We are introducing the beta release of TorchRec and a number of improvements to the current PyTorch domain libraries, alongside the [PyTorch 1.11 release](https:\/\/pytorch.org\/blog\/pytorch-1.11-released\/). These updates demonstrate our focus on developing common and extensible APIs across all domains to make it easier for our community to build ecosystem projects on PyTorch. Highlights include:","__index_level_0__":241}
+{"text":"- **TorchRec**, a PyTorch domain library for Recommendation Systems, is available in beta. [View it on GitHub](https:\/\/github.com\/pytorch\/torchrec).\n- **TorchAudio** - Added Enformer- and RNN-T-based models and recipes to support the full development lifecycle of a streaming ASR model. See the release notes [here](https:\/\/github.com\/pytorch\/audio\/releases).\n- **TorchText** - Added beta support for RoBERTa and XLM-R models, byte-level BPE tokenizer, and text datasets backed by TorchData. See the release notes [here](https:\/\/github.com\/pytorch\/text\/releases).\n- **TorchVision** - Added 4 new model families and 14 new classification datasets such as CLEVR, GTSRB, FER2013. See the release notes [here](https:\/\/github.com\/pytorch\/vision\/releases).","__index_level_0__":242}
+{"text":"## TorchRec 0.1","__index_level_0__":243}
+{"text":"We [announced TorchRec](https:\/\/pytorch.org\/blog\/introducing-torchrec\/) a few weeks ago and we are excited to release the beta version today. To recap, TorchRec is a PyTorch domain library for Recommendation Systems. This new library provides common sparsity and parallelism primitives, enabling researchers to build state-of-the-art personalization models and deploy them in production. TorchRec was used to train a 1.25 trillion parameter model, pushed to production in January 2022.","__index_level_0__":244}
+{"text":"In particular, the library includes:","__index_level_0__":245}
+{"text":"- Modeling primitives, such as embedding bags and jagged tensors, that enable easy authoring of large, performant multi-device\/multi-node models using hybrid data-parallelism and model-parallelism.\n- Optimized RecSys kernels powered by [FBGEMM](https:\/\/github.com\/pytorch\/FBGEMM), including support for sparse and quantized operations.\n- A sharder which can partition embedding tables with a variety of different strategies including data-parallel, table-wise, row-wise, table-wise-row-wise, and column-wise sharding.\n- A planner which can automatically generate optimized sharding plans for models.\n- Pipelining to overlap dataloading device transfer (copy to GPU), inter-device communications (input_dist), and computation (forward, backward) for increased performance.\n- GPU inference support.\n- Common modules for RecSys, such as models and public datasets (Criteo & Movielens).","__index_level_0__":246}
+{"text":"Please check the TorchRec announcement post [here](https:\/\/pytorch.org\/blog\/introducing-torchrec\/), [video tutorial](https:\/\/www.youtube.com\/watch?v=cjgj41dvSeQ), install instructions [here](https:\/\/github.com\/pytorch\/torchrec#readme), test drive the feature through this tutorial [here](https:\/\/pytorch.org\/tutorials\/intermediate\/torchrec_tutorial.html), and refer to the reference document [here](https:\/\/pytorch.org\/torchrec\/).","__index_level_0__":247}
+{"text":"## TorchAudio 0.11","__index_level_0__":248}
+{"text":"#### TorchAudio: Building Blocks for Audio and Speech Processing","__index_level_0__":249}
+{"text":"We published a paper, [TorchAudio: Building Blocks for Audio and Speech Processing](https:\/\/arxiv.org\/abs\/2110.15018), describing the overview of the TorchAudio library. If you find TorchAudio useful for your research, please help us share with the community by citing our paper.","__index_level_0__":250}
+{"text":"#### (Beta) RNN-T & (Prototype) Emformer Models and Recipes","__index_level_0__":251}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/torchaudio-rnnt-emformer-demo.gif\" width=\"60%\">\n<\/p>","__index_level_0__":252}
+{"text":"Emformer is an efficient memory-transformer-based streaming acoustic model that has demonstrated state-of-the-art streaming automatic speech recognition (ASR) performance in low-latency, resource-constrained scenarios, such as on-device applications (citation: [https:\/\/arxiv.org\/abs\/2010.10759](https:\/\/arxiv.org\/abs\/2010.10759)).","__index_level_0__":253}
+{"text":"The TorchAudio v0.11 release includes the following beta features:","__index_level_0__":254}
+{"text":"- Implementation of Emformer ([docs](https:\/\/pytorch.org\/audio\/main\/models.html#emformer))\n- Recurrent neural network transducer (RNN-T) streaming ASR model that uses Emformer for its transcription network ([docs](https:\/\/pytorch.org\/audio\/main\/models.html#rnn-t))\n- RNN-T beam search decoder with TorchScript support ([docs](https:\/\/pytorch.org\/audio\/main\/models.html#rnntbeamsearch))\n- LibriSpeech Emformer RNN-T training recipe ([GitHub](https:\/\/github.com\/pytorch\/audio\/tree\/release\/0.11\/examples\/asr\/librispeech_emformer_rnnt)) and corresponding pre-trained streaming ASR inference pipeline ([docs](https:\/\/pytorch.org\/audio\/main\/pipelines.html#emformer-rnnt-base-librispeech))","__index_level_0__":255}
+{"text":"Also there are prototype features that are available from nightly builds or the main branch.","__index_level_0__":256}
+{"text":"- Training recipes trained on MuST-C and TED-LIUM3 datasets. ([GitHub](https:\/\/github.com\/pytorch\/audio\/tree\/main\/examples\/asr\/emformer_rnnt))\n- Pre-trained pipelines corresponding to the recipes. ([docs](https:\/\/pytorch.org\/audio\/main\/prototype.pipelines.html))\n- Tutorial that steps through performing online speech recognition with RNN-T Emformer model. ([docs](https:\/\/pytorch.org\/audio\/main\/tutorials\/online_asr_tutorial.html))","__index_level_0__":257}
+{"text":"Collectively, these features cover the full development lifecycle of a streaming ASR model, from definition through training and inference, and enable users to easily develop their own Emformer- and RNN-T-based models.","__index_level_0__":258}
+{"text":"Special thanks to Yangyang Shi, Jay Mahadeokar, and Gil Keren for their code contributions and guidance.","__index_level_0__":259}
+{"text":"#### (Beta) HuBERT Pretrain Model","__index_level_0__":260}
+{"text":"The masked prediction training of HuBERT model requires the masked logits, unmasked logits, and feature norm as the outputs. The logits are for cross-entropy losses and the feature norm is for penalty loss. The release adds [HuBERTPretrainModel](https:\/\/github.com\/pytorch\/audio\/blob\/main\/torchaudio\/models\/wav2vec2\/model.py#L120-L205) and corresponding factory functions ([hubert_pretrain_base](https:\/\/github.com\/pytorch\/audio\/blob\/main\/torchaudio\/models\/wav2vec2\/model.py#L964-L1027), [hubert_pretrain_large](https:\/\/github.com\/pytorch\/audio\/blob\/main\/torchaudio\/models\/wav2vec2\/model.py#L1030-L1090), and [hubert_pretrain_xlarge](https:\/\/github.com\/pytorch\/audio\/blob\/main\/torchaudio\/models\/wav2vec2\/model.py#L1093-L1153)) to enable training from scratch.","__index_level_0__":261}
+{"text":"#### (Prototype) CTC Beam Search Decoder","__index_level_0__":262}
+{"text":"In recent releases, TorchAudio has added support for ASR models fine-tuned on CTC loss. The addition of an inference time CTC beam search decoder enables running end-to-end ASR evaluation using TorchAudio utils.","__index_level_0__":263}
+{"text":"The CTC decoder in TorchAudio supports customizable beam search decoding with lexicon constraint. It also has optional KenLM language model support.","__index_level_0__":264}
+{"text":"For more details, please check out the [API tutorial](https:\/\/pytorch.org\/audio\/main\/tutorials\/asr_inference_with_ctc_decoder_tutorial.html) and [documentation](https:\/\/pytorch.org\/audio\/main\/prototype.ctc_decoder.html). This prototype feature is available through nightly builds.","__index_level_0__":265}
+{"text":"#### (Prototype) Streaming API","__index_level_0__":266}
+{"text":"TorchAudio started as simple audio I\/O APIs that supplement PyTorch. With the recent addition of ASR models and training recipes, the project has received requests to support high-level application development.","__index_level_0__":267}
+{"text":"Streaming API makes it easy to develop and test the model in online inference. It utilizes ffmpeg under the hood, and enables reading media from online services and hardware devices, decoding media in an incremental manner, and applying filters and preprocessing.","__index_level_0__":268}
+{"text":"Please checkout the [API tutorial](https:\/\/pytorch.org\/audio\/main\/tutorials\/streaming_api_tutorial.html) and [the documentation](https:\/\/pytorch.org\/audio\/main\/prototype.io.html). There are also the [streaming ASR](https:\/\/pytorch.org\/audio\/main\/tutorials\/online_asr_tutorial.html) tutorial and the [device streaming ASR tutorial](https:\/\/pytorch.org\/audio\/main\/tutorials\/device_asr.html). This feature is available from nightly releases. Please refer to [pytorch.org](https:\/\/pytorch.org\/get-started\/locally\/) for how to install nightly builds.","__index_level_0__":269}
+{"text":"## TorchText 0.12","__index_level_0__":270}
+{"text":"#### (Beta) RoBERTa and XLM-R Models","__index_level_0__":271}
+{"text":"TorchText has added support for pre-trained RoBERTa and XLM-R models. It would allow users to train end-2-end Transformer Encoder based models on standard NLP tasks using TorchText.","__index_level_0__":272}
+{"text":"More specifically:","__index_level_0__":273}
+{"text":"- The models are torchscriptable and hence can be employed for production use-cases.\n- The model APIs let users to easily attach custom task-specific heads with pre-trained encoders.\n- The API also comes equipped with data pre-processing transforms to match the pre-trained weights and model configuration.","__index_level_0__":274}
+{"text":"We have added a [tutorial](https:\/\/pytorch.org\/text\/main\/tutorials\/sst2_classification_non_distributed.html) to demonstrate SST-2 binary text classification task with pre-trained XLM-R base architecture.","__index_level_0__":275}
+{"text":"For additional details on model APIs and usage examples, please refer to the [documentation](https:\/\/pytorch.org\/text\/main\/models.html).","__index_level_0__":276}
+{"text":"#### (Beta) byte-level BPE tokenizer","__index_level_0__":277}
+{"text":"TorchText has added support for a Byte-Level BPE tokenizer, as used in GPT-2. This tokenizer is also used for tokenizing inputs to the pre-trained RoBERTa models described previously. In addition to the RoBERTa vocab, users can also load their own custom BPE vocab to use the tokenizer. Furthermore, the tokenizer is fully torchscriptable and hence can be employed for production use-cases. For additional details on model APIs and usage examples, please refer to the [documentation](https:\/\/pytorch.org\/text\/main\/transforms.html#gpt2bpetokenizer).","__index_level_0__":278}
+{"text":"#### (Beta) Text datasets backed by TorchData","__index_level_0__":279}
+{"text":"TorchText has modernized its datasets by migrating from older-style Iterable Datasets to [TorchData\u2019s](https:\/\/github.com\/pytorch\/data#readme) DataPipes. TorchData is a library that provides modular\/composable primitives, allowing users to load and transform data in performant data pipelines.","__index_level_0__":280}
+{"text":"These DataPipes work out-of-the-box with PyTorch DataLoader and would enable new functionalities like auto-sharding. Users can now easily do data manipulation and pre-processing using user-defined functions and transformations in a functional style programming. Datasets backed by DataPipes also enable standard flow-control like batching, collation, shuffling and bucketizing.","__index_level_0__":281}
+{"text":"Collectively, DataPipes provides a comprehensive experience for data preprocessing and tensorization needs in a pythonic and flexible way for model training. We have added a [tutorial](https:\/\/pytorch.org\/text\/main\/tutorials\/sst2_classification_non_distributed.html) to demonstrate data-processing pipelining using the modernized dataset for binary text-classification.","__index_level_0__":282}
+{"text":"You can learn more about TorchData DataPipe APIs in its [official documentation](https:\/\/pytorch.org\/data).","__index_level_0__":283}
+{"text":"## TorchVision 0.12","__index_level_0__":284}
+{"text":"### New Models","__index_level_0__":285}
+{"text":"Four new model families have been released in the latest version along with pre-trained weights for their variants.","__index_level_0__":286}
+{"text":"#### #1 Object Detection","__index_level_0__":287}
+{"text":"[FCOS](https:\/\/arxiv.org\/pdf\/1904.01355.pdf) is a popular, fully convolutional, anchor-free model for object detection. In this release we include a community-contributed model implementation as well as pre-trained weights. The model was trained on COCO train2017 and can be used as follows:","__index_level_0__":288}
+{"text":"```python\nimport torch\nfrom torchvision import models","__index_level_0__":289}
+{"text":"x = [torch.rand(3, 224, 224)]\nfcos = models.detection.fcos_resnet50_fpn(pretrained=True).eval()\npredictions =  fcos(x)\n```","__index_level_0__":290}
+{"text":"The box AP of the pre-trained model on COCO val2017 is 39.2 (see [#4961](https:\/\/github.com\/pytorch\/vision\/pull\/4961) for more details).","__index_level_0__":291}
+{"text":"We would like to thank [Hu Ye](https:\/\/github.com\/xiaohu2015) and [Zhiqiang Wang](https:\/\/github.com\/zhiqwang) for contributing to the model implementation and initial training. This was the first community-contributed model in a long while, and given its success, we decided to use the learnings from this process and create a new [model contribution guidelines](https:\/\/github.com\/pytorch\/vision\/blob\/main\/CONTRIBUTING_MODELS.md).","__index_level_0__":292}
+{"text":"#### #2 Optical Flow support and RAFT model","__index_level_0__":293}
+{"text":"TorchVision now supports optical flow! Optical Flow models try to predict movement in a video: given two consecutive frames, the model predicts where each pixel of the first frame ends up in the second frame. Check out our [new tutorial on Optical Flow](https:\/\/pytorch.org\/vision\/0.12\/auto_examples\/plot_optical_flow.html#sphx-glr-auto-examples-plot-optical-flow-py)!","__index_level_0__":294}
+{"text":"We implemented a torchscript-compatible [RAFT](https:\/\/arxiv.org\/abs\/2003.12039) model with pre-trained weights (both normal and \u201csmall\u201d versions), and added support for [training and evaluating](https:\/\/github.com\/pytorch\/vision\/tree\/main\/references\/optical_flow) optical flow models. Our training scripts support distributed training across processes and nodes, leading to much faster training time than the original implementation. We also added 5 new [optical flow datasets](https:\/\/pytorch.org\/vision\/0.12\/datasets.html#optical-flow): Flying Chairs, Flying Things, Sintel, Kitti, and HD1K.","__index_level_0__":295}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/image-classification.png\" width=\"60%\">\n<\/p>","__index_level_0__":296}
+{"text":"#### #3. Image Classification","__index_level_0__":297}
+{"text":"[Vision Transformer](https:\/\/arxiv.org\/abs\/2010.11929) (ViT) and [ConvNeXt](https:\/\/arxiv.org\/abs\/2201.03545) are two popular architectures which can be used as image classifiers or as backbones for downstream vision tasks. In this release we include 8 pre-trained weights for their classification variants. The models were trained on ImageNet and can be used as follows:","__index_level_0__":298}
+{"text":"```python\nimport torch\nfrom torchvision import models","__index_level_0__":299}
+{"text":"x = torch.rand(1, 3, 224, 224)\nvit = models.vit_b_16(pretrained=True).eval()\nconvnext = models.convnext_tiny(pretrained=True).eval()\npredictions1 = vit(x)\npredictions2 = convnext(x)\n```","__index_level_0__":300}
+{"text":"The accuracies of the pre-trained models obtained on ImageNet val are seen below:","__index_level_0__":301}
+{"text":"| **Model**      | **Acc@1** | **Acc@5** |\n| -------------- | --------: | --------: |\n| vit_b_16       |    81.072 |    95.318 |\n| vit_b_32       |    75.912 |    92.466 |\n| vit_l_16       |    79.662 |    94.638 |\n| vit_l_32       |    76.972 |     93.07 |\n| convnext_tiny  |     82.52 |    96.146 |\n| convnext_small |    83.616 |     96.65 |\n| convnext_base  |    84.062 |     96.87 |\n| convnext_large |    84.414 |    96.976 |","__index_level_0__":302}
+{"text":"The above models have been trained using an adjusted version of our new [training recipe](https:\/\/pytorch.org\/blog\/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives\/) and this allows us to offer models with accuracies significantly higher than the ones on the original papers.","__index_level_0__":303}
+{"text":"#### #4. GPU Video Decoding","__index_level_0__":304}
+{"text":"In this release, we add support for GPU video decoding in the video reading API. To use hardware-accelerated decoding, we just need to pass a cuda device to the video reading API as shown below:","__index_level_0__":305}
+{"text":"```python\nimport torchvision","__index_level_0__":306}
+{"text":"reader = torchvision.io.VideoReader(file_name, device=\"cuda:0\")\nfor frame in reader:\n    print(frame)\n```","__index_level_0__":307}
+{"text":"We also support seeking to anyframe or a keyframe in the video before reading, as shown below:","__index_level_0__":308}
+{"text":"```python\nreader.seek(seek_time)\n```","__index_level_0__":309}
+{"text":"### New Datasets","__index_level_0__":310}
+{"text":"We have implemented 14 new [classification datasets](https:\/\/pytorch.org\/vision\/0.12\/datasets.html#image-classification): CLEVR, GTSRB, FER2013, SUN397, Country211, Flowers102, fvgc_aircraft, OxfordIIITPet, DTD, Food 101, Rendered SST2, Stanford cars, PCAM, and EuroSAT.","__index_level_0__":311}
+{"text":"As part of our work on Optical Flow support (see above for more details), we also added 5 new [optical flow datasets](https:\/\/pytorch.org\/vision\/0.12\/datasets.html#optical-flow): Flying Chairs, Flying Things, Sintel, Kitti, and HD1K.","__index_level_0__":312}
+{"text":"### Other Updates","__index_level_0__":313}
+{"text":"- **New documentation layout**: Each function \/ class is now documented in a separate page, clearing up some space in the per-module pages, and easing the discovery of the proposed APIs. Compare e.g. our [previous docs](https:\/\/pytorch.org\/vision\/0.11\/transforms.html) vs the [new ones](https:\/\/pytorch.org\/vision\/0.12\/transforms.html). Please let us know if you have any [feedback](https:\/\/github.com\/pytorch\/vision\/issues\/5511)!\n- **New [model contribution guidelines](https:\/\/github.com\/pytorch\/vision\/blob\/main\/CONTRIBUTING_MODELS.md)** have been published following the success of the [FCOS](https:\/\/github.com\/pytorch\/vision\/pull\/4961) model which was contributed by the community. These guidelines aim to be an overview of the model contribution process for anyone who would like to suggest, implement and train a new model.\n- **Upcoming Prototype API** - We are currently working on a prototype API which adds Multi-weight support on all of our model builder methods. This will enable us to offer multiple pre-trained weights, associated with their meta-data and inference transforms. The API is still under review and thus was not included in the release but you can read more about it on our [blogpost](https:\/\/pytorch.org\/blog\/introducing-torchvision-new-multi-weight-support-api\/) and provide your feedback on the dedicated [Github issue](https:\/\/github.com\/pytorch\/vision\/issues\/5088).\n- **Changes in our deprecation policy** - Up until now, torchvision would almost never remove deprecated APIs. In order to be more aligned and consistent with pytorch core, we are updating our deprecation policy. We are now following a 2-release deprecation cycle: deprecated APIs will raise a warning for 2 versions, and will be removed after that. To reflect these changes and to smooth the transition, we have decided to:\n  - Remove all APIs that had been deprecated before or on v0.8, released 1.5 years ago.\n  - Update the removal timeline of all other deprecated APIs to v0.14, to reflect the new 2-cycle policy starting now in v0.12.","__index_level_0__":314}
+{"text":"### Captum 0.5","__index_level_0__":315}
+{"text":"[Captum](https:\/\/captum.ai\/) is a PyTorch library for model interpretability. For this release, we expanded Captum with influential instances and added support for both similarity based influences and novel algorithms, [TracIn](https:\/\/arxiv.org\/abs\/2002.08484) and its variants. TracIn variants offer faster approximation of influence scores based on random projections for fully connected layers.","__index_level_0__":316}
+{"text":"More specifically the new, influence, subsection of Captum includes:","__index_level_0__":317}
+{"text":"- **[SimilarityInfluence](https:\/\/captum.ai\/api\/influence.html#similarityinfluence)** computes similarity scores between test and training examples using default (cosine or euclidean) or custom user definite metrics w.r.t. given input model layers.\n- **[TracInCP](https:\/\/captum.ai\/api\/influence.html#tracincp)** approximates the influential score of each training example on a given test example based on the dot-product similarity between loss gradients w.r.t. model parameters for test and training examples. Note that if we use training examples as test examples then we compute self influence. This method and its variants described below also return top-k proponents and opponents which are the top-k largest positive and negative influential examples respectively.\n- **[TracInCPFast](https:\/\/captum.ai\/api\/influence.html#tracincpfast)** is an approximation of TracInCP that avoids computing the gradients w.r.t. large parameter matrices. It approximates influence score based on the dot products between last fully connected layer activations and loss gradients w.r.t. that layer for training and test examples.\n- **[TracInCPFastRandProj](https:\/\/captum.ai\/api\/influence.html#tracincpfastrandproj)** uses a nearest neighbor approximation library such as annoy to compute the dot product between the training and test quantities. In order to reduce the dimensionality of layer activations and corresponding gradients this method, in addition, allows to project those vectors into a lower dimensional space using random projection matrices.","__index_level_0__":318}
+{"text":"More about the implementation of influential instances can be found on our [GitHub](https:\/\/github.com\/pytorch\/captum\/tree\/master\/captum\/influence) page and [tutorials](https:\/\/captum.ai\/tutorials\/TracInCP_Tutorial).","__index_level_0__":319}
+{"text":"Thanks for reading, If you\u2019re interested in these updates and want to join the PyTorch community, we encourage you to join the [discussion forums](https:\/\/discuss.pytorch.org\/) and [open GitHub issues](https:\/\/github.com\/pytorch\/pytorch\/issues). To get the latest news from PyTorch, follow us on [Twitter](https:\/\/twitter.com\/PyTorch), [Medium](https:\/\/medium.com\/pytorch), [YouTube](https:\/\/www.youtube.com\/pytorch), and [LinkedIn](https:\/\/www.linkedin.com\/company\/pytorch).","__index_level_0__":320}
+{"text":"Team PyTorch","__index_level_0__":322}
+{"text":"<div class=\"pytorch-content-right\">\n    <div class=\"pytorch-right-menu\">\n        <div class=\"pytorch-side-scroll\">\n            <ul>\n                <li>\n                    <a class=\"reference internal title-link has-children\" href=\"#torchrec-01\">TorchRec 0.1<\/a>\n                <\/li>\n                <li>\n                    <a class=\"reference internal title-link has-children\" href=\"#torchaudio-011\">TorchAudio 0.11<\/a>\n                          <\/li>\n                <li>\n                    <a class=\"reference internal title-link has-children\" href=\"#torchtext-012\">TorchText 0.12<\/a>\n                               <\/li>\n\t\t\t\t<li>\n                    <a class=\"reference internal title-link has-children\" href=\"#torchvision-012\">TorchVision 0.12<\/a>                  \n                <\/li>\n            <\/ul>\n        <\/div>\n    <\/div>\n<\/div>\n<style>\n    article.pytorch-article {\n        position: relative;\n    }\n    .pytorch-content-right {\n        position: absolute;\n        top: 1.8%;\n        right: -27%;\n    }\n    article.pytorch-article .pytorch-content-right ul {\n        padding-left: 1rem;\n        list-style-type: none;\n        margin: 0;\n    }\n    article.pytorch-article .pytorch-content-right ul li {\n        margin-bottom: 0;\n    }\n    article.pytorch-article .pytorch-content-right ul>li>a {\n        color: #262626;\n        font-weight: 500;\n        font-size: 0.825rem;\n    }\n    article.pytorch-article .pytorch-content-right ul>li>ul>li>a {\n        color: #6c6c6d;\n        font-weight: 400;\n    }\n<\/style>\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.11-new-library-releases\/ \n category: pytorch blogs","__index_level_0__":323}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch 2.0 & XLA\u2014The Latest Cutting Edge Features\"\nauthor: Jack Cao, Milad Mohammadi, Alex Wertheim, Yeounoh Chung, Joe Spisak, Will Cromar, Shauheen Zahirazami\n---","__index_level_0__":324}
+{"text":"Today, we are excited to share our latest work for [PyTorch\/XLA 2.0](https:\/\/github.com\/pytorch\/xla\/releases\/tag\/v2.0.0). The release of [PyTorch 2.0](https:\/\/pytorch.org\/get-started\/pytorch-2.0\/) is yet another major milestone for this storied community and we are excited to continue to be part of it. When the [PyTorch\/XLA](https:\/\/github.com\/pytorch\/xla) project started in 2018 between Google and Meta, the focus was on bringing cutting edge Cloud TPUs to help support the PyTorch community. Along the way, others in the community such as Amazon joined the project and very quickly the community expanded. We are excited about XLA's [direction](https:\/\/opensource.googleblog.com\/2023\/03\/openxla-is-ready-to-accelerate-and-simplify-ml-development.html) and the benefits this project continues to bring to the PyTorch community. In this blog we\u2019d like to showcase some key features that have been in development, show code snippets, and illustrate the benefit through some benchmarks. ","__index_level_0__":325}
+{"text":"\n## TorchDynamo \/ torch.compile (Experimental)","__index_level_0__":326}
+{"text":"[TorchDynamo](https:\/\/github.com\/pytorch\/torchdynamo) (Dynamo) is a Python-level JIT compiler designed to make unmodified PyTorch programs faster. It provides a clean API for compiler backends to hook in; its biggest feature is to dynamically modify Python bytecode just before execution. In the PyTorch\/XLA 2.0 release, an experimental backend for Dynamo is provided for both inference and training. ","__index_level_0__":327}
+{"text":"Dynamo provides a [Torch FX](https:\/\/pytorch.org\/docs\/stable\/fx.html) (FX) graph when it recognizes a model pattern and PyTorch\/XLA uses a Lazy Tensor approach to compile the FX graph and return the compiled function. To get more insight regarding the technical details about PyTorch\/XLA\u2019s dynamo implementation, check out [this](https:\/\/dev-discuss.pytorch.org\/t\/torchdynamo-update-10-integrating-with-pytorch-xla-for-inference-and-training\/935) dev-discuss post and [dynamo doc](https:\/\/github.com\/pytorch\/xla\/blob\/r2.0\/docs\/dynamo.md).","__index_level_0__":328}
+{"text":"Here is a small code example of running ResNet18 with `torch.compile`:","__index_level_0__":329}
+{"text":"```\nimport torch\nimport torchvision\nimport torch_xla.core.xla_model as xm","__index_level_0__":330}
+{"text":"def eval_model(loader):\n  device = xm.xla_device()\n  xla_resnet18 = torchvision.models.resnet18().to(device)\n  xla_resnet18.eval()\n  dynamo_resnet18 = torch.compile(\n      xla_resnet18, backend='torchxla_trace_once')\n  for data, _ in loader:\n    output = dynamo_resnet18(data)\n```","__index_level_0__":331}
+{"text":"With `torch.compile` PyTorch\/XLA only traces the ResNet18 model once during the init time and executes the compiled binary everytime `dynamo_resnet18` is invoked, instead of tracing the model every step. To illustrate the benefits of Dynamo+XLA, below is an inference speedup analysis to compare Dynamo and LazyTensor (without Dynamo) using TorchBench on a Cloud TPU v4-8 where the y-axis is the speedup multiplier.","__index_level_0__":332}
+{"text":"\n![Inference Speedup - PyTorch\/XLA Dynamo on TPU](\/assets\/images\/2023-03-22-inferencespeedup.svg){:width=\"100%\"}","__index_level_0__":333}
+{"text":"\nDynamo for training is in the development stage with its implementation being at an earlier stage than inference. Developers are welcome to test this early feature, however, in the 2.0 release, PyTorch\/XLA supports the forward and backward pass graphs and not the optimizer graph; the optimizer graph is available in the nightly builds and will land in the PyTorch\/XLA 2.1 release. Below is an example of what training looks like using the ResNet18 example with `torch.compile`:","__index_level_0__":334}
+{"text":"```\nimport torch\nimport torchvision\nimport torch_xla.core.xla_model as xm","__index_level_0__":335}
+{"text":"def train_model(model, data, target):\n  loss_fn = torch.nn.CrossEntropyLoss()\n  pred = model(data)\n  loss = loss_fn(pred, target)\n  loss.backward()\n  return pred","__index_level_0__":336}
+{"text":"def train_model_main(loader):\n  device = xm.xla_device()\n  xla_resnet18 = torchvision.models.resnet18().to(device)\n  xla_resnet18.train()\n  dynamo_train_model = torch.compile(\n        train_model, backend='aot_torchxla_trace_once')\n  for data, target in loader:\n    output = dynamo_train_model(xla_resnet18, data, target)\n```","__index_level_0__":337}
+{"text":"Note that the backend for training is `aot_torchxla_trace_once` (API will be updated for stable release) whereas the inference backend is `torchxla_trace_once` (name subject to change). We expect to extract and execute 3 graphs per training step instead of 1 training step if you use the Lazy tensor. Below is a training speedup analysis to compare Dynamo and Lazy using the TorchBench on Cloud TPU v4-8.","__index_level_0__":338}
+{"text":"\n![Training Speedup - PyTorch\/XLA Dynamo on TPU](\/assets\/images\/2023-03-22-trainingspeedup.svg){:width=\"100%\"}","__index_level_0__":339}
+{"text":"## PJRT Runtime (Beta)","__index_level_0__":341}
+{"text":"PyTorch\/XLA is migrating from XRT to the new PJRT runtime. PJRT is a better-maintained stack, with demonstrated performance advantages, including, on average, a 35% performance for training on TorchBench 2.0 models. It also supports a richer set of features enabling technologies like SPMD. In the PyTorch\/XLA 2.0 release, PJRT is the default runtime for TPU and CPU; GPU support is in experimental state. The PJRT features included in the PyTorch\/XLA 2.0 release are:","__index_level_0__":342}
+{"text":"* TPU runtime implementation in `libtpu` using the [PJRT Plugin API](https:\/\/github.com\/openxla\/community\/blob\/main\/rfcs\/20230123-pjrt-plugin.md#rfc-openxla-pjrt-plugin) improves performance by up to 30%\n* `torch.distributed` support for TPU v2 and v3, including `pjrt:\/\/` `init_method` (Experimental)\n* Single-host GPU support. Multi-host support coming soon. (Experimental)","__index_level_0__":343}
+{"text":"Switching to PJRT requires no change (or minimal change for GPUs) to user code (see [pjrt.md](https:\/\/github.com\/pytorch\/xla\/blob\/master\/docs\/pjrt.md) for more details). Runtime configuration is as simple as setting the `PJRT_DEVICE` environment variable to the local device type (i.e. `TPU`, `GPU`, `CPU`). Below are examples of using PJRT runtimes on different devices. ","__index_level_0__":344}
+{"text":"```\n# TPU Device\nPJRT_DEVICE=TPU python3 xla\/test\/test_train_mp_imagenet.py --fake_data --batch_size=256 --num_epochs=1\n```","__index_level_0__":345}
+{"text":"```\n# TPU Pod Device\ngcloud alpha compute tpus tpu-vm ssh $USER-pjrt --zone=us-central2-b --project=$PROJECT --worker=all --command=\"git clone --depth=1 --branch r2.0 https:\/\/github.com\/pytorch\/xla.git\"","__index_level_0__":346}
+{"text":"gcloud alpha compute tpus tpu-vm ssh $USER-pjrt --zone=us-central2-b --project=$PROJECT --worker=all --command=\"PJRT_DEVICE=TPU python3 xla\/test\/test_train_mp_imagenet.py --fake_data --batch_size=256 --num_epochs=1\"\n```","__index_level_0__":347}
+{"text":"```\n# GPU Device (Experimental)\nPJRT_DEVICE=GPU GPU_NUM_DEVICES=4 python3 xla\/test\/test_train_mp_imagenet.py --fake_data --batch_size=128 --num_epochs=1\n```","__index_level_0__":348}
+{"text":"Below is a performance comparison between XRT and PJRT by task on TorchBench 2.0 on v4-8 TPU. To learn more about PJRT vs. XRT please review the [documentation](https:\/\/github.com\/pytorch\/xla\/blob\/r2.0\/docs\/pjrt.md#tpu).","__index_level_0__":349}
+{"text":"\n![TorchBench Training Time](\/assets\/images\/2023-03-22-torchbenchtraining.svg){:width=\"100%\"}","__index_level_0__":350}
+{"text":"## Parallelization","__index_level_0__":352}
+{"text":"\n### GSPMD (Experimental)","__index_level_0__":353}
+{"text":"We are delighted to introduce General and Scalable Parallelization for ML Computation Graphs ([GSPMD](https:\/\/arxiv.org\/abs\/2105.04663)) in PyTorch as a new experimental data & model sharding solution. [GSPMD](https:\/\/arxiv.org\/abs\/2105.04663) provides automatic parallelization for common ML workloads, allowing developers to write PyTorch programs as if on a single large device and without custom sharded computation ops and\/or collective communication ops. The XLA compiler transforms the single device program into a partitioned one with proper collectives, based on the user provided sharding hints. The API ([RFC](https:\/\/github.com\/pytorch\/xla\/issues\/3871)) will be available in the PyTorch\/XLA 2.0 release as an experimental feature on a single TPU VM host. ","__index_level_0__":354}
+{"text":"\n#### Next Steps for GSPMD","__index_level_0__":355}
+{"text":"GSPMD is experimental in 2.0 release. To bring it to Stable status, we plan to address a number of feature gaps and known issues in the following releases, including multi-host support, DTensor integration, partial replication sharding, asynchronous data loading, and checkpointing. ","__index_level_0__":356}
+{"text":"\n### FSDP (Beta)","__index_level_0__":357}
+{"text":"PyTorch\/XLA [introduced](https:\/\/pytorch.org\/blog\/scaling-pytorch-models-on-cloud-tpus-with-fsdp\/) fully sharded data parallel (FSDP) experimental support in version 1.12. This feature is a parallel representation of PyTorch FSDP and there are subtle differences in how XLA and upstream CUDA kernels are set up. `auto_wrap_policy` is a new argument that enables developers to automatically specify conditions for propagating partitioning specifications to neural network submodules. `auto_wrap_policy`s may be simply passed in as an argument when wrapping a model with FSDP. Two `auto_wrap_policy` callables worth noting are: `size_based_auto_wrap_policy`, `transformer_auto_wrap_policy`.","__index_level_0__":358}
+{"text":"`size_based_auto_wrap_policy` enables users to wrap submodules with a minimum number of parameters. The example below wraps model submodules having at least 10M parameters.","__index_level_0__":359}
+{"text":"```\nauto_wrap_policy = partial(size_based_auto_wrap_policy, min_num_params=1e7)\n```","__index_level_0__":360}
+{"text":"`transformer_auto_wrap_policy` enables users to wrap all submodules that match a specific layer type. The example below wraps model submodules named `torch.nn.Conv2d`. To learn more, review [this ResNet example](https:\/\/github.com\/pytorch\/xla\/blob\/master\/test\/test_train_mp_imagenet_fsdp.py#L237-L255) by Ronghang Hu.","__index_level_0__":361}
+{"text":"```\nauto_wrap_policy = partial(transformer_auto_wrap_policy, transformer_layer_cls={torch.nn.Conv2d})\n```","__index_level_0__":362}
+{"text":"PyTorch\/XLA FSDP is now integrated in HuggingFace trainer class ([PR](https:\/\/github.com\/huggingface\/transformers\/pull\/21406)) enabling users to train much larger models on PyTorch\/XLA ([official Hugging Face documentation](https:\/\/huggingface.co\/docs\/transformers\/main\/en\/main_classes\/trainer#pytorchxla-fully-sharded-data-parallel)). A 16B parameters GPT2 model trained on Cloud TPU v4-64 with this FSDP configuration achieved 39% hardware utilization.","__index_level_0__":363}
+{"text":"\n<table class=\"table table-bordered\" style=\"max-width: 450px;\">\n  <tr>\n   <td><strong>TPU Accelerator - Num Devices<\/strong>\n   <\/td>\n   <td>v4-64\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>GPT2 Parameter Count<\/strong>\n   <\/td>\n   <td>16B\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Layers Wrapped with FSDP<\/strong>\n   <\/td>\n   <td>GPT2Block\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>TFLOPs \/ Chip<\/strong>\n   <\/td>\n   <td>275\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>PFLOPs \/ Step<\/strong>\n   <\/td>\n   <td>50\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Hardware Utilization<\/strong>\n   <\/td>\n   <td>39%\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":364}
+{"text":"### Differences Between FSDP & GSPMD","__index_level_0__":366}
+{"text":"FSDP is a data parallelism technique that reduces device memory footprint by storing model parameters, optimizer states, and gradients all sharded. Note that the actual computation is still local to the device and requires all-gathering the sharded model parameters for both forward and backward passes, hence the name \u201cdata parallel\u201d. FSDP is one of the newest additions to PyTorch\/XLA to scale large model training.","__index_level_0__":367}
+{"text":"GSPMD on the other hand, is a general parallelization system that enables various types of parallelisms, including both data and model parallelisms. PyTorch\/XLA provides a sharding annotation API and XLAShardedTensor abstraction, so a user can annotate any tensor with sharding specs in the PyTorch program. Developers don\u2019t need to manually implement sharded computations or inject collective communications ops to get it right. The XLA compiler does the work so that each computation can run in a distributed manner on multiple devices.","__index_level_0__":368}
+{"text":"\n### Examples & Preliminary Results","__index_level_0__":369}
+{"text":"To learn about PyTorch\/XLA parallelism sharding API, visit our [RFC](https:\/\/github.com\/pytorch\/xla\/issues\/3871) and see the [Sample Code](https:\/\/github.com\/pytorch\/xla\/tree\/r2.0\/test\/spmd) references. Below is a simple example to enable data and model parallelism.","__index_level_0__":370}
+{"text":"```\nmodel = SimpleLinear().to(xm.xla_device())\n# Sharding annotate the linear layer weights.\nxs.mark_sharding(model.fc1.weight, mesh, partition_spec)\n# Training loop\nmodel.train()\nfor step, (data, target) in enumerate(loader):\n  optimizer.zero_grad()\n  data = data.to(xm.xla_device())\n  target = target.to(xm.xla_device())\n  # Sharding annotate input data, we can shard any input\n  # dimensions. Sharidng the batch dimension enables \n  # data parallelism, sharding the feature dimension enables\n  # spatial partitioning.\n  xs.mark_sharding(data, mesh, partition_spec)\n  ouput = model(data)\n  loss = loss_fn(output, target)\n  optimizer.step()\n  xm.mark_step()\n```","__index_level_0__":371}
+{"text":"The following graph highlights the memory efficiency benefits of PyTorch\/XLA FSDP and SPMD on Cloud TPU v4-8 running ResNet50.","__index_level_0__":372}
+{"text":"\n![Batch Size Scaling with Spatial Partitioning](\/assets\/images\/2023-03-22-batchsizescaling.svg){:width=\"100%\"}","__index_level_0__":373}
+{"text":"## Closing Thoughts\u2026","__index_level_0__":375}
+{"text":"We are excited to bring these features to the PyTorch community, and this is really just the beginning. Areas like dynamic shapes, deeper support for OpenXLA and many others are in development and we plan to put out more blogs to dive into the details. PyTorch\/XLA is developed fully open source and we invite you to join the community of developers by filing issues, submitting pull requests, and sending RFCs on [GitHub](github.com\/pytorch\/xla). You can try PyTorch\/XLA on a variety of XLA devices including TPUs and GPUs. [Here](https:\/\/colab.sandbox.google.com\/github\/pytorch\/xla\/blob\/master\/contrib\/colab\/getting-started.ipynb) is how to get started.","__index_level_0__":376}
+{"text":"Congratulations again to the PyTorch community on this milestone!","__index_level_0__":377}
+{"text":"The PyTorch Team at Google \n source: https:\/\/pytorch.org\/blog\/pytorch-2.0-xla\/ \n category: pytorch blogs","__index_level_0__":379}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Compromised PyTorch-nightly dependency chain between December 25th and December 30th, 2022.\"\nauthor:  The PyTorch Team\n---","__index_level_0__":380}
+{"text":"If you installed PyTorch-nightly on Linux via pip between December 25, 2022 and December 30, 2022, please uninstall it and torchtriton immediately, and use the latest nightly binaries (newer than Dec 30th 2022).","__index_level_0__":381}
+{"text":"```bash\n$ pip3 uninstall -y torch torchvision torchaudio torchtriton\n$ pip3 cache purge\n```","__index_level_0__":382}
+{"text":"PyTorch-nightly Linux packages installed via pip during that time installed a dependency, torchtriton, which was compromised on the Python Package Index (PyPI) code repository and ran a malicious binary. This is what is known as a supply chain attack and directly affects dependencies for packages that are hosted on public package indices.","__index_level_0__":383}
+{"text":"**NOTE:** Users of the PyTorch **stable** packages **are not** affected by this issue.","__index_level_0__":384}
+{"text":"\n## How to check if your Python environment is affected","__index_level_0__":385}
+{"text":"The following command searches for the malicious binary in the torchtriton package (`PYTHON_SITE_PACKAGES\/triton\/runtime\/triton`) and prints out whether your current Python environment is affected or not.","__index_level_0__":386}
+{"text":"```bash\npython3 -c \"import pathlib;import importlib.util;s=importlib.util.find_spec('triton'); affected=any(x.name == 'triton' for x in (pathlib.Path(s.submodule_search_locations[0] if s is not None else '\/' ) \/ 'runtime').glob('*'));print('You are {}affected'.format('' if affected else 'not '))\"\n```","__index_level_0__":387}
+{"text":"The malicious binary is executed when the triton package is imported, which requires explicit code to do and is not PyTorch\u2019s default behavior.","__index_level_0__":388}
+{"text":"## The Background","__index_level_0__":389}
+{"text":"At around 4:40pm GMT on December 30 (Friday), we learned about a malicious dependency package (`torchtriton`) that was uploaded to the Python Package Index (PyPI) code repository with the same package name as the one we ship on the [PyTorch nightly package index](https:\/\/download.pytorch.org\/whl\/nightly). Since the [PyPI index takes precedence](https:\/\/github.com\/pypa\/pip\/issues\/8606), this malicious package was being installed instead of the version from our official repository. This design enables somebody to register a package by the same name as one that exists in a third party index, and pip will install their version by default.","__index_level_0__":390}
+{"text":"This malicious package has the same name `torchtriton` but added in code that uploads sensitive data from the machine.","__index_level_0__":391}
+{"text":"\n## What we know","__index_level_0__":392}
+{"text":"torchtriton on PyPI contains a malicious triton binary which is installed at `PYTHON_SITE_PACKAGES\/triton\/runtime\/triton`. Its SHA256 hash is listed below.","__index_level_0__":393}
+{"text":"`SHA256(triton)= 2385b29489cd9e35f92c072780f903ae2e517ed422eae67246ae50a5cc738a0e`","__index_level_0__":394}
+{"text":"The binary\u2019s main function does the following:","__index_level_0__":395}
+{"text":"- Get system information\n  - nameservers from `\/etc\/resolv.conf`\n  - hostname from `gethostname()`\n  - current username from `getlogin()`\n  - current working directory name from `getcwd()`\n  - environment variables\n- Read the following files\n  - `\/etc\/hosts`\n  - `\/etc\/passwd`\n  - The first 1,000 files in `$HOME\/*`\n  - `$HOME\/.gitconfig`\n  - `$HOME\/.ssh\/*`\n- Upload all of this information, including file contents, via encrypted DNS queries to the domain *.h4ck[.]cfd, using the DNS server wheezy[.]io","__index_level_0__":396}
+{"text":"The binary\u2019s file upload functionality is limited to files less than 99,999 bytes in size. It also uploads only the first 1,000 files in $HOME (but all files < 99,999 bytes in the .ssh directory).","__index_level_0__":397}
+{"text":"## Steps taken towards mitigation","__index_level_0__":398}
+{"text":"- torchtriton has been removed as a dependency for our nightly packages and replaced with pytorch-triton ([pytorch\/pytorch#91539](https:\/\/github.com\/pytorch\/pytorch\/pull\/91539)) and a dummy package registered on PyPI (so that this issue doesn\u2019t repeat)\n- All nightly packages that depend on torchtriton have been removed from our package indices at https:\/\/download.pytorch.org until further notice\n- We have reached out to the PyPI security team to get proper ownership of the `torchtriton` package on PyPI and to delete the malicious version","__index_level_0__":399}
+{"text":" \n source: https:\/\/pytorch.org\/blog\/compromised-nightly-dependency\/ \n category: pytorch blogs","__index_level_0__":401}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Running PyTorch Models on Jetson Nano'\nauthor: Jeff Tang, Hamid Shojanazeri, Geeta Chauhan\nfeatured-img: 'assets\/images\/pytorch-logo.jpg'\n---","__index_level_0__":402}
+{"text":"### Overview\nNVIDIA [Jetson Nano](https:\/\/developer.nvidia.com\/embedded\/jetson-nano-developer-kit), part of the [Jetson family of products](https:\/\/developer.nvidia.com\/embedded\/jetson-modules) or Jetson modules, is a small yet powerful Linux (Ubuntu) based embedded computer with 2\/4GB GPU. With it, you can run many PyTorch models efficiently. This document summarizes our experience of running different deep learning models using 3 different mechanisms on Jetson Nano:","__index_level_0__":403}
+{"text":"  1. Jetson Inference the higher-level NVIDIA API that has built-in support for running most common computer vision models which can be transfer-learned with PyTorch on the Jetson platform.","__index_level_0__":404}
+{"text":"  2. TensorRT, an SDK for high-performance inference from NVIDIA that requires the conversion of a PyTorch model to ONNX, and then to the TensorRT engine file that the TensorRT runtime can run.","__index_level_0__":405}
+{"text":"  3. PyTorch with the direct PyTorch API `torch.nn` for inference.","__index_level_0__":406}
+{"text":"### Setting up Jetson Nano\nAfter purchasing a Jetson Nano [here](https:\/\/developer.nvidia.com\/buy-jetson?product=jetson_nano&location=US), simply follow the clear step-by-step [instructions](https:\/\/developer.nvidia.com\/embedded\/learn\/get-started-jetson-nano-devkit) to download and write the Jetson Nano Developer Kit SD Card Image to a microSD card, and complete the setup. After the setup is done and the Nano is booted, you\u2019ll see the standard Linux prompt along with the username and the Nano name used in the setup.","__index_level_0__":407}
+{"text":"To check the GPU status on Nano, run the following commands:","__index_level_0__":408}
+{"text":"```\nsudo pip3 install jetson-stats\nsudo jtop\n```","__index_level_0__":409}
+{"text":"You\u2019ll see information, including:","__index_level_0__":410}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/blog-2022-3-10-setting-up-jetson-nano.png\" width=\"60%\">\n<\/div>","__index_level_0__":411}
+{"text":"You can also see the installed CUDA version:","__index_level_0__":412}
+{"text":"```\n$ ls -lt \/usr\/local\nlrwxrwxrwx  1 root root   22 Aug  2 01:47 cuda -> \/etc\/alternatives\/cuda\nlrwxrwxrwx  1 root root   25 Aug  2 01:47 cuda-10 -> \/etc\/alternatives\/cuda-10\ndrwxr-xr-x 12 root root 4096 Aug  2 01:47 cuda-10.2\n```","__index_level_0__":413}
+{"text":"To use a camera on Jetson Nano, for example, Arducam 8MP IMX219, follow the instructions [here](https:\/\/www.arducam.com\/docs\/camera-for-jetson-nano\/mipi-camera-modules-for-jetson-nano\/driver-installation\/) or run the commands below after [installing a camera module](https:\/\/developer.nvidia.com\/embedded\/learn\/jetson-nano-2gb-devkit-user-guide#id-.JetsonNano2GBDeveloperKitUserGuidevbatuu_v1.0-Camera):","__index_level_0__":414}
+{"text":"```\ncd ~\nwget https:\/\/github.com\/ArduCAM\/MIPI_Camera\/releases\/download\/v0.0.3\/install_full.sh\nchmod +x install_full.sh\n.\/install_full.sh -m arducam\n```","__index_level_0__":415}
+{"text":"Another way to do this is to use the original Jetson Nano camera driver:","__index_level_0__":416}
+{"text":"```\nsudo dpkg -r arducam-nvidia-l4t-kernel\nsudo shutdown -r now\n```","__index_level_0__":417}
+{"text":"Then, use ls \/dev\/video0 to confirm the camera is found:","__index_level_0__":418}
+{"text":"```\n$ ls \/dev\/video0\n\/dev\/video0\n```","__index_level_0__":419}
+{"text":"And finally, the following command to see the camera in action:","__index_level_0__":420}
+{"text":"```\nnvgstcapture-1.0 --orientation=2\n```","__index_level_0__":421}
+{"text":"### Using Jetson Inference\nNVIDIA [Jetson Inference](https:\/\/github.com\/dusty-nv\/jetson-inference) API offers the easiest way to run image recognition, object detection, semantic segmentation, and pose estimation models on Jetson Nano. Jetson Inference has TensorRT built-in, so it\u2019s very fast. ","__index_level_0__":422}
+{"text":"To test run Jetson Inference, first clone the repo and download the models:","__index_level_0__":423}
+{"text":"```\ngit clone --recursive https:\/\/github.com\/dusty-nv\/jetson-inference\ncd jetson-inference\n```","__index_level_0__":424}
+{"text":"Then use the pre-built [Docker Container](https:\/\/github.com\/dusty-nv\/jetson-inference\/blob\/master\/docs\/jetpack-setup-2.md) that already has PyTorch installed to test run the models:","__index_level_0__":425}
+{"text":"```\ndocker\/run.sh --volume ~\/jetson_inference:\/jetson_inference\n```","__index_level_0__":426}
+{"text":"To run image recognition, object detection, semantic segmentation, and pose estimation models on test images, use the following:","__index_level_0__":427}
+{"text":"```\ncd build\/aarch64\/bin\n.\/imagenet.py images\/jellyfish.jpg \/jetson_inference\/jellyfish.jpg\n.\/segnet.py images\/dog.jpg \/jetson_inference\/dog.jpeg\n.\/detectnet.py images\/peds_0.jpg \/jetson_inference\/peds_0.jpg\n.\/posenet.py images\/humans_0.jpg \/jetson_inference\/pose_humans_0.jpg\n```","__index_level_0__":428}
+{"text":"Four result images from running the four different models will be generated. Exit the docker image to see them:","__index_level_0__":429}
+{"text":"```\n$ ls -lt ~\/jetson_inference\/\n-rw-r--r-- 1 root root  68834 Oct 15 21:30 pose_humans_0.jpg\n-rw-r--r-- 1 root root 914058 Oct 15 21:30 peds_0.jpg\n-rw-r--r-- 1 root root 666239 Oct 15 21:30 dog.jpeg\n-rw-r--r-- 1 root root 179760 Oct 15 21:29 jellyfish.jpg\n```","__index_level_0__":430}
+{"text":"\n<div style=\"display: flex; justify-content: space-between;\">\n  <img src=\"\/assets\/images\/blog-2022-3-10-using-jetson-interface-1.jpeg\" alt=\"Using jest interface example 1\" width=\"40%\">\n  <img src=\"\/assets\/images\/blog-2022-3-10-using-jetson-interface-2.jpeg\" alt=\"Using jest interface example 2\" width=\"60%\">\n<\/div>","__index_level_0__":431}
+{"text":"\n<div style=\"display: flex; justify-content: space-between;\">\n  <img src=\"\/assets\/images\/blog-2022-3-10-using-jetson-interface-3.jpeg\" alt=\"Using jest interface example 3\" width=\"60%\">\n  <img src=\"\/assets\/images\/blog-2022-3-10-using-jetson-interface-4.jpeg\" alt=\"Using jest interface example 4\" width=\"40%\">\n<\/div>","__index_level_0__":432}
+{"text":"You can also use the docker image to run PyTorch models because the image has PyTorch, torchvision and torchaudio installed:","__index_level_0__":433}
+{"text":"```\n# pip list|grep torch\ntorch (1.9.0)\ntorchaudio (0.9.0a0+33b2469)\ntorchvision (0.10.0a0+300a8a4)\n```","__index_level_0__":434}
+{"text":"Although Jetson Inference includes models already converted to the TensorRT engine file format, you can fine-tune the models by following the steps in Transfer Learning with PyTorch (for Jetson Inference) [here](https:\/\/github.com\/dusty-nv\/jetson-inference\/blob\/master\/docs\/pytorch-transfer-learning.md).","__index_level_0__":435}
+{"text":"### Using TensorRT\n[TensorRT](https:\/\/docs.nvidia.com\/deeplearning\/tensorrt\/) is an SDK for high-performance inference from NVIDIA. Jetson Nano supports TensorRT via the Jetpack SDK, included in the SD Card image used to set up Jetson Nano. To confirm that TensorRT is already installed in Nano, `run dpkg -l|grep -i tensorrt`:","__index_level_0__":436}
+{"text":"\n<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/blog-2022-3-10-using-tensorrt.png\" width=\"80%\">\n<\/div>","__index_level_0__":437}
+{"text":"Theoretically, TensorRT can be used to \u201ctake a trained PyTorch model and optimize it to run more efficiently during inference on an NVIDIA GPU.\u201d Follow the instructions and code in the [notebook](https:\/\/github.com\/NVIDIA\/TensorRT\/blob\/master\/quickstart\/IntroNotebooks\/4.%20Using%20PyTorch%20through%20ONNX.ipynb) to see how to use PyTorch with TensorRT through ONNX on a torchvision Resnet50 model:","__index_level_0__":438}
+{"text":"1. How to convert the model from PyTorch to ONNX;","__index_level_0__":439}
+{"text":"2. How to convert the ONNX model to a TensorRT engine file; ","__index_level_0__":440}
+{"text":"3. How to run the engine file with the TensorRT runtime for performance improvement: inference time improved from the original 31.5ms\/19.4ms (FP32\/FP16 precision) to 6.28ms (TensorRT).","__index_level_0__":441}
+{"text":"You can replace the Resnet50 model in the notebook code with another PyTorch model, go through the conversion process above, and run the finally converted model TensorRT engine file with the TensorRT runtime to see the optimized performance. But be aware that due to the Nano GPU memory size, models larger than 100MB are likely to fail to run, with the following error information:","__index_level_0__":442}
+{"text":"`Error Code 1: Cuda Runtime (all CUDA-capable devices are busy or unavailable)`","__index_level_0__":443}
+{"text":"You may also see an error when converting a PyTorch model to ONNX model, which may be fixed by replacing: ","__index_level_0__":444}
+{"text":"`torch.onnx.export(resnet50, dummy_input, \"resnet50_pytorch.onnx\", verbose=False)`","__index_level_0__":445}
+{"text":"`torch.onnx.export(model, dummy_input, \"deeplabv3_pytorch.onnx\", opset_version=11, verbose=False)`","__index_level_0__":447}
+{"text":"### Using PyTorch \nFirst, to download and install PyTorch 1.9 on Nano, run the following commands (see [here](https:\/\/forums.developer.nvidia.com\/t\/pytorch-for-jetson-version-1-10-now-available\/72048) for more information):","__index_level_0__":448}
+{"text":"```\nwget https:\/\/nvidia.box.com\/shared\/static\/p57jwntv436lfrd78inwl7iml6p13fzh.whl -O torch-1.8.0-cp36-cp36m-linux_aarch64.whl -O torch-1.9.0-cp36-cp36m-linux_aarch64.whl\nsudo apt-get install python3-pip libopenblas-base libopenmpi-dev \npip3 install Cython\npip3 install numpy torch-1.9.0-cp36-cp36m-linux_aarch64.whl\n```","__index_level_0__":449}
+{"text":"To download and install torchvision 0.10 on Nano, run the commands below:","__index_level_0__":450}
+{"text":"```\nhttps:\/\/drive.google.com\/uc?id=1tU6YlPjrP605j4z8PMnqwCSoP6sSC91Z\npip3 install torchvision-0.10.0a0+300a8a4-cp36-cp36m-linux_aarch64.whl\n```","__index_level_0__":451}
+{"text":"After the steps above, run this to confirm:\n```\n$ pip3 list|grep torch\ntorch (1.9.0)\ntorchvision (0.10.0)\n```","__index_level_0__":452}
+{"text":"You can also use the docker image described in the section *Using Jetson Inference* (which also has PyTorch and torchvision installed), to skip the manual steps above.","__index_level_0__":453}
+{"text":"The official [YOLOv5](https:\/\/github.com\/ultralytics\/yolov5) repo is used to run the PyTorch YOLOv5 model on Jetson Nano. After logging in to Jetson Nano, follow the steps below:","__index_level_0__":454}
+{"text":"* Get the repo and install what\u2019s required:","__index_level_0__":455}
+{"text":"```\ngit clone https:\/\/github.com\/ultralytics\/yolov5\ncd yolov5\npip install -r requirements.txt\n```","__index_level_0__":456}
+{"text":"* Run `python3 detect.py`, which by default uses the PyTorch yolov5s.pt model. You should see something like:","__index_level_0__":457}
+{"text":"```\ndetect: weights=yolov5s.pt, source=data\/images, imgsz=[640, 640], conf_thres=0.25, iou_thres=0.45, max_det=1000, device=, view_img=False, save_txt=False, save_conf=False, save_crop=False, nosave=False, classes=None, agnostic_nms=False, augment=False, visualize=False, update=False, project=runs\/detect, name=exp, exist_ok=False, line_thickness=3, hide_labels=False, hide_conf=False, half=False\nYOLOv5 \ud83d\ude80 v5.0-499-g48b00db torch 1.9.0 CUDA:0 (NVIDIA Tegra X1, 3956.1015625MB)","__index_level_0__":458}
+{"text":"Fusing layers... \nModel Summary: 224 layers, 7266973 parameters, 0 gradients\nimage 1\/5 \/home\/jeff\/repos\/yolov5-new\/yolov5\/data\/images\/bus.jpg: 640x480 4 persons, 1 bus, 1 fire hydrant, Done. (0.142s)\n...\n```","__index_level_0__":459}
+{"text":"**The inference time on Jetson Nano GPU is about 140ms, more than twice as fast as the inference time on iOS or Android (about 330ms).**","__index_level_0__":460}
+{"text":"If you get an error `\u201cImportError: The _imagingft C module is not installed.\u201d` then you need to reinstall pillow:\n```\nsudo apt-get install libpng-dev\nsudo apt-get install libfreetype6-dev\npip3 uninstall pillow\npip3 install --no-cache-dir pillow\n```","__index_level_0__":461}
+{"text":"After successfully completing the `python3 detect.py` run, the object detection results of the test images located in `data\/images` will be in the `runs\/detect\/exp` directory. To test the detection with a live webcam instead of local images, use the `--source 0` parameter when running `python3 detect.py`):","__index_level_0__":462}
+{"text":"```\n~\/repos\/yolov5$ ls -lt runs\/detect\/exp10\ntotal 1456\n-rw-rw-r-- 1 jeff jeff 254895 Oct 15 16:12 zidane.jpg\n-rw-rw-r-- 1 jeff jeff 202674 Oct 15 16:12 test3.png\n-rw-rw-r-- 1 jeff jeff 217117 Oct 15 16:12 test2.jpg\n-rw-rw-r-- 1 jeff jeff 305826 Oct 15 16:12 test1.png\n-rw-rw-r-- 1 jeff jeff 495760 Oct 15 16:12 bus.jpg\n```","__index_level_0__":463}
+{"text":"Using the same test files used in the PyTorch iOS YOLOv5 demo app or Android YOLOv5 demo app, you can compare the results generated with running the YOLOv5 PyTorch model on mobile devices and Jetson Nano:","__index_level_0__":464}
+{"text":"<div style=\"display: flex\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/blog-2022-3-10-using-pytorch-1.png\" alt=\"PyTorch YOLOv5 on Jetson Nano, example with a dog\" width=\"35%\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/blog-2022-3-10-using-pytorch-2.jpeg\" alt=\"PyTorch YOLOv5 on Jetson Nano, example with a horse and a rider\" width=\"50%\">\n<\/div>\nFigure 1. PyTorch YOLOv5 on Jetson Nano.  ","__index_level_0__":465}
+{"text":"<div style=\"display: flex\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/blog-2022-3-10-using-pytorch-3.png\" alt=\"PyTorch YOLOv5 on iOS, example with a dog\" width=\"35%\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/blog-2022-3-10-using-pytorch-4.png\" alt=\"PyTorch YOLOv5 on iOS, example with a horse and a rider\" width=\"50%\">\n<\/div>\nFigure 2. PyTorch YOLOv5 on iOS.  ","__index_level_0__":466}
+{"text":"<div style=\"display: flex\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/blog-2022-3-10-using-pytorch-5.png\" alt=\"PyTorch YOLOv5 on Android, example with a dog\" width=\"35%\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/blog-2022-3-10-using-pytorch-6.png\" alt=\"PyTorch YOLOv5 on Android, example with a horse and a rider\" width=\"50%\">\n<\/div>\nFigure 3. PyTorch YOLOv5 on Android.  ","__index_level_0__":467}
+{"text":"### Summary\nBased on our experience of running different PyTorch models for potential demo apps on Jetson Nano, we see that even Jetson Nano, a lower-end of the Jetson family of products, provides a powerful GPU and embedded system that can directly run some of the latest PyTorch models, pre-trained or transfer learned, efficiently.","__index_level_0__":468}
+{"text":"Building PyTorch demo apps on Jetson Nano can be similar to building PyTorch apps on Linux, but you can also choose to use TensorRT after converting the PyTorch models to the TensorRT engine file format.","__index_level_0__":469}
+{"text":"But if you just need to run some common computer vision models on Jetson Nano using NVIDIA\u2019s Jetson Inference which supports image recognition, object detection, semantic segmentation, and pose estimation models, then this is the easiest way.","__index_level_0__":470}
+{"text":"\n### References\nTorch-TensorRT, a compiler for PyTorch via TensorRT:\n[https:\/\/github.com\/NVIDIA\/Torch-TensorRT\/](https:\/\/github.com\/NVIDIA\/Torch-TensorRT\/)","__index_level_0__":471}
+{"text":"Jetson Inference docker image details:\n[https:\/\/github.com\/dusty-nv\/jetson-inference\/blob\/master\/docs\/aux-docker.md](https:\/\/github.com\/dusty-nv\/jetson-inference\/blob\/master\/docs\/aux-docker.md)","__index_level_0__":472}
+{"text":"A guide to using TensorRT on the NVIDIA Jetson Nano:\n[https:\/\/docs.donkeycar.com\/guide\/robot_sbc\/tensorrt_jetson_nano\/](https:\/\/docs.donkeycar.com\/guide\/robot_sbc\/tensorrt_jetson_nano\/) \nincluding:","__index_level_0__":473}
+{"text":"1. Use Jetson as a portable GPU device to run an NN chess engine model: \n[https:\/\/medium.com\/@ezchess\/jetson-lc0-running-leela-chess-zero-on-nvidia-jetson-a-portable-gpu-device-a213afc9c018](https:\/\/medium.com\/@ezchess\/jetson-lc0-running-leela-chess-zero-on-nvidia-jetson-a-portable-gpu-device-a213afc9c018)","__index_level_0__":474}
+{"text":"2. A MaskEraser app using PyTorch and torchvision, installed directly with pip:\n[https:\/\/github.com\/INTEC-ATI\/MaskEraser#install-pytorch](https:\/\/github.com\/INTEC-ATI\/MaskEraser#install-pytorch)\n \n source: https:\/\/pytorch.org\/blog\/running-pytorch-models-on-jetson-nano\/ \n category: pytorch blogs","__index_level_0__":475}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 1.9 Release, including torch.linalg and Mobile Interpreter'\nauthor: Team PyTorch \n---","__index_level_0__":476}
+{"text":"We are excited to announce the release of PyTorch 1.9. The release is composed of more than 3,400 commits since 1.8, made by 398 contributors. The release notes are available [here](https:\/\/github.com\/pytorch\/pytorch\/releases). Highlights include:\n1. Major improvements to support scientific computing, including *torch.linalg*, *torch.special*, and Complex Autograd\n2. Major improvements in on-device binary size with Mobile Interpreter\n3. Native support for elastic-fault tolerance training through the upstreaming of TorchElastic into PyTorch Core\n4. Major updates to the PyTorch RPC framework to support large scale distributed training with GPU support\n5. New APIs to optimize performance and packaging for model inference deployment \n6. Support for Distributed training, GPU utilization and SM efficiency in the PyTorch Profiler","__index_level_0__":477}
+{"text":"Along with 1.9, we are also releasing major updates to the PyTorch libraries, which you can read about in [this blog post](https:\/\/pytorch.org\/blog\/pytorch-1.9-new-library-releases\/). ","__index_level_0__":478}
+{"text":"We\u2019d like to thank the community for their support and work on this latest release. We\u2019d especially like to thank Quansight and Microsoft for their contributions.","__index_level_0__":479}
+{"text":"Features in PyTorch releases are classified as Stable, Beta, and Prototype. You can learn more about the definitions in [this blog post](https:\/\/pytorch.org\/blog\/pytorch-feature-classification-changes\/). ","__index_level_0__":480}
+{"text":"# Frontend APIs","__index_level_0__":481}
+{"text":"### (Stable) *torch.linalg*","__index_level_0__":482}
+{"text":"In 1.9, the *torch.linalg* module is moving to a stable release. Linear algebra is essential to deep learning and scientific computing, and the *torch.linalg* module extends PyTorch\u2019s support for it with implementations of every function from [NumPy\u2019s linear algebra module](https:\/\/numpy.org\/doc\/stable\/reference\/routines.linalg.html) (now with support for accelerators and autograd) and more, like [*torch.linalg.matrix_norm*](https:\/\/pytorch.org\/docs\/1.9.0\/generated\/torch.linalg.matrix_norm.html?highlight=matrix_norm#torch.linalg.matrix_norm) and [*torch.linalg.householder_product*](https:\/\/pytorch.org\/docs\/1.9.0\/generated\/torch.linalg.householder_product.html?highlight=householder_product#torch.linalg.householder_product). This makes the module immediately familiar to users who have worked with NumPy. Refer to [the documentation](https:\/\/pytorch.org\/docs\/1.9.0\/linalg.html?highlight=linalg#module-torch.linalg) here. ","__index_level_0__":483}
+{"text":"We plan to publish another blog post with more details on the *torch.linalg* module next week!","__index_level_0__":484}
+{"text":"### (Stable) Complex Autograd ","__index_level_0__":485}
+{"text":"The Complex Autograd feature, released as a beta in PyTorch 1.8, is now stable. Since the beta release, we have extended support for Complex Autograd for over 98% operators in PyTorch 1.9, improved testing for complex operators by adding more OpInfos, and added greater validation through TorchAudio migration to native complex tensors (refer to [this issue](https:\/\/github.com\/pytorch\/audio\/issues\/1337)). ","__index_level_0__":486}
+{"text":"This feature provides users the functionality to calculate complex gradients and optimize real valued loss functions with complex variables. This is a required feature for multiple current and downstream prospective users of complex numbers in PyTorch like TorchAudio, ESPNet, Asteroid, and FastMRI. Refer to [the documentation](https:\/\/pytorch.org\/docs\/1.9.0\/notes\/autograd.html#autograd-for-complex-numbers) for more details. ","__index_level_0__":487}
+{"text":"### (Stable) torch.use_deterministic_algorithms() ","__index_level_0__":488}
+{"text":"To help with debugging and writing reproducible programs, PyTorch 1.9 includes a *torch.use_determinstic_algorithms* option. When this setting is enabled, operations will behave deterministically, if possible, or throw a runtime error if they might behave nondeterministically. Here are a couple examples:","__index_level_0__":489}
+{"text":"```python\n>>> a = torch.randn(100, 100, 100, device='cuda').to_sparse()\n>>> b = torch.randn(100, 100, 100, device='cuda')","__index_level_0__":490}
+{"text":"# Sparse-dense CUDA bmm is usually nondeterministic\n>>> torch.bmm(a, b).eq(torch.bmm(a, b)).all().item()\nFalse","__index_level_0__":491}
+{"text":">>> torch.use_deterministic_algorithms(True)","__index_level_0__":492}
+{"text":"# Now torch.bmm gives the same result each time, but with reduced performance\n>>> torch.bmm(a, b).eq(torch.bmm(a, b)).all().item()\nTrue","__index_level_0__":493}
+{"text":"# CUDA kthvalue has no deterministic algorithm, so it throws a runtime error\n>>> torch.zeros(10000, device='cuda').kthvalue(1)\nRuntimeError: kthvalue CUDA does not have a deterministic implementation...\n```","__index_level_0__":494}
+{"text":"PyTorch 1.9 adds deterministic implementations for a number of indexing operations, too, including *index_add*, *index_copy*, and *index_put with accum=False*. For more details, refer to the [documentation](https:\/\/pytorch.org\/docs\/1.9.0\/generated\/torch.use_deterministic_algorithms.html?highlight=use_deterministic#torch.use_deterministic_algorithms) and [reproducibility note](https:\/\/pytorch.org\/docs\/1.9.0\/notes\/randomness.html?highlight=reproducibility).","__index_level_0__":495}
+{"text":"### (Beta) *torch.special*","__index_level_0__":496}
+{"text":"A *torch.special* module, analogous to [SciPy\u2019s special module](https:\/\/docs.scipy.org\/doc\/scipy\/reference\/special.html), is now available in beta. This module contains many functions useful for scientific computing and working with distributions such as *iv*, *ive*, *erfcx*, *logerfc*, and *logerfcx*. Refer to [the documentation](https:\/\/pytorch.org\/docs\/master\/special.html) for more details. ","__index_level_0__":497}
+{"text":"### (Beta) nn.Module parameterization ","__index_level_0__":498}
+{"text":"```nn.Module``` parameterization allows users to parametrize any parameter or buffer of an ```nn.Module``` without modifying the ```nn.Module``` itself. It allows you to constrain the space in which your parameters live without the need for special optimization methods.","__index_level_0__":499}
+{"text":"This also contains a new implementation of the ```spectral_norm``` parametrization for PyTorch 1.9. More parametrization will be added to this feature (weight_norm, matrix constraints and part of pruning) for the feature to become stable in 1.10. For more details, refer to the [documentation](https:\/\/pytorch.org\/docs\/1.9.0\/generated\/torch.nn.utils.parametrizations.spectral_norm.html?highlight=parametrize) and [tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/parametrizations.html).","__index_level_0__":500}
+{"text":"# PyTorch Mobile","__index_level_0__":501}
+{"text":"### (Beta) Mobile Interpreter ","__index_level_0__":502}
+{"text":"We are releasing Mobile Interpreter, a streamlined version of the PyTorch runtime, in beta. The Interpreter will execute PyTorch programs in edge devices, with reduced binary size footprint. ","__index_level_0__":503}
+{"text":"Mobile Interpreter is one of the top requested features for PyTorch Mobile. This new release will significantly reduce binary size compared with the current on-device runtime. In order for you to get the binary size improvements with our interpreter (which can reduce the binary size up to ~75% for a typical application) follow these instructions. As an example, using Mobile Interpreter, we can reach 2.6 MB compressed with MobileNetV2 in arm64-v7a Android. With this latest release we are making it much simpler to integrate the interpreter by providing pre-built libraries for iOS and Android.","__index_level_0__":504}
+{"text":"### TorchVision Library","__index_level_0__":505}
+{"text":"Starting from 1.9, users can use the TorchVision library on their iOS\/Android apps. The Torchvision library contains the C++ TorchVision ops and needs to be linked together with the main PyTorch library for iOS, for Android it can be added as a gradle dependency. This allows using TorchVision prebuilt MaskRCNN operators for object detections and segmentation. To learn more about the library, please refer to our tutorials and [demo apps](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/D2Go). ","__index_level_0__":506}
+{"text":"### Demo apps","__index_level_0__":507}
+{"text":"We are releasing a new video app based on [PyTorch Video](https:\/\/pytorchvideo.org\/) library and an updated speech recognition app based on the latest torchaudio, wave2vec model. Both are available on [iOS](https:\/\/github.com\/pytorch\/ios-demo-app) and [Android](https:\/\/github.com\/pytorch\/android-demo-app). In addition, we have updated the seven Computer Vision and three Natural Language Processing demo apps, including the HuggingFace DistilBERT, and the DeiT vision transformer models, with PyTorch Mobile v1.9. With the addition of these two apps, we now offer a full suite of demo apps covering image, text, audio, and video. To get started check out our [iOS demo apps](https:\/\/github.com\/pytorch\/ios-demo-app) and [Android demo apps](https:\/\/github.com\/pytorch\/android-demo-app).","__index_level_0__":508}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/android-demo-app.png\" width=\"100%\">\n<\/div>","__index_level_0__":509}
+{"text":"# Distributed Training","__index_level_0__":510}
+{"text":"### (Beta) TorchElastic is now part of core ","__index_level_0__":511}
+{"text":"[TorchElastic](https:\/\/github.com\/pytorch\/pytorch\/issues\/50621), which was open sourced over a year ago in the [pytorch\/elastic](https:\/\/github.com\/pytorch\/elastic) github repository, is a runner and coordinator for PyTorch worker processes. Since then, it has been adopted by various distributed torch use-cases: 1) [deepspeech.pytorch](https:\/\/medium.com\/pytorch\/training-deepspeech-using-torchelastic-ad013539682) 2) [pytorch-lightning](https:\/\/pytorch-lightning.readthedocs.io\/en\/stable\/advanced\/multi_gpu.html#torchelastic) 3) [Kubernetes CRD](https:\/\/github.com\/pytorch\/elastic\/blob\/master\/kubernetes\/README.md). Now, it is part of PyTorch core. ","__index_level_0__":512}
+{"text":"As its name suggests, the core function of TorcheElastic is to gracefully handle scaling events. A notable corollary of elasticity is that peer discovery and rank assignment are built into TorchElastic enabling users to run distributed training on preemptible instances without requiring a gang scheduler. As a side note, [etcd](https:\/\/etcd.io\/) used to be a hard dependency of TorchElastic. With the upstream, this is no longer the case since we have added a \u201cstandalone\u201d rendezvous based on c10d::Store. For more details, refer to the [documentation](https:\/\/pytorch.org\/docs\/1.9.0\/distributed.elastic.html).","__index_level_0__":513}
+{"text":"### (Beta) Distributed Training Updates","__index_level_0__":514}
+{"text":"In addition to TorchElastic, there are a number of beta features available in the distributed package:","__index_level_0__":515}
+{"text":"* **(Beta) CUDA support is available in RPC**: Compared to CPU RPC and general-purpose RPC frameworks, CUDA RPC is a much more efficient way for P2P Tensor communication. It is built on top of TensorPipe which can automatically choose a communication channel for each Tensor based on Tensor device type and channel availability on both the caller and the callee. Existing TensorPipe channels cover NVLink, InfiniBand, SHM, CMA, TCP, etc. See [this recipe](https:\/\/pytorch.org\/tutorials\/recipes\/cuda_rpc.html) for how CUDA RPC helps to attain 34x speedup compared to CPU RPC.","__index_level_0__":516}
+{"text":"* **(Beta) ZeroRedundancyOptimizer**: ZeroRedundancyOptimizer can be used in conjunction with DistributedDataParallel to reduce the size of per-process optimizer states. The idea of ZeroRedundancyOptimizer comes from [DeepSpeed\/ZeRO project](https:\/\/github.com\/microsoft\/DeepSpeed) and [Marian](https:\/\/github.com\/marian-nmt\/marian-dev), where the optimizer in each process owns a shard of model parameters and their corresponding optimizer states. When running `step()`, each optimizer only updates its own parameters, and then uses collective communication to synchronize updated parameters across all processes. Refer to [this documentation](https:\/\/pytorch.org\/docs\/master\/distributed.optim.html) and this [tutorial](https:\/\/pytorch.org\/tutorials\/recipes\/zero_redundancy_optimizer.html) to learn more. ","__index_level_0__":517}
+{"text":"* **(Beta) Support for profiling distributed collectives**: PyTorch\u2019s profiler tools, *torch.profiler* and *torch.autograd.profiler*, are able to profile distributed collectives and point to point communication primitives including allreduce, alltoall, allgather, send\/recv, etc. This is enabled for all backends supported natively by PyTorch: gloo, mpi, and nccl. This can be used to debug performance issues, analyze traces that contain distributed communication, and gain insight into performance of applications that use distributed training. To learn more, refer to [this documentation](https:\/\/pytorch.org\/docs\/1.9.0\/distributed.html#profiling-collective-communication). ","__index_level_0__":518}
+{"text":"# Performance Optimization and Tooling","__index_level_0__":519}
+{"text":"### (Stable) Freezing API ","__index_level_0__":520}
+{"text":"Module Freezing is the process of inlining module parameters and attributes values as constants into the TorchScript internal representation. This allows further optimization and specialization of your program, both for TorchScript optimizations and lowering to other backends. It is used by [optimize_for_mobile API](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/utils\/mobile_optimizer.py), ONNX, and others.   ","__index_level_0__":521}
+{"text":"Freezing is recommended for model deployment. It helps TorchScript JIT optimizations optimize away overhead and bookkeeping that is necessary for training, tuning, or debugging PyTorch models. It enables graph fusions that are not semantically valid on non-frozen graphs - such as fusing Conv-BN. For more details, refer to the [documentation](https:\/\/pytorch.org\/docs\/1.9.0\/generated\/torch.jit.freeze.html).","__index_level_0__":522}
+{"text":"### (Beta) PyTorch Profiler ","__index_level_0__":523}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/pytorch-profiler.gif\" width=\"100%\">\n<\/div>","__index_level_0__":524}
+{"text":"The new PyTorch Profiler graduates to beta and leverages [Kineto](https:\/\/github.com\/pytorch\/kineto\/) for GPU profiling, TensorBoard for visualization and is now the standard across our tutorials and documentation. ","__index_level_0__":525}
+{"text":"PyTorch 1.9 extends support for the new *torch.profiler* API to more builds, including Windows and Mac and is recommended in most cases instead of the previous *torch.autograd.profiler* API. The new API supports existing profiler features, integrates with CUPTI library (Linux-only) to trace on-device CUDA kernels and provides support for long-running jobs, e.g.:","__index_level_0__":526}
+{"text":"```python\ndef trace_handler(p):\n    output = p.key_averages().table(sort_by=\"self_cuda_time_total\", row_limit=10)\n    print(output)\n    p.export_chrome_trace(\"\/tmp\/trace_\" + str(p.step_num) + \".json\")","__index_level_0__":527}
+{"text":"with profile(\n    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],\n    # schedule argument specifies the iterations on which the profiler is active\n    schedule=torch.profiler.schedule(\n        wait=1,\n        warmup=1,\n        active=2),\n    # on_trace_ready argument specifies the handler for the traces\n    on_trace_ready=trace_handler\n) as p:\n    for idx in range(8):\n        model(inputs)\n        # profiler will trace iterations 2 and 3, and then 6 and 7 (counting from zero)\n        p.step()\n```","__index_level_0__":528}
+{"text":"More usage examples can be found on the [profiler recipe page](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/profiler_recipe.html). ","__index_level_0__":529}
+{"text":"The PyTorch Profiler Tensorboard plugin has new features for:\n* Distributed Training summary view with communications overview for NCCL\n* GPU Utilization and SM Efficiency in Trace view and GPU operators view\n* Memory Profiling view\n* Jump to source when launched from Microsoft VSCode\n* Ability for load traces from cloud object storage systems ","__index_level_0__":530}
+{"text":"### (Beta) Inference Mode API ","__index_level_0__":531}
+{"text":"Inference Mode API allows significant speed-up for inference workloads while remaining safe and ensuring no incorrect gradients can ever be computed. It offers the best possible performance when no autograd is required. For more details, refer to [the documentation for inference mode itself](https:\/\/pytorch.org\/docs\/1.9.0\/generated\/torch.inference_mode.html?highlight=inference%20mode#torch.inference_mode) and [the documentation explaining when to use it and the difference with no_grad mode](https:\/\/pytorch.org\/docs\/1.9.0\/notes\/autograd.html#locally-disabling-gradient-computation).","__index_level_0__":532}
+{"text":"### (Beta) *torch.package* \n \n*torch.package* is a new way to package PyTorch models in a self-contained, stable format. A package will include both the model\u2019s data (e.g. parameters, buffers) and its code (model architecture). Packaging a model with its full set of Python dependencies, combined with a description of a conda environment with pinned versions, can be used to easily reproduce training. Representing a model in a self-contained artifact will also allow it to be published and transferred throughout a production ML pipeline while retaining the flexibility of a pure-Python representation. For more details, refer to [the documentation](https:\/\/pytorch.org\/docs\/1.9.0\/package.html).","__index_level_0__":533}
+{"text":"### (Prototype) prepare_for_inference ","__index_level_0__":534}
+{"text":"prepare_for_inference is a new prototype feature that takes in a module and performs graph-level optimizations to improve inference performance, depending on the device. It is meant to be a PyTorch-native option that requires minimal changes to user\u2019s workflows. For more details, see [the documentation](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/jit\/_freeze.py#L168) for the Torchscript version [here](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/jit\/_freeze.py#L168) or the FX version [here](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/fx\/experimental\/optimization.py#L234).","__index_level_0__":535}
+{"text":"### (Prototype) Profile-directed typing in TorchScript  ","__index_level_0__":536}
+{"text":"TorchScript has a hard requirement for source code to have type annotations in order for compilation to be successful. For a long time, it was only possible to add missing or incorrect type annotations through trial and error (i.e., by fixing the type-checking errors generated by *torch.jit.script* one by one), which was inefficient and time consuming. Now, we have enabled profile directed typing for *torch.jit.script* by leveraging existing tools like MonkeyType, which makes the process much easier, faster, and more efficient. For more details, refer to [the documentation](https:\/\/pytorch.org\/docs\/1.9.0\/jit.html).","__index_level_0__":537}
+{"text":"Thanks for reading. If you\u2019re interested in these updates and want to join the PyTorch community, we encourage you to join the [discussion forums](https:\/\/discuss.pytorch.org\/) and [open GitHub issues](https:\/\/github.com\/pytorch\/pytorch\/issues). To get the latest news from PyTorch, follow us on [Facebook](https:\/\/www.facebook.com\/pytorch\/), [Twitter](https:\/\/twitter.com\/PyTorch), [Medium](https:\/\/medium.com\/pytorch), [YouTube](https:\/\/www.youtube.com\/pytorch), or [LinkedIn](https:\/\/www.linkedin.com\/company\/pytorch).  ","__index_level_0__":538}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.9-released\/ \n category: pytorch blogs","__index_level_0__":540}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Announcing PyTorch Developer Day 2020'\nauthor: Team PyTorch\n---","__index_level_0__":541}
+{"text":"Starting this year, we plan to host two separate events for PyTorch: one for developers and users to discuss core technical development, ideas and roadmaps called **\u201cDeveloper Day\u201d**, and another for the PyTorch ecosystem and industry communities to showcase their work and discover opportunities to collaborate called **\u201cEcosystem Day\u201d** (scheduled for early 2021).","__index_level_0__":542}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/PTD2-social-asset.png\" width=\"100%\">\n<\/div>","__index_level_0__":543}
+{"text":"The **PyTorch Developer Day** (#PTD2) is kicking off on November 12, 2020, 8AM PST with a full day of technical talks on a variety of topics, including updates to the core framework, new tools and libraries to support development across a variety of domains. You'll also see talks covering the latest research around systems and tooling in ML.","__index_level_0__":544}
+{"text":"For Developer Day, we have an online networking event limited to people composed of PyTorch maintainers and contributors, long-time stakeholders and experts in areas relevant to PyTorch\u2019s future. Conversations from the networking event will strongly shape the future of PyTorch. Hence, invitations are required to attend the networking event.","__index_level_0__":545}
+{"text":"All talks will be livestreamed and available to the public.\n* [Livestream event page](https:\/\/www.facebook.com\/events\/802177440559164\/)\n* [Apply for an invitation to the networking event](https:\/\/pytorchdeveloperday.fbreg.com\/apply)","__index_level_0__":546}
+{"text":"Visit the [event website](https:\/\/pytorchdeveloperday.fbreg.com\/) to learn more. We look forward to welcoming you to PyTorch Developer Day on November 12th! ","__index_level_0__":547}
+{"text":"The PyTorch team\n \n source: https:\/\/pytorch.org\/blog\/pytorch-developer-day-2020\/ \n category: pytorch blogs","__index_level_0__":549}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 1.7 released w\/ CUDA 11, New APIs for FFTs, Windows support for Distributed training and more'\nauthor: Team PyTorch\n---","__index_level_0__":550}
+{"text":"Today, we\u2019re announcing the availability of PyTorch 1.7, along with updated domain libraries. The PyTorch 1.7 release includes a number of new APIs including support for NumPy-Compatible FFT operations, profiling tools and major updates to both distributed data parallel (DDP) and remote procedure call (RPC) based distributed training. In addition, several features moved to [stable](https:\/\/pytorch.org\/docs\/stable\/index.html#pytorch-documentation) including custom C++ Classes, the memory profiler, extensions via custom tensor-like objects, user async functions in RPC and a number of other features in torch.distributed such as Per-RPC timeout, DDP dynamic bucketing and RRef helper. ","__index_level_0__":551}
+{"text":"A few of the highlights include:\n* CUDA 11 is now officially supported with binaries available at [PyTorch.org](http:\/\/pytorch.org\/)\n* Updates and additions to profiling and performance for RPC, TorchScript and Stack traces in the autograd profiler\n* (Beta) Support for NumPy compatible Fast Fourier transforms (FFT) via torch.fft\n* (Prototype) Support for Nvidia A100 generation GPUs and native TF32 format \n* (Prototype) Distributed training on Windows now supported\n* torchvision\n   * (Stable) Transforms now support Tensor inputs, batch computation, GPU, and TorchScript\n   * (Stable) Native image I\/O for JPEG and PNG formats\n   * (Beta) New Video Reader API\n* torchaudio\n   * (Stable) Added support for speech rec (wav2letter), text to speech (WaveRNN) and source separation (ConvTasNet)","__index_level_0__":552}
+{"text":"To reiterate, starting PyTorch 1.6, features are now classified as stable, beta and prototype. You can see the detailed announcement [here](https:\/\/pytorch.org\/blog\/pytorch-feature-classification-changes\/). Note that the prototype features listed in this blog are available as part of this release. ","__index_level_0__":553}
+{"text":"Find the full release notes [here](https:\/\/github.com\/pytorch\/pytorch\/releases).  ","__index_level_0__":554}
+{"text":"# Front End APIs\n## [Beta] NumPy Compatible torch.fft module\nFFT-related functionality is commonly used in a variety of scientific fields like signal processing. While PyTorch has historically supported a few FFT-related functions, the 1.7 release adds a new torch.fft module that implements FFT-related functions with the same API as NumPy.","__index_level_0__":555}
+{"text":"This new module must be imported to be used in the 1.7 release, since its name conflicts with the historic (and now deprecated) torch.fft function.","__index_level_0__":556}
+{"text":"**Example usage:**\n```python\n>>> import torch.fft\n>>> t = torch.arange(4)\n>>> t\ntensor([0, 1, 2, 3])","__index_level_0__":557}
+{"text":">>> torch.fft.fft(t)\ntensor([ 6.+0.j, -2.+2.j, -2.+0.j, -2.-2.j])","__index_level_0__":558}
+{"text":">>> t = tensor([0.+1.j, 2.+3.j, 4.+5.j, 6.+7.j])\n>>> torch.fft.fft(t)\ntensor([12.+16.j, -8.+0.j, -4.-4.j,  0.-8.j])\n ```","__index_level_0__":559}
+{"text":"* [Documentation](https:\/\/pytorch.org\/docs\/stable\/fft.html#torch-fft)","__index_level_0__":560}
+{"text":"## [Beta] C++ Support for Transformer NN Modules\nSince [PyTorch 1.5](https:\/\/pytorch.org\/blog\/pytorch-1-dot-5-released-with-new-and-updated-apis\/), we\u2019ve continued to maintain parity between the python and C++ frontend APIs. This update allows developers to use the nn.transformer module abstraction from the C++ Frontend. And moreover, developers no longer need to save a module from python\/JIT and load into C++ as it can now be used it in C++ directly.\n* [Documentation](https:\/\/pytorch.org\/cppdocs\/api\/classtorch_1_1nn_1_1_transformer_impl.html#_CPPv4N5torch2nn15TransformerImplE)","__index_level_0__":561}
+{"text":"## [Beta] torch.set_deterministic \nReproducibility (bit-for-bit determinism) may help identify errors when debugging or testing a program. To facilitate reproducibility, PyTorch 1.7 adds the  ```torch.set_deterministic(bool)``` function that can direct PyTorch operators to select deterministic algorithms when available, and to throw a runtime error if an operation may result in nondeterministic behavior. By default, the flag this function controls is false and there is no change in behavior, meaning PyTorch may implement its operations nondeterministically by default. ","__index_level_0__":562}
+{"text":"More precisely, when this flag is true:\n* Operations known to not have a deterministic implementation throw a runtime error;\n* Operations with deterministic variants use those variants (usually with a performance penalty versus the non-deterministic version); and\n* ```torch.backends.cudnn.deterministic = True``` is set.","__index_level_0__":563}
+{"text":"Note that this is necessary, **but not sufficient**, for determinism **within a single run of a PyTorch program**. Other sources of randomness like random number generators, unknown operations, or asynchronous or distributed computation may still cause nondeterministic behavior.","__index_level_0__":564}
+{"text":"See the documentation for ```torch.set_deterministic(bool)``` for the list of affected operations.\n* [RFC](https:\/\/github.com\/pytorch\/pytorch\/issues\/15359)\n* [Documentation](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.set_deterministic.html)","__index_level_0__":565}
+{"text":"# Performance & Profiling\n## [Beta] Stack traces added to profiler\nUsers can now see not only operator name\/inputs in the profiler output table but also where the operator is in the code. The workflow requires very little change to take advantage of this capability. The user uses the [autograd profiler](https:\/\/pytorch.org\/docs\/stable\/autograd.html#profiler) as before but with optional new parameters: ```with_stack``` and ```group_by_stack_n```. Caution: regular profiling runs should not use this feature as it adds significant overhead.\n* [Detail](https:\/\/github.com\/pytorch\/pytorch\/pull\/43898\/)\n* [Documentation](https:\/\/pytorch.org\/docs\/stable\/autograd.html)","__index_level_0__":566}
+{"text":"# Distributed Training & RPC \n## [Stable] TorchElastic now bundled into PyTorch docker image\nTorchelastic offers a strict superset of the current ```torch.distributed.launch``` CLI with the added features for fault-tolerance and elasticity. If the user is not be interested in fault-tolerance, they can get the exact functionality\/behavior parity by setting ```max_restarts=0``` with the added convenience of auto-assigned ```RANK``` and ```MASTER_ADDR|PORT``` (versus manually specified in ```torch.distributed.launch)```.","__index_level_0__":567}
+{"text":"By bundling ```torchelastic``` in the same docker image as PyTorch, users can start experimenting with TorchElastic right-away without having to separately install ```torchelastic```. In addition to convenience, this work is a nice-to-have when adding support for elastic parameters in the existing Kubeflow\u2019s distributed PyTorch operators.\n* [Usage examples and how to get started](https:\/\/pytorch.org\/elastic\/0.2.0\/examples.html)","__index_level_0__":568}
+{"text":"## [Beta] Support for uneven dataset inputs in DDP\nPyTorch 1.7 introduces a new context manager to be used in conjunction with models trained using ```torch.nn.parallel.DistributedDataParallel``` to enable training with uneven dataset size across different processes. This feature enables greater flexibility when using DDP and prevents the user from having to manually ensure dataset sizes are the same across different process. With this context manager, DDP will handle uneven dataset sizes automatically, which can prevent errors or hangs at the end of training.\n* [RFC](https:\/\/github.com\/pytorch\/pytorch\/issues\/38174)\n* [Documentation](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel.join)","__index_level_0__":569}
+{"text":"## [Beta] NCCL Reliability - Async Error\/Timeout Handling\nIn the past, NCCL training runs would hang indefinitely due to stuck collectives, leading to a very unpleasant experience for users. This feature will abort stuck collectives and throw an exception\/crash the process if a potential hang is detected. When used with something like torchelastic (which can recover the training process from the last checkpoint), users can have much greater reliability for distributed training. This feature is completely opt-in and sits behind an environment variable that needs to be explicitly set in order to enable this functionality (otherwise users will see the same behavior as before).\n* [RFC](https:\/\/github.com\/pytorch\/pytorch\/issues\/46874)\n* [Documentation](https:\/\/pytorch.org\/docs\/stable\/distributed.html?highlight=init_process_group#torch.distributed.init_process_group)","__index_level_0__":570}
+{"text":"## [Beta] TorchScript ```rpc_remote``` and ```rpc_sync```\n```torch.distributed.rpc.rpc_async``` has been available in TorchScript in prior releases. For PyTorch 1.7, this functionality will be extended the remaining two core RPC APIs, ```torch.distributed.rpc.rpc_sync``` and ```torch.distributed.rpc.remote```. This will complete the major RPC APIs targeted for support in TorchScript, it allows users to use the existing python RPC APIs within TorchScript (in a script function or script method, which releases the python Global Interpreter Lock) and could possibly improve application performance in multithreaded environment.\n* [Documentation](https:\/\/pytorch.org\/docs\/stable\/rpc.html#rpc)\n* [Usage examples](https:\/\/github.com\/pytorch\/pytorch\/blob\/58ed60c259834e324e86f3e3118e4fcbbfea8dd1\/torch\/testing\/_internal\/distributed\/rpc\/jit\/rpc_test.py#L505-L525)","__index_level_0__":571}
+{"text":"## [Beta] Distributed optimizer with TorchScript support\nPyTorch provides a broad set of optimizers for training algorithms, and these have been used repeatedly as part of the python API. However, users often want to use multithreaded training instead of multiprocess training as it provides better resource utilization and efficiency in the context of large scale distributed training (e.g. Distributed Model Parallel) or any RPC-based training application). Users couldn\u2019t do this with with distributed optimizer before because we need to get rid of the python Global Interpreter Lock (GIL) limitation to achieve this.","__index_level_0__":572}
+{"text":"In PyTorch 1.7, we are enabling the TorchScript support in distributed optimizer to remove the GIL, and make it possible to run optimizer in multithreaded applications. The new distributed optimizer has the exact same interface as before but it automatically converts optimizers within each worker into TorchScript to make each GIL free. This is done by leveraging a functional optimizer concept and allowing the distributed optimizer to convert the computational portion of the optimizer into TorchScript. This will help use cases like distributed model parallel training and improve performance using multithreading. ","__index_level_0__":573}
+{"text":"Currently, the only optimizer that supports automatic conversion with TorchScript is ```Adagrad``` and all other optimizers will still work as before without TorchScript support. We are working on expanding the coverage to all PyTorch optimizers and expect more to come in future releases. The usage to enable TorchScript support is automatic and exactly the same with existing python APIs, here is an example of how to use this:","__index_level_0__":574}
+{"text":"```python\nimport torch.distributed.autograd as dist_autograd\nimport torch.distributed.rpc as rpc\nfrom torch import optim\nfrom torch.distributed.optim import DistributedOptimizer","__index_level_0__":575}
+{"text":"with dist_autograd.context() as context_id:\n  # Forward pass.\n  rref1 = rpc.remote(\"worker1\", torch.add, args=(torch.ones(2), 3))\n  rref2 = rpc.remote(\"worker1\", torch.add, args=(torch.ones(2), 1))\n  loss = rref1.to_here() + rref2.to_here()","__index_level_0__":576}
+{"text":"  # Backward pass.\n  dist_autograd.backward(context_id, [loss.sum()])","__index_level_0__":577}
+{"text":"  # Optimizer, pass in optim.Adagrad, DistributedOptimizer will\n  # automatically convert\/compile it to TorchScript (GIL-free)\n  dist_optim = DistributedOptimizer(\n     optim.Adagrad,\n     [rref1, rref2],\n     lr=0.05,\n  )\n  dist_optim.step(context_id)\n ```\n* [RFC](https:\/\/github.com\/pytorch\/pytorch\/issues\/46883)\n* [Documentation](https:\/\/pytorch.org\/docs\/stable\/rpc.html#module-torch.distributed.optim)","__index_level_0__":578}
+{"text":"## [Beta] Enhancements to RPC-based Profiling\nSupport for using the PyTorch profiler in conjunction with the RPC framework was first introduced in PyTorch 1.6. In PyTorch 1.7, the following enhancements have been made:\n* Implemented better support for profiling TorchScript functions over RPC\n* Achieved parity in terms of profiler features that work with RPC\n* Added support for asynchronous RPC functions on the server-side (functions decorated with ```rpc.functions.async_execution)```.","__index_level_0__":579}
+{"text":"Users are now able to use familiar profiling tools such as with ```torch.autograd.profiler.profile()``` and ```with torch.autograd.profiler.record_function```, and this works transparently with the RPC framework with full feature support, profiles asynchronous functions, and TorchScript functions.\n* [Design doc](https:\/\/github.com\/pytorch\/pytorch\/issues\/39675)\n* [Usage examples](https:\/\/pytorch.org\/tutorials\/recipes\/distributed_rpc_profiling.html)","__index_level_0__":580}
+{"text":"## [Prototype] Windows support for Distributed Training\nPyTorch 1.7 brings prototype support for ```DistributedDataParallel``` and collective communications on the Windows platform. In this release, the support only covers Gloo-based ```ProcessGroup``` and ```FileStore```.","__index_level_0__":581}
+{"text":"To use this feature across multiple machines, please provide a file from a shared file system in ```init_process_group```. ","__index_level_0__":582}
+{"text":"```python\n# initialize the process group\ndist.init_process_group(\n    \"gloo\",\n    # multi-machine example:\n    # init_method = \"file:\/\/\/\/\/\/{machine}\/{share_folder}\/file\"\n    init_method=\"file:\/\/\/{your local file path}\",\n    rank=rank,\n    world_size=world_size\n)","__index_level_0__":583}
+{"text":"model = DistributedDataParallel(local_model, device_ids=[rank])\n```\n* [Design doc](https:\/\/github.com\/pytorch\/pytorch\/issues\/42095)\n* [Documentation](https:\/\/pytorch.org\/docs\/master\/distributed.html#backends-that-come-with-pytorch)\n* Acknowledgement ([gunandrose4u](https:\/\/github.com\/gunandrose4u))","__index_level_0__":584}
+{"text":"# Mobile\nPyTorch Mobile supports both [iOS](https:\/\/pytorch.org\/mobile\/ios) and [Android](https:\/\/pytorch.org\/mobile\/android\/) with binary packages available in [Cocoapods](https:\/\/cocoapods.org\/) and [JCenter](https:\/\/mvnrepository.com\/repos\/jcenter) respectively. You can learn more about PyTorch Mobile [here](https:\/\/pytorch.org\/mobile\/home\/). ","__index_level_0__":585}
+{"text":"## [Beta] PyTorch Mobile Caching allocator for performance improvements\nOn some mobile platforms, such as Pixel, we observed that memory is returned to the system more aggressively. This results in frequent page faults as PyTorch being a functional framework does not maintain state for the operators. Thus outputs are allocated dynamically on each execution of the op, for the most ops. To ameliorate performance penalties due to this, PyTorch 1.7 provides a simple caching allocator for CPU. The allocator caches allocations by tensor sizes and, is currently, available only via the PyTorch C++ API. The caching allocator itself is owned by client and thus the lifetime of the allocator is also maintained by client code. Such a client owned caching allocator can then be used with scoped guard, ```c10::WithCPUCachingAllocatorGuard```, to enable the use of cached allocation within that scope.\n**Example usage:**","__index_level_0__":586}
+{"text":"```python\n#include <c10\/mobile\/CPUCachingAllocator.h>\n.....\nc10::CPUCachingAllocator caching_allocator;\n  \/\/ Owned by client code. Can be a member of some client class so as to tie the\n  \/\/ the lifetime of caching allocator to that of the class.\n.....\n{\n  c10::optional<c10::WithCPUCachingAllocatorGuard> caching_allocator_guard;\n  if (FLAGS_use_caching_allocator) {\n    caching_allocator_guard.emplace(&caching_allocator);\n  }\n  ....\n  model.forward(..);\n}\n...\n```\n**NOTE**: Caching allocator is only available on mobile builds, thus the use of caching allocator outside of mobile builds won\u2019t be effective.\n* [Documentation](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/c10\/mobile\/CPUCachingAllocator.h#L13-L43)\n* [Usage examples](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/binaries\/speed_benchmark_torch.cc#L207)","__index_level_0__":587}
+{"text":"# torchvision\n## [Stable] Transforms now support Tensor inputs, batch computation, GPU, and TorchScript\ntorchvision transforms are now inherited from ```nn.Module``` and can be torchscripted and applied on torch Tensor inputs as well as on PIL images. They also support Tensors with batch dimensions and work seamlessly on CPU\/GPU devices:\n```python\nimport torch\nimport torchvision.transforms as T","__index_level_0__":588}
+{"text":"# to fix random seed, use torch.manual_seed\n# instead of random.seed\ntorch.manual_seed(12)","__index_level_0__":589}
+{"text":"transforms = torch.nn.Sequential(\n    T.RandomCrop(224),\n    T.RandomHorizontalFlip(p=0.3),\n    T.ConvertImageDtype(torch.float),\n    T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n)\nscripted_transforms = torch.jit.script(transforms)\n# Note: we can similarly use T.Compose to define transforms\n# transforms = T.Compose([...]) and \n# scripted_transforms = torch.jit.script(torch.nn.Sequential(*transforms.transforms))","__index_level_0__":590}
+{"text":"tensor_image = torch.randint(0, 256, size=(3, 256, 256), dtype=torch.uint8)\n# works directly on Tensors\nout_image1 = transforms(tensor_image)\n# on the GPU\nout_image1_cuda = transforms(tensor_image.cuda())\n# with batches\nbatched_image = torch.randint(0, 256, size=(4, 3, 256, 256), dtype=torch.uint8)\nout_image_batched = transforms(batched_image)\n# and has torchscript support\nout_image2 = scripted_transforms(tensor_image)\n```\nThese improvements enable the following new features:\n* support for GPU acceleration\n* batched transformations e.g. as needed for videos\n* transform multi-band torch tensor images (with more than 3-4 channels)\n* torchscript transforms together with your model for deployment\n**Note:** Exceptions for TorchScript support includes ```Compose```, ```RandomChoice```, ```RandomOrder```, ```Lambda``` and those applied on PIL images, such as ```ToPILImage```.","__index_level_0__":591}
+{"text":"## [Stable] Native image IO for JPEG and PNG formats\ntorchvision 0.8.0 introduces native image reading and writing operations for JPEG and PNG formats. Those operators support TorchScript and return ```CxHxW``` tensors in ```uint8``` format, and can thus be now part of your model for deployment in C++ environments.\n```python\nfrom torchvision.io import read_image","__index_level_0__":592}
+{"text":"# tensor_image is a CxHxW uint8 Tensor\ntensor_image = read_image('path_to_image.jpeg')","__index_level_0__":593}
+{"text":"# or equivalently\nfrom torchvision.io import read_file, decode_image\n# raw_data is a 1d uint8 Tensor with the raw bytes\nraw_data = read_file('path_to_image.jpeg')\ntensor_image = decode_image(raw_data)","__index_level_0__":594}
+{"text":"# all operators are torchscriptable and can be\n# serialized together with your model torchscript code\nscripted_read_image = torch.jit.script(read_image)\n```\n## [Stable] RetinaNet detection model\nThis release adds pretrained models for RetinaNet with a ResNet50 backbone from [Focal Loss for Dense Object Detection](https:\/\/arxiv.org\/abs\/1708.02002).","__index_level_0__":595}
+{"text":"## [Beta] New Video Reader API\nThis release introduces a new video reading abstraction, which gives more fine-grained control of iteration over videos. It supports image and audio, and implements an iterator interface so that it is interoperable with other the python libraries such as itertools.\n```python\nfrom torchvision.io import VideoReader","__index_level_0__":596}
+{"text":"# stream indicates if reading from audio or video\nreader = VideoReader('path_to_video.mp4', stream='video')\n# can change the stream after construction\n# via reader.set_current_stream","__index_level_0__":597}
+{"text":"# to read all frames in a video starting at 2 seconds\nfor frame in reader.seek(2):\n    # frame is a dict with \"data\" and \"pts\" metadata\n    print(frame[\"data\"], frame[\"pts\"])","__index_level_0__":598}
+{"text":"# because reader is an iterator you can combine it with\n# itertools\nfrom itertools import takewhile, islice\n# read 10 frames starting from 2 seconds\nfor frame in islice(reader.seek(2), 10):\n    pass\n    \n# or to return all frames between 2 and 5 seconds\nfor frame in takewhile(lambda x: x[\"pts\"] < 5, reader):\n    pass\n```\n**Notes:**\n* In order to use the Video Reader API beta, you must compile torchvision from source and have ffmpeg installed in your system.\n* The VideoReader API is currently released as beta and its API may change following user feedback.","__index_level_0__":599}
+{"text":"# torchaudio\nWith this release, torchaudio is expanding its support for models and [end-to-end applications](https:\/\/github.com\/pytorch\/audio\/tree\/master\/examples), adding a wav2letter training pipeline and end-to-end text-to-speech and source separation pipelines. Please file an issue on [github](https:\/\/github.com\/pytorch\/audio\/issues\/new?template=questions-help-support.md) to provide feedback on them.","__index_level_0__":600}
+{"text":"## [Stable] Speech Recognition\nBuilding on the addition of the wav2letter model for speech recognition in the last release, we\u2019ve now added an [example wav2letter training pipeline](https:\/\/github.com\/pytorch\/audio\/tree\/master\/examples\/pipeline_wav2letter) with the LibriSpeech dataset.","__index_level_0__":601}
+{"text":"## [Stable] Text-to-speech\nWith the goal of supporting text-to-speech applications, we added a vocoder based on the WaveRNN model, based on the implementation from [this repository](https:\/\/github.com\/fatchord\/WaveRNN). The original implementation was introduced in \"Efficient Neural Audio Synthesis\". We also provide an [example WaveRNN training pipeline](https:\/\/github.com\/pytorch\/audio\/tree\/master\/examples\/pipeline_wavernn) that uses the LibriTTS dataset added to torchaudio in this release.","__index_level_0__":602}
+{"text":"## [Stable] Source Separation\nWith the addition of the ConvTasNet model, based on the paper \"Conv-TasNet: Surpassing Ideal Time-Frequency Magnitude Masking for Speech Separation,\" torchaudio now also supports source separation. An [example ConvTasNet training pipeline](https:\/\/github.com\/pytorch\/audio\/tree\/master\/examples\/source_separation) is provided with the wsj-mix dataset.","__index_level_0__":603}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.7-released\/ \n category: pytorch blogs","__index_level_0__":605}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Adding a Contributor License Agreement for PyTorch'\nauthor: Team PyTorch\n---","__index_level_0__":606}
+{"text":"To ensure the ongoing growth and success of the framework, we're introducing the use of the Apache Contributor License Agreement (CLA) for PyTorch. We care deeply about the broad community of contributors who make PyTorch such a great framework, so we want to take a moment to explain why we are adding a CLA.","__index_level_0__":607}
+{"text":"#### Why Does PyTorch Need a CLA?","__index_level_0__":608}
+{"text":"CLAs help clarify that users and maintainers have the relevant rights to use and maintain code contributed to an open source project, while allowing contributors to retain ownership rights to their code. ","__index_level_0__":609}
+{"text":"PyTorch has grown from a small group of enthusiasts to a now global community with over 1,600 contributors from dozens of countries, each bringing their own diverse perspectives, values and approaches to collaboration. Looking forward, clarity about how this collaboration is happening is an important milestone for the framework as we continue to build a stronger, safer and more scalable community around PyTorch. ","__index_level_0__":610}
+{"text":"The text of the Apache CLA can be found [here](https:\/\/www.apache.org\/licenses\/contributor-agreements.html), together with an accompanying [FAQ](https:\/\/www.apache.org\/licenses\/cla-faq.html). The language in the PyTorch CLA is identical to the Apache template. Although CLAs have been the subject of significant discussion in the open source community, we are seeing that using a CLA, and particularly the Apache CLA, is now standard practice when projects and communities reach a certain scale. Popular projects that have adopted some type of CLA include: Visual Studio Code, Flutter, TensorFlow, kubernetes, Ubuntu, Django, Python, Go, Android and many others.","__index_level_0__":611}
+{"text":"#### What is Not Changing","__index_level_0__":612}
+{"text":"PyTorch\u2019s BSD license is **not** changing. There is no impact to PyTorch users. CLAs will only be required for new contributions to the project. For past contributions, no action is necessary. Everything else stays the same, whether it\u2019s IP ownership, workflows, contributor roles or anything else that you\u2019ve come to expect from PyTorch. ","__index_level_0__":613}
+{"text":"#### How the New CLA will Work","__index_level_0__":614}
+{"text":"Moving forward, all contributors to projects under the PyTorch GitHub organization will need to sign a CLA to merge their contributions. ","__index_level_0__":615}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/clacheck.png\" width=\"70%\">\n<\/div>","__index_level_0__":616}
+{"text":"If you've contributed to other Facebook Open Source projects, you may have already signed the CLA, and no action is required. If you have not signed the CLA, a GitHub check will prompt you to sign it before your pull requests can be merged. You can reach the CLA from this [link](https:\/\/code.facebook.com\/cla).","__index_level_0__":617}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/clafb.png\" width=\"70%\">\n<\/div>","__index_level_0__":618}
+{"text":"If you're contributing as an individual, meaning the code is not something you worked on as part of your job, you should sign the individual contributor agreement. This agreement associates your GitHub username with future contributions and only needs to be signed once.","__index_level_0__":619}
+{"text":"If you're contributing as part of your employment, you may need to sign the [corporate contributor agreement](https:\/\/code.facebook.com\/cla\/corporate). Check with your legal team on filling this out. Also you will include a list of github ids from your company.","__index_level_0__":620}
+{"text":"As always, we continue to be humbled and grateful for all your support, and we look forward to scaling PyTorch together to even greater heights in the years to come.","__index_level_0__":621}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/a-contributor-license-agreement-for-pytorch\/ \n category: pytorch blogs","__index_level_0__":623}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Feature Extraction in TorchVision using Torch FX'\nauthor: Alexander Soare and Francisco Massa\nfeatured-img: 'assets\/images\/fx-image2.png'\n---","__index_level_0__":624}
+{"text":"<style type=\"text\/css\">\narticle.pytorch-article table tr th, article.pytorch-article table td {line-height: 1.5rem}\n<\/style>","__index_level_0__":625}
+{"text":"# Introduction","__index_level_0__":626}
+{"text":"[FX](https:\/\/pytorch.org\/docs\/stable\/fx.html) based feature extraction is a new [TorchVision utility](https:\/\/pytorch.org\/vision\/stable\/feature_extraction.html) that lets us access intermediate transformations of an input during the forward pass of a PyTorch Module. It does so by symbolically tracing the forward method to produce a graph where each node represents a single operation. Nodes are named in a human-readable manner such that one may easily specify which nodes they want to access.","__index_level_0__":627}
+{"text":"Did that all sound a little complicated? Not to worry as there\u2019s a little in this article for everyone. Whether you\u2019re a beginner or an advanced deep-vision practitioner, chances are you will want to know about FX feature extraction. If you still want more background on feature extraction in general, read on. If you\u2019re already comfortable with that and want to know how to do it in PyTorch, skim ahead to Existing Methods in PyTorch: Pros and Cons. And if you already know about the challenges of doing feature extraction in PyTorch, feel free to skim forward to FX to The Rescue.","__index_level_0__":628}
+{"text":"\n## A Recap On Feature Extraction","__index_level_0__":629}
+{"text":"We\u2019re all used to the idea of having a deep neural network (DNN) that takes inputs and produces outputs, and we don\u2019t necessarily think of what happens in between. Let\u2019s just consider a ResNet-50 classification model as an example:","__index_level_0__":630}
+{"text":"<p align=\"center\">\n\t<img src=\"{{ site.url }}\/assets\/images\/fx-image1.png\" alt=\"CResNet-50 takes an image of a bird and transforms that into the abstract concept 'bird'\" width=\"100%\">\n\t<br>\n\t\tFigure 1: ResNet-50 takes an image of a bird and transforms that into the abstract concept \"bird\". Source: Bird image from ImageNet.\n<\/p>","__index_level_0__":631}
+{"text":"We know though, that there are many sequential \u201clayers\u201d within the ResNet-50 architecture that transform the input step-by-step. In Figure 2 below, we peek under the hood to show the layers within ResNet-50, and we also show the intermediate transformations of the input as it passes through those layers.","__index_level_0__":632}
+{"text":"<p align=\"center\">\n\t<img src=\"{{ site.url }}\/assets\/images\/fx-image2.png\" alt=\"ResNet-50 transforms the input image in multiple steps. Conceptually, we may access the intermediate transformation of the image after each one of these steps.\" width=\"100%\">\n\t<br>\n\t\tFigure 2: ResNet-50 transforms the input image in multiple steps. Conceptually, we may access the intermediate transformation of the image after each one of these steps. Source: Bird image from ImageNet.\n<\/p>","__index_level_0__":633}
+{"text":"\n## Existing Methods In PyTorch: Pros and Cons","__index_level_0__":634}
+{"text":"There were already a few ways of doing feature extraction in PyTorch prior to FX based feature extraction being introduced.","__index_level_0__":635}
+{"text":"To illustrate these, let\u2019s consider a simple convolutional neural network that does the following","__index_level_0__":636}
+{"text":"* Applies several \u201cblocks\u201d each with several convolution layers within.\n* After several blocks, it uses a global average pool and flatten operation.\n* Finally it uses a single output classification layer.","__index_level_0__":637}
+{"text":"```python\nimport torch\nfrom torch import nn","__index_level_0__":638}
+{"text":"\nclass ConvBlock(nn.Module):\n   \"\"\"\n   Applies `num_layers` 3x3 convolutions each followed by ReLU then downsamples\n   via 2x2 max pool.\n   \"\"\"","__index_level_0__":639}
+{"text":"   def __init__(self, num_layers, in_channels, out_channels):\n       super().__init__()\n       self.convs = nn.ModuleList(\n           [nn.Sequential(\n               nn.Conv2d(in_channels if i==0 else out_channels, out_channels, 3, padding=1),\n               nn.ReLU()\n            )\n            for i in range(num_layers)]\n       )\n       self.downsample = nn.MaxPool2d(kernel_size=2, stride=2)\n      \n   def forward(self, x):\n       for conv in self.convs:\n           x = conv(x)\n       x = self.downsample(x)\n       return x\n      ","__index_level_0__":640}
+{"text":"class CNN(nn.Module):\n   \"\"\"\n   Applies several ConvBlocks each doubling the number of channels, and\n   halving the feature map size, before taking a global average and classifying.\n   \"\"\"","__index_level_0__":641}
+{"text":"   def __init__(self, in_channels, num_blocks, num_classes):\n       super().__init__()\n       first_channels = 64\n       self.blocks = nn.ModuleList(\n           [ConvBlock(\n               2 if i==0 else 3,\n               in_channels=(in_channels if i == 0 else first_channels*(2**(i-1))),\n               out_channels=first_channels*(2**i))\n            for i in range(num_blocks)]\n       )\n       self.global_pool = nn.AdaptiveAvgPool2d((1, 1))\n       self.cls = nn.Linear(first_channels*(2**(num_blocks-1)), num_classes)","__index_level_0__":642}
+{"text":"   def forward(self, x):\n       for block in self.blocks:\n           x = block(x)\n       x = self.global_pool(x)\n       x = x.flatten(1)\n       x = self.cls(x)\n       return x","__index_level_0__":643}
+{"text":"\nmodel = CNN(3, 4, 10)\nout = model(torch.zeros(1, 3, 32, 32))  # This will be the final logits over classes","__index_level_0__":644}
+{"text":"Let\u2019s say we want to get the final feature map before global average pooling. We could do the following:","__index_level_0__":646}
+{"text":"### Modify the forward method","__index_level_0__":647}
+{"text":"```python\ndef forward(self, x):\n   for block in self.blocks:\n       x = block(x)\n   self.final_feature_map = x\n   x = self.global_pool(x)\n   x = x.flatten(1)\n   x = self.cls(x)\n   return x\n```","__index_level_0__":648}
+{"text":"Or return it directly:","__index_level_0__":649}
+{"text":"```python\ndef forward(self, x):\n   for block in self.blocks:\n       x = block(x)\n   final_feature_map = x\n   x = self.global_pool(x)\n   x = x.flatten(1)\n   x = self.cls(x)\n   return x, final_feature_map\n```\nThat looks pretty easy. But there are some downsides here which all stem from the same underlying issue: that is, modifying the source code is not ideal:","__index_level_0__":650}
+{"text":"* It\u2019s not always easy to access and change given the practical considerations of a project.\n* If we want flexibility (switching feature extraction on or off, or having variations on it), we need to further adapt the source code to support that.\n* It\u2019s not always just a question of inserting a single line of code. Think about how you would go about getting the feature map from one of the intermediate blocks with the way I\u2019ve written this module.\n* Overall, we\u2019d rather avoid the overhead of maintaining source code for a model, when we actually don\u2019t need to change anything about how it works.","__index_level_0__":651}
+{"text":"One can see how this downside can start to get a lot more thorny when dealing with larger, more complicated models, and trying to get at features from within nested submodules.","__index_level_0__":652}
+{"text":"### Write a new module using the parameters from the original one","__index_level_0__":653}
+{"text":"Following on the example from above, say we want to get a feature map from each block. We could write a new module like so:","__index_level_0__":654}
+{"text":"```python\nclass CNNFeatures(nn.Module):\n   def __init__(self, backbone):\n       super().__init__()\n       self.blocks = backbone.blocks","__index_level_0__":655}
+{"text":"   def forward(self, x):\n       feature_maps = []\n       for block in self.blocks:\n           x = block(x)\n           feature_maps.append(x)\n       return feature_maps","__index_level_0__":656}
+{"text":"\nbackbone = CNN(3, 4, 10)\nmodel = CNNFeatures(backbone)\nout = model(torch.zeros(1, 3, 32, 32))  # This is now a list of Tensors, each representing a feature map\n```","__index_level_0__":657}
+{"text":"In fact, this is much like the method that TorchVision used internally to make many of its detection models. ","__index_level_0__":658}
+{"text":"Although this approach solves some of the issues with modifying the source code directly, there are still some major downsides:","__index_level_0__":659}
+{"text":"* It\u2019s only really straight-forward to access the outputs of top-level submodules. Dealing with nested submodules rapidly becomes complicated.\n* We have to be careful not to miss any important operations in between the input and the output. We introduce potential for errors in transcribing the exact functionality of the original module to the new module.","__index_level_0__":660}
+{"text":"Overall, this method and the last both have the complication of tying in feature extraction with the model\u2019s source code itself. Indeed, if we examine the source code for TorchVision models we might suspect that some of the design choices were influenced by the desire to use them in this way for downstream tasks.","__index_level_0__":661}
+{"text":"### Use hooks","__index_level_0__":662}
+{"text":"Hooks move us away from the paradigm of writing source code, towards one of specifying outputs. Considering our toy CNN example above, and the goal of getting feature maps for each layer, we could use hooks like this:","__index_level_0__":663}
+{"text":"\n```python\nmodel = CNN(3, 4, 10)\nfeature_maps = []  # This will be a list of Tensors, each representing a feature map","__index_level_0__":664}
+{"text":"def hook_feat_map(mod, inp, out):\n\tfeature_maps.append(out)","__index_level_0__":665}
+{"text":"for block in model.blocks:\n\tblock.register_forward_hook(hook_feat_map)","__index_level_0__":666}
+{"text":"out = model(torch.zeros(1, 3, 32, 32))  # This will be the final logits over classes\n```","__index_level_0__":667}
+{"text":"Now we have full flexibility in terms of accessing nested submodules, and we free ourselves of the responsibilities of fiddling with the source code. But this approach comes with its own downsides:","__index_level_0__":668}
+{"text":"* We can only apply hooks to modules. If we have functional operations (reshape, view, functional non-linearities, etc) for which we want the outputs, hooks won\u2019t work directly on them.\n* We have not modified anything about the source code, so the whole forward pass is executed, regardless of the hooks. If we only need to access early features without any need for the final output, this could result in a lot of useless computation.\n* Hooks are not TorchScript friendly.","__index_level_0__":669}
+{"text":"Here\u2019s a summary of the different methods and their pros\/cons:","__index_level_0__":670}
+{"text":"\n|                                                                   | Can use source code as is without any modifications or rewriting  | Full flexibility in accessing features                                                 | Drops unnecessary computational steps  | TorchScript friendly |\n|-------------------------------------------------------------------|:-----------------------------------------------------------------:|:--------------------------------------------------------------------------------------:|:--------------------------------------:|:--------------------:|\n| Modify forward method                                             | NO                                                                | Technically yes. Depends on how much code you\u2019re willing to write. So in practice, NO. | YES                                    | YES                  |                     \n|-------------------------------------------------------------------|:-----------------------------------------------------------------:|:--------------------------------------------------------------------------------------:|:--------------------------------------:|:--------------------:|\n| New module that reuses submodules \/ parameters of original module | NO                                                                | Technically yes. Depends on how much code you\u2019re willing to write. So in practice, NO. | YES                                    | YES                  |\n|-------------------------------------------------------------------|:-----------------------------------------------------------------:|:--------------------------------------------------------------------------------------:|:--------------------------------------:|:--------------------:|\n| Hooks                                                             | YES                                                               | Mostly YES. Only outputs of submodules                                                 | NO                                     | NO                   |\n|-------------------------------------------------------------------|:-----------------------------------------------------------------:|:--------------------------------------------------------------------------------------:|:--------------------------------------:|:--------------------:|","__index_level_0__":671}
+{"text":"Table 1: The pros (or cons) of some of the existing methods for feature extraction with PyTorch","__index_level_0__":672}
+{"text":"In the next section of this article, let\u2019s see how we can get YES across the board.","__index_level_0__":673}
+{"text":"\n## FX to The Rescue","__index_level_0__":674}
+{"text":"The natural question for some new-starters in Python and coding at this point might be: *\u201cCan\u2019t we just point to a line of code and tell Python or PyTorch that we want the result of that line?\u201d* For those who have spent more time coding, the reason this can\u2019t be done is clear: multiple operations can happen in one line of code, whether they are explicitly written there, or they are implicit as sub-operations. Just take this simple module as an example:","__index_level_0__":675}
+{"text":"```python\nclass MyModule(torch.nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.param = torch.nn.Parameter(torch.rand(3, 4))\n        self.submodule = MySubModule()","__index_level_0__":676}
+{"text":"    def forward(self, x):\n        return self.submodule(x + self.param).clamp(min=0.0, max=1.0)\n```","__index_level_0__":677}
+{"text":"The forward method has a single line of code which we can unravel as:","__index_level_0__":678}
+{"text":"1. Add `self.param` to `x`\n2. Pass x through self.submodule. Here we would need to consider the steps happening in that submodule. I\u2019m just going to use dummy operation names for illustration:\n\tI. submodule.op_1\n\tII. submodule.op_2\n3. Apply the clamp operation","__index_level_0__":679}
+{"text":"So even if we point at this one line, the question then is: \u201cFor which step do we want to extract the output?\u201d.","__index_level_0__":680}
+{"text":"[FX](https:\/\/pytorch.org\/docs\/stable\/fx.html) is a core PyTorch toolkit that (oversimplifying) does the unravelling I just mentioned. It does something called \u201csymbolic tracing\u201d, which means the Python code is interpreted and stepped through, operation-by-operation, using some dummy proxy for a real input. Introducing some nomenclature, each step as described above is considered a **\u201cnode\u201d**, and consecutive nodes are connected to one another to form a **\u201cgraph\u201d** (not unlike the common mathematical notion of a graph). Here are the \u201csteps\u201d above translated to this concept of a graph.","__index_level_0__":681}
+{"text":"<p align=\"center\">\n\t<img src=\"{{ site.url }}\/assets\/images\/fx-image4.png\" alt=\"Graphical representation of the result of symbolically tracing our example of a simple forward method.\" width=\"50%\">\n\t<br>\n\t\tFigure 3: Graphical representation of the result of symbolically tracing our example of a simple forward method.\n<\/p>","__index_level_0__":682}
+{"text":"Note that we call this a graph, and not just a set of steps, because it\u2019s possible for the graph to branch off and recombine. Think of the skip connection in a residual block. This would look something like:","__index_level_0__":683}
+{"text":"<p align=\"center\">\n\t<img src=\"{{ site.url }}\/assets\/images\/fx-image5.png\" alt=\"Graphical representation of a residual skip connection. The middle node is like the main branch of a residual block, and the final node represents the sum of the input and output of the main branch.\" width=\"25%\">\n\t<br>\n\t\tFigure 4: Graphical representation of a residual skip connection. The middle node is like the main branch of a residual block, and the final node represents the sum of the input and output of the main branch.\n<\/p>","__index_level_0__":684}
+{"text":"Now, TorchVision\u2019s **[get_graph_node_names](https:\/\/pytorch.org\/vision\/stable\/feature_extraction.html#torchvision.models.feature_extraction.get_graph_node_names)** function applies FX as described above, and in the process of doing so, tags each node with a human readable name. Let\u2019s try this with our toy CNN model from the previous section:","__index_level_0__":685}
+{"text":"```python\nmodel = CNN(3, 4, 10)\nfrom torchvision.models.feature_extraction import get_graph_node_names\nnodes, _ = get_graph_node_names(model)\nprint(nodes)\n```\nwhich will result in:\n```python\n['x', 'blocks.0.convs.0.0', 'blocks.0.convs.0.1', 'blocks.0.convs.1.0', 'blocks.0.convs.1.1', 'blocks.0.downsample', 'blocks.1.convs.0.0', 'blocks.1.convs.0.1', 'blocks.1.convs.1.0', 'blocks.1.convs.1.1', 'blocks.1.convs.2.0', 'blocks.1.convs.2.1', 'blocks.1.downsample', 'blocks.2.convs.0.0', 'blocks.2.convs.0.1', 'blocks.2.convs.1.0', 'blocks.2.convs.1.1', 'blocks.2.convs.2.0', 'blocks.2.convs.2.1', 'blocks.2.downsample', 'blocks.3.convs.0.0', 'blocks.3.convs.0.1', 'blocks.3.convs.1.0', 'blocks.3.convs.1.1', 'blocks.3.convs.2.0', 'blocks.3.convs.2.1', 'blocks.3.downsample', 'global_pool', 'flatten', 'cls']\n```","__index_level_0__":686}
+{"text":"We can read these node names as hierarchically organised \u201caddresses\u201d for the operations of interest. For example 'blocks.1.downsample' refers to the MaxPool2d layer in the second `ConvBlock`.","__index_level_0__":687}
+{"text":"[`create_feature_extractor`](https:\/\/pytorch.org\/vision\/stable\/feature_extraction.html#torchvision.models.feature_extraction.create_feature_extractor), which is where all the magic happens, goes a few steps further than **`get_graph_node_names`**. It takes desired node names as one of the input arguments, and then uses more FX core functionality to:","__index_level_0__":688}
+{"text":"1. Assign the desired nodes as outputs.\n2. Prune unnecessary downstream nodes and their associated parameters.\n3. Translate the resulting graph back into Python code.\n4. Return another PyTorch Module to the user. This has the python code from step 3 as the forward method.","__index_level_0__":689}
+{"text":"As a demonstration, here\u2019s how we would apply `create_feature_extractor` to get the 4 feature maps from our toy CNN model","__index_level_0__":690}
+{"text":"```python\nfrom torchvision.models.feature_extraction import create_feature_extractor\n# Confused about the node specification here?\n# We are allowed to provide truncated node names, and `create_feature_extractor`\n# will choose the last node with that prefix.\nfeature_extractor = create_feature_extractor(\n\tmodel, return_nodes=['blocks.0', 'blocks.1', 'blocks.2', 'blocks.3'])\n# `out` will be a dict of Tensors, each representing a feature map\nout = feature_extractor(torch.zeros(1, 3, 32, 32))\n```","__index_level_0__":691}
+{"text":"It\u2019s as simple as that. When it comes down to it, FX feature extraction is just a way of making it possible to do what some of us would have naively hoped for when we first started programming: *\u201cjust give me the output of this code (*points finger at screen)\u201d*.","__index_level_0__":692}
+{"text":"- [ ] \u2026 does not require us to fiddle with source code.\n- [ ] \u2026 provides full flexibility in terms of accessing any intermediate transformation of our inputs, whether they are the results of a module or a functional operation\n- [ ] \u2026 does drop unnecessary computations steps once features have been extracted\n- [ ] \u2026 and I didn\u2019t mention this before, but it\u2019s also TorchScript friendly!","__index_level_0__":693}
+{"text":"Here\u2019s that table again with another row added for FX feature extraction","__index_level_0__":694}
+{"text":"\n|                                                                   | Can use source code as is without any modifications or rewriting  | Full flexibility in accessing features                                                 | Drops unnecessary computational steps  | TorchScript friendly |\n|-------------------------------------------------------------------|:-----------------------------------------------------------------:|:--------------------------------------------------------------------------------------:|:--------------------------------------:|:--------------------:|\n| Modify forward method                                             | NO                                                                | Technically yes. Depends on how much code you\u2019re willing to write. So in practice, NO. | YES                                    | YES                  |                     \n|-------------------------------------------------------------------|:-----------------------------------------------------------------:|:--------------------------------------------------------------------------------------:|:--------------------------------------:|:--------------------:|\n| New module that reuses submodules \/ parameters of original module | NO                                                                | Technically yes. Depends on how much code you\u2019re willing to write. So in practice, NO. | YES                                    | YES                  |\n|-------------------------------------------------------------------|:-----------------------------------------------------------------:|:--------------------------------------------------------------------------------------:|:--------------------------------------:|:--------------------:|\n| Hooks                                                             | YES                                                               | Mostly YES. Only outputs of submodules                                                 | NO                                     | NO                   |\n|-------------------------------------------------------------------|:-----------------------------------------------------------------:|:--------------------------------------------------------------------------------------:|:--------------------------------------:|:--------------------:|\n| FX                                                                | YES                                                               | YES                                                                                    | YES                                    | YES                  |\n|-------------------------------------------------------------------|:-----------------------------------------------------------------:|:--------------------------------------------------------------------------------------:|:--------------------------------------:|:--------------------:|","__index_level_0__":695}
+{"text":"Table 2: A copy of Table 1 with an added row for FX feature extraction. FX feature extraction gets YES across the board!","__index_level_0__":696}
+{"text":"\n## Current FX Limitations","__index_level_0__":697}
+{"text":"Although I would have loved to end the post there, FX does have some of its own limitations which boil down to:","__index_level_0__":698}
+{"text":"1. There may be some Python code that isn\u2019t yet handled by FX when it comes to the step of interpretation and translation into a graph.\n2. Dynamic control flow can\u2019t be represented in terms of a static graph.","__index_level_0__":699}
+{"text":"The easiest thing to do when these problems crop up is to bundle the underlying code into a \u201cleaf node\u201d. Recall the example graph from Figure 3? Conceptually, we may agree that the `submodule` should be treated as a node in itself rather than a set of nodes representing the underlying operations. If we do so, we can redraw the graph as:","__index_level_0__":700}
+{"text":"<p align=\"center\">\n\t<img src=\"{{ site.url }}\/assets\/images\/fx-image6.png\" alt=\"The individual operations within `submodule` may (left - within red box), may be consolidated into one node (right - node #2) if we consider the `submodule` as a 'leaf' node.\" width=\"100%\">\n\t<br>\n\t\tFigure 5: The individual operations within `submodule` may (left - within red box), may be consolidated into one node (right - node #2) if we consider the `submodule` as a \"leaf\" node.\n<\/p>","__index_level_0__":701}
+{"text":"\nWe would want to do so if there is some problematic code within the submodule, but we don\u2019t have any need for extracting any intermediate transformations from within it. In practice, this is easily achievable by providing a keyword argument to create_feature_extractor or get_graph_node_names.","__index_level_0__":702}
+{"text":"\n```python\nmodel = CNN(3, 4, 10)\nnodes, _ = get_graph_node_names(model, tracer_kwargs={'leaf_modules': [ConvBlock]})\nprint(nodes)\n```","__index_level_0__":703}
+{"text":"for which the output will be:","__index_level_0__":704}
+{"text":"```python\n['x', 'blocks.0', 'blocks.1', 'blocks.2', 'blocks.3', 'global_pool', 'flatten', 'cls']\n```","__index_level_0__":705}
+{"text":"Notice how, as compared to previously, all the nodes for any given `ConvBlock` are consolidated into a single node.","__index_level_0__":706}
+{"text":"We could do something similar with functions. For example, Python\u2019s inbuilt `len` needs to be wrapped and the result should be treated as a leaf node. Here\u2019s how you can do that with core FX functionality:","__index_level_0__":707}
+{"text":"```python\ntorch.fx.wrap('len')","__index_level_0__":708}
+{"text":"class MyModule(nn.Module):\n   def forward(self, x):\n       x += 1\n       len(x)","__index_level_0__":709}
+{"text":"model = MyModule()\nfeature_extractor = create_feature_extractor(model, return_nodes=['add'])\n```","__index_level_0__":710}
+{"text":"For functions you define, you may instead use another keyword argument to `create_feature_extractor` (minor detail: here\u2019s[ why you might want to do it this way instead](https:\/\/github.com\/pytorch\/pytorch\/issues\/62021#issue-950458396)):","__index_level_0__":711}
+{"text":"\n```python\ndef myfunc(x):\n   return len(x)","__index_level_0__":712}
+{"text":"class MyModule(nn.Module):\n   def forward(self, x):\n       x += 1\n       myfunc(x)","__index_level_0__":713}
+{"text":"model = MyModule()\nfeature_extractor = create_feature_extractor(\n   model, return_nodes=['add'], tracer_kwargs={'autowrap_functions': [myfunc]})\n```","__index_level_0__":714}
+{"text":"Notice that none of the fixes above involved modifying source code.","__index_level_0__":715}
+{"text":"Of course, there may be times when the very intermediate transformation one is trying to get access to is within the same forward method or function that is causing problems. Here, we can\u2019t just treat that module or function as a leaf node, because then we can\u2019t access the intermediate transformations within. In these cases, some rewriting of the source code will be needed. Here are some examples (not exhaustive)","__index_level_0__":716}
+{"text":"- FX will raise an error when trying to trace through code with an `assert` statement.  In this case you may need to remove that assertion or switch it with [`torch._assert`](https:\/\/pytorch.org\/docs\/stable\/generated\/torch._assert.html) (this is not a public function - so consider it a bandaid and use with caution).\n- Symbolically tracing in-place changes to slices of tensors is not supported. You will need to make a new variable for the slice, apply the operation, then reconstruct the original tensor using concatenation or stacking.\n- Representing dynamic control flow in a static graph is just not logically possible. See if you can distill the coded logic down to something that is not dynamic - see FX documentation for tips.","__index_level_0__":717}
+{"text":"In general, you may consult the FX documentation for more detail on the [limitations of symbolic tracing](https:\/\/pytorch.org\/docs\/stable\/fx.html#limitations-of-symbolic-tracing) and the possible workarounds.","__index_level_0__":718}
+{"text":"## Conclusion","__index_level_0__":719}
+{"text":"We did a quick recap on feature extraction and why one might want to do it. Although there are existing methods for doing feature extraction in PyTorch they all have rather significant shortcomings. We learned how TorchVision\u2019s FX feature extraction utility works and what makes it so versatile compared to the existing methods. While there are still some minor kinks to iron out for the latter, we understand the limitations, and can trade them off against the limitations of other methods depending on our use case. Hopefully by adding this new utility to your PyTorch toolkit, you\u2019re now equipped to handle the vast majority of feature extraction requirements you may come across.","__index_level_0__":720}
+{"text":"Happy coding!\n \n source: https:\/\/pytorch.org\/blog\/FX-feature-extraction-torchvision\/ \n category: pytorch blogs","__index_level_0__":721}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch Ecosystem Day 2021 Recap and New Contributor Resources'\nauthor: Team PyTorch\n---","__index_level_0__":722}
+{"text":"Thank you to our incredible community for making the first ever PyTorch Ecosystem Day a success! The day was filled with discussions on new developments, trends and challenges showcased through 71 posters, 32 breakout sessions and 6 keynote speakers. ","__index_level_0__":723}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/ecosystem-day-thank-you.png\" width=\"70%\">\n<\/div>","__index_level_0__":724}
+{"text":"Special thanks to our keynote speakers: Piotr Bialecki, Ritchie Ng, Miquel Farr\u00e9, Joe Spisak, Geeta Chauhan, and Suraj Subramanian who shared updates from the latest release of PyTorch, exciting work being done with partners, use case example from Disney, the growth and development of the PyTorch community in Asia Pacific, and latest contributor highlights.","__index_level_0__":725}
+{"text":"If you missed the opening talks, you rewatch them here:\n* [Morning\/EMEA Opening Talks](https:\/\/www.youtube.com\/watch?v=MYE01-XaSZA)\n* [Evening\/APAC Opening Talks](https:\/\/www.youtube.com\/watch?v=CjU_6OaYKpw)","__index_level_0__":726}
+{"text":"In addition to the talks, we had 71 posters covering various topics such as multimodal, NLP, compiler, distributed training, researcher productivity tools, AI accelerators, and more. From the event, it was clear that an underlying thread that ties all of these different projects together is the cross-collaboration of the PyTorch community. Thank you for continuing to push the state of the art with PyTorch! ","__index_level_0__":727}
+{"text":"To view the full catalogue of poster, please visit **[PyTorch Ecosystem Day 2021 Event Page](https:\/\/pytorch.org\/ecosystem\/pted\/2021)**.  ","__index_level_0__":728}
+{"text":"### New Contributor Resources \nToday, we are also sharing new contributor resources that we are trying out to give you the most access to up-to-date news, networking opportunities and more. \n* [Contributor Newsletter](https:\/\/pytorch.org\/resources\/contributors\/) - Includes curated news including RFCs, feature roadmaps, notable PRs, editorials from developers, and more to support keeping track of everything that\u2019s happening in our community. \n* [Contributors Discussion Forum](https:\/\/dev-discuss.pytorch.org\/) - Designed for contributors to learn and collaborate on the latest development across PyTorch. \n* [PyTorch Developer Podcast (Beta)](https:\/\/pytorch-dev-podcast.simplecast.com\/) - Edward Yang, PyTorch Research Scientist, at Facebook AI shares bite-sized (10 to 20 mins) podcast episodes discussing topics about all sorts of internal development topics in PyTorch.","__index_level_0__":729}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/ecosystem-day-2021-recap\/ \n category: pytorch blogs","__index_level_0__":731}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Geospatial deep learning with TorchGeo\"\nauthor: Adam Stewart (University of Illinois at Urbana-Champaign), Caleb Robinson (Microsoft AI for Good Research Lab), Isaac Corley (University of Texas at San Antonio)\nfeatured-img: 'assets\/images\/torchgeo-hurricane.jpg'\n---","__index_level_0__":732}
+{"text":"TorchGeo is a PyTorch domain library providing datasets, samplers, transforms, and pre-trained models specific to geospatial data.","__index_level_0__":733}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/torchgeo-logo.png\" width=\"100%\">\n<\/p>","__index_level_0__":734}
+{"text":"<p align = \"center\">\n  <a href=\"https:\/\/github.com\/microsoft\/torchgeo\">https:\/\/github.com\/microsoft\/torchgeo<\/a>\n<\/p>","__index_level_0__":735}
+{"text":"For decades, Earth observation satellites, aircraft, and more recently UAV platforms have been collecting increasing amounts of imagery of the Earth\u2019s surface. With information about seasonal and long-term trends, remotely sensed imagery can be invaluable for solving some of the greatest challenges to humanity, including climate change adaptation, natural disaster monitoring, water resource management, and food security for a growing global population. From a computer vision perspective, this includes applications like land cover mapping (semantic segmentation), deforestation and flood monitoring (change detection), glacial flow (pixel tracking), hurricane tracking and intensity estimation (regression), and building and road detection (object detection, instance segmentation). By leveraging recent advancements in deep learning architectures, cheaper and more powerful GPUs, and petabytes of freely available satellite imagery datasets, we can come closer to solving these important problems.","__index_level_0__":736}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/torchgeo-hurricane.jpg\" width=\"80%\">\n<\/p>","__index_level_0__":737}
+{"text":"<p align = \"center\">\nNational Oceanic and Atmospheric Administration satellite image of Hurricane Katrina, taken on August 28, 2005 (<a href=\"https:\/\/www.whoi.edu\/know-your-ocean\/ocean-topics\/hazards\/hurricanes\/\">source<\/a>). Geospatial machine learning libraries like TorchGeo can be used to detect, track, and predict future trajectories of hurricanes and other natural disasters.\n<\/p>","__index_level_0__":738}
+{"text":"# The challenges","__index_level_0__":739}
+{"text":"In traditional computer vision datasets, such as ImageNet, the image files themselves tend to be rather simple and easy to work with. Most images have 3 spectral bands (RGB), are stored in common file formats like PNG or JPEG, and can be easily loaded with popular software libraries like [PIL](https:\/\/pillow.readthedocs.io\/en\/stable\/) or [OpenCV](https:\/\/opencv.org\/). Each image in these datasets is usually small enough to pass directly into a neural network. Furthermore, most of these datasets contain a finite number of well-curated images that are assumed to be independent and identically distributed, making train-val-test splits straightforward. As a result of this relative homogeneity, the same pre-trained models (e.g., CNNs pretrained on ImageNet) have shown to be effective across a wide range of vision tasks using transfer learning methods. Existing libraries, such as [torchvision](https:\/\/github.com\/pytorch\/vision), handle these simple cases well, and have been used to make large advances in vision tasks over the past decade.","__index_level_0__":740}
+{"text":"Remote sensing imagery is not so uniform. Instead of simple RGB images, satellites tend to capture images that are multispectral ([Landsat 8](https:\/\/www.usgs.gov\/landsat-missions) has 11 spectral bands) or even hyperspectral ([Hyperion](https:\/\/www.usgs.gov\/centers\/eros\/science\/usgs-eros-archive-earth-observing-one-eo-1-hyperion) has 242 spectral bands). These images capture information at a wider range of wavelengths (400 nm\u201315 \u00b5m), far outside of the visible spectrum. Different satellites also have very different spatial resolutions\u2014[GOES](https:\/\/www.goes.noaa.gov\/) has a resolution of 4 km\/px, [Maxar](https:\/\/www.maxar.com\/products\/satellite-imagery) imagery is 30 cm\/px, and drone imagery resolution can be as high as 7 mm\/px. These datasets almost always have a temporal component, with satellite revisists that are daily, weekly, or biweekly. Images often have overlap with other images in the dataset, and need to be stitched together based on geographic metadata. These images tend to be very large (e.g., 10K x 10K pixels), so it isn't possible to pass an entire image through a neural network. This data is distributed in hundreds of different raster and vector file formats like GeoTIFF and ESRI Shapefile, requiring specialty libraries like [GDAL](https:\/\/gdal.org\/) to load.","__index_level_0__":741}
+{"text":"\n<p align=\"center\">\n  <img src=\"\/assets\/images\/torchgeo-map.png\" width=\"80%\">\n<\/p>","__index_level_0__":742}
+{"text":"\n<p align = \"center\">\nFrom left to right: Mercator, Albers Equal Area, and Interrupted Goode Homolosine projections (<a href=\"https:\/\/scitools.org.uk\/cartopy\/docs\/latest\/reference\/projections.html\">source<\/a>). Geospatial data is associated with one of many different types of reference systems that project the 3D Earth onto a 2D representation. Combining data from different sources often involves re-projecting to a common reference system in order to ensure that all layers are aligned.\n<\/p>","__index_level_0__":743}
+{"text":"Although each image is 2D, the Earth itself is 3D. In order to stitch together images, they first need to be projected onto a 2D representation of the Earth, called a coordinate reference system (CRS). Most people are familiar with equal angle representations like Mercator that distort the size of regions (Greenland looks larger than Africa even though Africa is 15x larger), but there are many other CRSs that are commonly used. Each dataset may use a different CRS, and each image within a single dataset may also be in a unique CRS. In order to use data from multiple layers, they must all share a common CRS, otherwise the data won't be properly aligned. For those who aren't familiar with remote sensing data, this can be a daunting task.","__index_level_0__":744}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/torchgeo-reproject.png\" width=\"80%\">\n<\/p>","__index_level_0__":745}
+{"text":"<p align = \"center\">\nEven if you correctly georeference images during indexing, if you don't project them to a common CRS, you'll end up with rotated images with nodata values around them, and the images won't be pixel-aligned.\n<\/p>","__index_level_0__":746}
+{"text":"# The solution","__index_level_0__":747}
+{"text":"At the moment, it can be quite challenging to work with both deep learning models and geospatial data without having expertise in both of these very different fields. To address these challenges, we've built TorchGeo, a PyTorch domain library for working with geospatial data. TorchGeo is designed to make it simple:","__index_level_0__":748}
+{"text":"1. for machine learning experts to work with geospatial data, and\n2. for remote sensing experts to explore machine learning solutions.","__index_level_0__":749}
+{"text":"TorchGeo is not just a research project, but a production-quality library that uses continuous integration to test every commit with a range of Python versions on a range of platforms (Linux, macOS, Windows). It can be easily installed with any of your favorite package managers, including pip, conda, and [spack](https:\/\/spack.io):","__index_level_0__":750}
+{"text":"```\n$ pip install torchgeo\n```","__index_level_0__":751}
+{"text":"TorchGeo is designed to have the same API as other PyTorch domain libraries like torchvision, torchtext, and torchaudio. If you already use torchvision in your workflow for computer vision datasets, you can switch to TorchGeo by changing only a few lines of code. All TorchGeo datasets and samplers are compatible with the PyTorch ``DataLoader`` class, meaning that you can take advantage of wrapper libraries like [PyTorch Lightning](https:\/\/www.pytorchlightning.ai\/) for distributed training. In the following sections, we'll explore possible use cases for TorchGeo to show how simple it is to use.","__index_level_0__":752}
+{"text":"# Geospatial datasets and samplers","__index_level_0__":753}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/torchgeo-sample.png\" width=\"80%\">\n<\/p>","__index_level_0__":754}
+{"text":"<p align = \"center\">\nExample application in which we combine A) a scene from <a href=\"https:\/\/www.usgs.gov\/landsat-missions\">Landsat 8<\/a> and B) <a href=\"https:\/\/data.nal.usda.gov\/dataset\/cropscape-cropland-data-layer\">Cropland Data Layer<\/a> labels, even though these files are in different EPSG projections. We want to sample patches C) and D) from these datasets using a geospatial bounding box as an index.\n<\/p>","__index_level_0__":755}
+{"text":"Many remote sensing applications involve working with [*geospatial datasets*](https:\/\/torchgeo.readthedocs.io\/en\/latest\/api\/datasets.html#geospatial-datasets) \u2014datasets with geographic metadata. In TorchGeo, we define a ``GeoDataset`` class to represent these kinds of datasets. Instead of being indexed by an integer, each ``GeoDataset`` is indexed by a spatiotemporal bounding box, meaning that two or more datasets covering a different geographic extent can be intelligently combined.","__index_level_0__":756}
+{"text":"In this example, we show how easy it is to work with geospatial data and to sample small image patches from a combination of Landsat and Cropland Data Layer (CDL) data using TorchGeo. First, we assume that the user has Landsat 7 and 8 imagery downloaded. Since Landsat 8 has more spectral bands than Landsat 7, we'll only use the bands that both satellites have in common. We'll create a single dataset including all images from both Landsat 7 and 8 data by taking the union between these two datasets.","__index_level_0__":757}
+{"text":"```c++\nfrom torch.utils.data import DataLoader\nfrom torchgeo.datasets import CDL, Landsat7, Landsat8, stack_samples\nfrom torchgeo.samplers import RandomGeoSampler","__index_level_0__":758}
+{"text":"landsat7 = Landsat7(root=\"...\")\nlandsat8 = Landsat8(root=\"...\", bands=Landsat8.all_bands[1:-2])\nlandsat = landsat7 | landsat8\n```","__index_level_0__":759}
+{"text":"Next, we take the intersection between this dataset and the CDL dataset. We want to take the intersection instead of the union to ensure that we only sample from regions where we have both Landsat and CDL data. Note that we can automatically download and checksum CDL data. Also note that each of these datasets may contain files in different CRSs or resolutions, but TorchGeo automatically ensures that a matching CRS and resolution is used.","__index_level_0__":760}
+{"text":"```c++\ncdl = CDL(root=\"...\", download=True, checksum=True)\ndataset = landsat & cdl\n```","__index_level_0__":761}
+{"text":"This dataset can now be used with a PyTorch data loader. Unlike benchmark datasets, geospatial datasets often include very large images. For example, the CDL dataset consists of a single image covering the entire contiguous United States. In order to sample from these datasets using geospatial coordinates, TorchGeo defines a number of [*samplers*](https:\/\/torchgeo.readthedocs.io\/en\/latest\/api\/samplers.html). In this example, we'll use a random sampler that returns 256 x 256 pixel images and 10,000 samples per epoch. We'll also use a custom collation function to combine each sample dictionary into a mini-batch of samples.","__index_level_0__":762}
+{"text":"```c++\nsampler = RandomGeoSampler(dataset, size=256, length=10000)\ndataloader = DataLoader(dataset, batch_size=128, sampler=sampler, collate_fn=stack_samples)\n```","__index_level_0__":763}
+{"text":"This data loader can now be used in your normal training\/evaluation pipeline.","__index_level_0__":764}
+{"text":"```c++\nfor batch in dataloader:\n    image = batch[\"image\"]\n    mask = batch[\"mask\"]","__index_level_0__":765}
+{"text":"    # train a model, or make predictions using a pre-trained model\n```","__index_level_0__":766}
+{"text":"Many applications involve intelligently composing datasets based on geospatial metadata like this. For example, users may want to:","__index_level_0__":767}
+{"text":"- Combine datasets for multiple image sources and treat them as equivalent (e.g., Landsat 7 and 8)\n- Combine datasets for disparate geospatial locations (e.g., Chesapeake NY and PA)","__index_level_0__":768}
+{"text":"These combinations require that all queries are present in *at least one* dataset, and can be created using a ``UnionDataset``. Similarly, users may want to:","__index_level_0__":769}
+{"text":"- Combine image and target labels and sample from both simultaneously (e.g., Landsat and CDL)\n- Combine datasets for multiple image sources for multimodal learning or data fusion (e.g., Landsat and Sentinel)","__index_level_0__":770}
+{"text":"These combinations require that all queries are present in *both* datasets, and can be created using an ``IntersectionDataset``. TorchGeo automatically composes these datasets for you when you use the intersection (``&``) and union \\(``|``\\) operators.","__index_level_0__":771}
+{"text":"# Multispectral and geospatial transforms","__index_level_0__":772}
+{"text":"In deep learning, it's common to augment and transform the data so that models are robust to variations in the input space. Geospatial data can have variations such as seasonal changes and warping effects, as well as image processing and capture issues like cloud cover and atmospheric distortion. TorchGeo utilizes augmentations and transforms from the [Kornia](https:\/\/kornia.github.io\/) library, which supports GPU acceleration and supports multispectral imagery with more than 3 channels.","__index_level_0__":773}
+{"text":"Traditional geospatial analyses compute and visualize spectral indices which are combinations of multispectral bands. Spectral indices are designed to highlight areas of interest in a multispectral image relevant to some application, such as vegetation health, areas of man-made change or increasing urbanization, or snow cover. TorchGeo supports numerous [*transforms*](https:\/\/torchgeo.readthedocs.io\/en\/latest\/api\/transforms.html), which can compute common spectral indices and append them as additional bands to a multispectral image tensor.","__index_level_0__":774}
+{"text":"Below, we show a simple example where we compute the Normalized Difference Vegetation Index (NDVI) on a Sentinel-2 image. NDVI measures the presence of vegetation and vegetation health and is computed as the normalized difference between the red and near-infrared (NIR) spectral bands. Spectral index transforms operate on sample dictionaries returned from TorchGeo datasets and append the resulting spectral index to the image channel dimension.","__index_level_0__":775}
+{"text":"First, we instantiate a Sentinel-2 dataset and load a sample image. Then, we plot the true color (RGB) representation of this data to see the region we are looking at.","__index_level_0__":776}
+{"text":"```c++\nimport matplotlib.pyplot as plt\nfrom torchgeo.datasets import Sentinel2\nfrom torchgeo.transforms import AppendNDVI","__index_level_0__":777}
+{"text":"dataset = Sentinel2(root=\"...\")\nsample = dataset[...]\nfig = dataset.plot(sample)\nplt.show()\n```","__index_level_0__":778}
+{"text":"Next, we instantiate and compute an NDVI transform, appending this new channel to the end of the image. Sentinel-2 imagery uses index 0 for its red band and index 3 for its NIR band. In order to visualize the data, we also normalize the image. NDVI values can range from -1 to 1, but we want to use the range 0 to 1 for plotting.","__index_level_0__":779}
+{"text":"```c++\ntransform = AppendNDVI(index_red=0, index_nir=3)\nsample = transform(sample)\nsample[\"image\"][-1] = (sample[\"image\"][-1] + 1) \/ 2\nplt.imshow(sample[\"image\"][-1], cmap=\"RdYlGn_r\")\nplt.show()\n```","__index_level_0__":780}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/torchgeo-true-ndvi.png\" width=\"100%\">\n<\/p>","__index_level_0__":781}
+{"text":"<p align = \"center\">\nTrue color (left) and NDVI (right) of the Texas Hill Region, taken on November 16, 2018 by the <a href=\"https:\/\/sentinel.esa.int\/web\/sentinel\/missions\/sentinel-2\">Sentinel-2<\/a> satellite. In the NDVI image, red indicates water bodies, yellow indicates barren soil, light green indicates unhealthy vegetation, and dark green indicates healthy vegetation.\n<\/p>","__index_level_0__":782}
+{"text":"# Benchmark datasets","__index_level_0__":783}
+{"text":"One of the driving factors behind progress in computer vision is the existence of standardized benchmark datasets like ImageNet and MNIST. Using these datasets, researchers can directly compare the performance of different models and training procedures to determine which perform the best. In the remote sensing domain, there are many such datasets, but due to the aforementioned difficulties of working with this data and the lack of existing libraries for loading these datasets, many researchers opt to use their own custom datasets.","__index_level_0__":784}
+{"text":"One of the goals of TorchGeo is to provide easy-to-use data loaders for these existing datasets. TorchGeo includes a number of [*benchmark datasets*](https:\/\/torchgeo.readthedocs.io\/en\/latest\/api\/datasets.html#non-geospatial-datasets) \u2014datasets that include both input images and target labels. This includes datasets for tasks like image classification, regression, semantic segmentation, object detection, instance segmentation, change detection, and more.","__index_level_0__":785}
+{"text":"If you've used torchvision before, these types of datasets should be familiar. In this example, we'll create a dataset for the Northwestern Polytechnical University (NWPU) very-high-resolution ten-class (VHR-10) geospatial object detection dataset. This dataset can be automatically downloaded, checksummed, and extracted, just like with torchvision.","__index_level_0__":786}
+{"text":"```c++\nfrom torch.utils.data import DataLoader\nfrom torchgeo.datasets import VHR10","__index_level_0__":787}
+{"text":"dataset = VHR10(root=\"...\", download=True, checksum=True)\ndataloader = DataLoader(dataset, batch_size=128, shuffle=True, num_workers=4)","__index_level_0__":788}
+{"text":"for batch in dataloader:\n    image = batch[\"image\"]\n    label = batch[\"label\"]","__index_level_0__":789}
+{"text":"    # train a model, or make predictions using a pre-trained model\n```","__index_level_0__":790}
+{"text":"All TorchGeo datasets are compatible with PyTorch data loaders, making them easy to integrate into existing training workflows. The only difference between a benchmark dataset in TorchGeo and a similar dataset in torchvision is that each dataset returns a dictionary with keys for each PyTorch ``Tensor``.","__index_level_0__":791}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/torchgeo-nwpu.png\" width=\"100%\">\n<\/p>","__index_level_0__":792}
+{"text":"<p align = \"center\">\nExample predictions from a Mask R-CNN model trained on the <a href=\"https:\/\/github.com\/chaozhong2010\/VHR-10_dataset_coco\">NWPU VHR-10<\/a> dataset. The model predicts sharp bounding boxes and masks for all objects with high confidence scores.\n<\/p>","__index_level_0__":793}
+{"text":"# Reproducibility with PyTorch Lightning","__index_level_0__":794}
+{"text":"Another key goal of TorchGeo is reproducibility. For many of these benchmark datasets, there is no predefined train-val-test split, or the predefined split has issues with class imbalance or geographic distribution. As a result, the performance metrics reported in the literature either can't be reproduced, or aren't indicative of how well a pre-trained model would work in a different geographic location. ","__index_level_0__":795}
+{"text":"In order to facilitate direct comparisons between results published in the literature and further reduce the boilerplate code needed to run experiments with datasets in TorchGeo, we have created PyTorch Lightning [*datamodules*](https:\/\/torchgeo.readthedocs.io\/en\/latest\/api\/datamodules.html) with well-defined train-val-test splits and [*trainers*](https:\/\/torchgeo.readthedocs.io\/en\/latest\/api\/trainers.html) for various tasks like classification, regression, and semantic segmentation. These datamodules show how to incorporate augmentations from the kornia library, include preprocessing transforms (with pre-calculated channel statistics), and let users easily experiment with hyperparameters related to the data itself (as opposed to the modeling process). Training a semantic segmentation model on the Inria Aerial Image Labeling dataset is as easy as a few imports and four lines of code.","__index_level_0__":796}
+{"text":"```c++\nfrom pytorch_lightning import Trainer\nfrom torchgeo.datamodules import InriaAerialImageLabelingDataModule\nfrom torchgeo.trainers import SemanticSegmentationTask","__index_level_0__":797}
+{"text":"datamodule = InriaAerialImageLabelingDataModule(root_dir=\"...\", batch_size=64, num_workers=6)\ntask = SemanticSegmentationTask(segmentation_model=\"unet\", encoder_weights=\"imagenet\", learning_rate=0.1)\ntrainer = Trainer(gpus=1, default_root_dir=\"...\")","__index_level_0__":798}
+{"text":"trainer.fit(model=task, datamodule=datamodule)\n```","__index_level_0__":799}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/torchgeo-inria.png\" width=\"100%\">\n<\/p>","__index_level_0__":800}
+{"text":"<p align = \"center\">\nBuilding segmentations produced by a U-Net model trained on the <a href=\"https:\/\/project.inria.fr\/aerialimagelabeling\/\">Inria Aerial Image Labeling<\/a> dataset. Reproducing these results is as simple as a few imports and four lines of code, making comparison of different models and training techniques simple and easy.\n<\/p>","__index_level_0__":801}
+{"text":"In our [preprint](https:\/\/arxiv.org\/abs\/2111.08872) we show a set of results that use the aforementioned datamodules and trainers to benchmark simple modeling approaches for several of the datasets in TorchGeo. For example, we find that a simple ResNet-50 can achieve state-of-the-art performance on the [So2Sat](https:\/\/ieeexplore.ieee.org\/document\/9014553) dataset. These types of baseline results are important for evaluating the contribution of different modeling choices when tackling problems with remotely sensed data.","__index_level_0__":802}
+{"text":"# Future work and contributing","__index_level_0__":803}
+{"text":"There is still a lot of remaining work to be done in order to make TorchGeo as easy to use as possible, especially for users without prior deep learning experience. One of the ways in which we plan to achieve this is by expanding our tutorials to include subjects like \"writing a custom dataset\" and \"transfer learning\", or tasks like \"land cover mapping\" and \"object detection\".","__index_level_0__":804}
+{"text":"Another important project we are working on is pre-training models. Most remote sensing researchers work with very small labeled datasets, and could benefit from pre-trained models and transfer learning approaches. TorchGeo is the first deep learning library to provide models pre-trained on multispectral imagery. Our goal is to provide models for different image modalities (optical, SAR, multispectral) and specific platforms (Landsat, Sentinel, MODIS) as well as benchmark results showing their performance with different amounts of training data. Self-supervised learning is a promising method for training such models. Satellite imagery datasets often contain petabytes of imagery, but accurately labeled datasets are much harder to come by. Self-supervised learning methods will allow us to train directly on the raw imagery without needing large labeled datasets.","__index_level_0__":805}
+{"text":"Aside from these larger projects, we're always looking to add new datasets, data augmentation transforms, and sampling strategies. If you're Python savvy and interested in contributing to TorchGeo, we would love to see contributions! TorchGeo is open source under an MIT license, so you can use it in almost any project.","__index_level_0__":806}
+{"text":"External links:","__index_level_0__":807}
+{"text":"- **Homepage**: [https:\/\/github.com\/microsoft\/torchgeo](https:\/\/github.com\/microsoft\/torchgeo)\n- **Documentation**: [https:\/\/torchgeo.readthedocs.io\/](https:\/\/torchgeo.readthedocs.io\/)\n- **PyPI**: [https:\/\/pypi.org\/project\/torchgeo\/](https:\/\/pypi.org\/project\/torchgeo\/)\n- **Paper**: [https:\/\/arxiv.org\/abs\/2111.08872](https:\/\/arxiv.org\/abs\/2111.08872)","__index_level_0__":808}
+{"text":"If you like TorchGeo, give us a star on GitHub! And if you use TorchGeo in your work, please cite our paper.","__index_level_0__":809}
+{"text":"# Acknowledgments","__index_level_0__":810}
+{"text":"*We would like to thank all TorchGeo contributors for their efforts in creating the library, the Microsoft AI for Good program for support, and the PyTorch Team for their guidance. This research is part of the Blue Waters sustained-petascale computing project, which is supported by the National Science Foundation (awards OCI-0725070 and ACI-1238993), the State of Illinois, and as of December, 2019, the National Geospatial-Intelligence Agency. Blue Waters is a joint effort of the University of Illinois at Urbana-Champaign and its National Center for Supercomputing Applications. The research was supported in part by NSF grants IIS-1908104, OAC-1934634, and DBI-2021898.*\n \n source: https:\/\/pytorch.org\/blog\/geospatial-deep-learning-with-torchgeo\/ \n category: pytorch blogs","__index_level_0__":811}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'What\u2019s New in PyTorch Profiler 1.9?'\nauthor: Sabrina Smai, Program Manager on the AI Framework team at Microsoft\n---","__index_level_0__":812}
+{"text":"PyTorch Profiler v1.9 has been released! The goal of this new release (previous [PyTorch Profiler release](https:\/\/pytorch.org\/blog\/introducing-pytorch-profiler-the-new-and-improved-performance-tool\/)) is to provide you with new state-of-the-art tools to help diagnose and fix machine learning performance issues regardless of whether you are working on one or numerous machines. The objective is to target the execution steps that are the most costly in time and\/or memory, and visualize the work load distribution between GPUs and CPUs. ","__index_level_0__":813}
+{"text":"Here is a summary of the five major features being released: ","__index_level_0__":814}
+{"text":"1.\t**Distributed Training View**: This helps you understand how much time and memory is consumed in your distributed training job. Many issues occur when you take a training model and split the load into worker nodes to be run in parallel as it can be a black box. The overall model goal is to speed up model training. This distributed training view will help you diagnose and debug issues within individual nodes. \n2.\t**Memory View**: This view allows you to understand your memory usage better. This tool will help you avoid the famously pesky Out of Memory error by showing active memory allocations at various points of your program run. \n3.\t**GPU Utilization Visualization**: This tool helps you make sure that your GPU is being fully utilized.  \n4.\t**Cloud Storage Support**: Tensorboard plugin can now read profiling data from Azure Blob Storage, Amazon S3, and Google Cloud Platform. \n5.\t**Jump to Source Code**: This feature allows you to visualize stack tracing information and jump directly into the source code. This helps you quickly optimize and iterate on your code based on your profiling results. ","__index_level_0__":815}
+{"text":"## Getting Started with PyTorch Profiling Tool\nPyTorch includes a profiling functionality called \u00ab PyTorch Profiler \u00bb. The PyTorch Profiler tutorial can be found [here](https:\/\/pytorch.org\/tutorials\/intermediate\/tensorboard_profiler_tutorial.html).","__index_level_0__":816}
+{"text":"To instrument your PyTorch code for profiling, you must:","__index_level_0__":817}
+{"text":"$ pip install torch-tb-profiler","__index_level_0__":818}
+{"text":"```python\nimport torch.profiler as profiler\nWith profiler.profile(XXXX)\n```","__index_level_0__":819}
+{"text":"**Comments**:","__index_level_0__":820}
+{"text":"\u2022 For CUDA and CPU profiling, see [below](https:\/\/github.com\/pytorch\/kineto\/blob\/master\/tb_plugin\/examples\/resnet50_profiler_api.py): \n```\nwith torch.profiler.profile( \nactivities=[ \ntorch.profiler.ProfilerActivity.CPU, \ntorch.profiler.ProfilerActivity.CUDA], \n```","__index_level_0__":821}
+{"text":"\u2022\tWith profiler.record_function(\u201c$NAME\u201d): allows putting a decorator (a tag associated to a name) for a block of function","__index_level_0__":822}
+{"text":"\u2022\tProfile_memory=True parameter under profiler.profile allows you to profile CPU and GPU memory footprint","__index_level_0__":823}
+{"text":"## Visualizing PyTorch Model Performance using PyTorch Profiler","__index_level_0__":824}
+{"text":"### Distributed Training ","__index_level_0__":825}
+{"text":"Recent advances in deep learning argue for the value of large datasets and large models, which requires you to scale out model training to more computational resources. Distributed Data Parallel (DDP) and NVIDIA Collective Communications Library (NCCL) are the widely adopted paradigms in PyTorch for accelerating your deep learning training. ","__index_level_0__":826}
+{"text":"In this release of PyTorch Profiler, DDP with NCCL backend is now supported.","__index_level_0__":827}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image1.png\" width=\"100%\">\n<\/div>","__index_level_0__":828}
+{"text":"### Computation\/Communication Overview","__index_level_0__":829}
+{"text":"In the Computation\/Communication overview under the Distributed training view, you can observe the computation-to-communication ratio of each worker and [load balancer](https:\/\/en.wikipedia.org\/wiki\/Load_balancing_(computing) nodes between worker as measured by granularity. ","__index_level_0__":830}
+{"text":"**Scenario 1**:","__index_level_0__":831}
+{"text":"If the computation and overlapping time of one worker is much larger than the others, this may suggest an issue in the workload balance or worker being a straggler. Computation is the sum of kernel time on GPU minus the overlapping time. The overlapping time is the time saved by interleaving communications during computation. The more overlapping time represents better parallelism between computation and communication. Ideally the computation and communication completely overlap with each other. Communication is the total communication time minus the overlapping time. The example image below displays how this scenario appears on Tensorboard. ","__index_level_0__":832}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image2.png\" width=\"100%\">\n  <p>Figure: A straggler example<\/p>\n<\/div>","__index_level_0__":833}
+{"text":"**Scenario 2**:","__index_level_0__":834}
+{"text":"If there is a small batch size (i.e. less computation on each worker) or the data to be transferred is large, the computation-to-communication may also be small and be seen in the profiler with low GPU utilization and long waiting times. This computation\/communication view will allow you to diagnose your code to reduce communication by adopting gradient accumulation, or to decrease the communication proportion by increasing batch size. DDP communication time depends on model size. Batch size has no relationship with model size. So increasing batch size could make computation time longer and make computation-to-communication ratio bigger. ","__index_level_0__":835}
+{"text":"### Synchronizing\/Communication Overview","__index_level_0__":836}
+{"text":"In the Synchronizing\/Communication view, you can observe the efficiency of communication. This is done by taking the step time minus computation and communication time. Synchronizing time is part of the total communication time for waiting and synchronizing with other workers. The Synchronizing\/Communication view includes initialization, data loader, CPU computation, and so on Insights like what is the ratio of total communication is really used for exchanging data and what is the idle time of waiting for data from other workers can be drawn from this view. ","__index_level_0__":837}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image4.png\" width=\"100%\">\n<\/div>","__index_level_0__":838}
+{"text":"For example, if there is an inefficient workload balance or straggler issue, you\u2019ll be able to identify it in this Synchronizing\/Communication view. This view will show several workers\u2019 waiting time being longer than others. ","__index_level_0__":839}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image5.png\" width=\"100%\">\n<\/div>","__index_level_0__":840}
+{"text":"This table view above allows you to see the detailed statistics of all communication ops in each node. This allows you to see what operation types are being called, how many times each op is called, what is the size of the data being transferred by each op, etc. ","__index_level_0__":841}
+{"text":"### Memory View:","__index_level_0__":842}
+{"text":"This memory view tool helps you understand the hardware resource consumption of the operators in your model. Understanding the time and memory consumption on the operator-level allows you to resolve performance bottlenecks and in turn, allow your model to execute faster. Given limited GPU memory size, optimizing the memory usage can: ","__index_level_0__":843}
+{"text":"1. Allow bigger model which can potentially generalize better on end level tasks.\n2. Allow bigger batch size. Bigger batch sizes increase the training speed.  ","__index_level_0__":844}
+{"text":"The profiler records all the memory allocation during the profiler interval. Selecting the \u201cDevice\u201d will allow you to see each operator\u2019s memory usage on the GPU side or host side. You must enable ```profile_memory=True``` to generate the below memory data as shown [here](https:\/\/github.com\/pytorch\/kineto\/blob\/master\/tb_plugin\/examples\/resnet50_profiler_api.py#L39). ","__index_level_0__":845}
+{"text":"```\nWith torch.profiler.profile(\nProfiler_memory=True # this will take 1 \u2013 2 minutes to complete. \n)\n```","__index_level_0__":846}
+{"text":"**Important Definitions**:","__index_level_0__":847}
+{"text":"\u2022\t\u201cSize Increase\u201d displays the sum of all allocation bytes and minus all the memory release bytes.","__index_level_0__":848}
+{"text":"\u2022\t\u201cAllocation Size\u201d shows the sum of all allocation bytes without considering the memory release.","__index_level_0__":849}
+{"text":"\u2022\t\u201cSelf\u201d means the allocated memory is not from any child operators, instead by the operator itself.","__index_level_0__":850}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image6.png\" width=\"100%\">\n<\/div>","__index_level_0__":851}
+{"text":"\n### GPU Metric on Timeline:","__index_level_0__":852}
+{"text":"This feature will help you debug performance issues when one or more GPU are underutilized. Ideally, your program should have high GPU utilization (aiming for 100% GPU utilization), minimal CPU to GPU communication, and no overhead. ","__index_level_0__":853}
+{"text":"**Overview**:\nThe overview page highlights the results of three important GPU usage metrics at different levels (i.e. GPU Utilization, Est. SM Efficiency, and Est. Achieved Occupancy). Essentially, each GPU has a bunch of SM each with a bunch of warps that can execute a bunch of threads concurrently. Warps execute a bunch because the amount depends on the GPU. But at a high level, this GPU Metric on Timeline tool allows you can see the whole stack, which is useful. ","__index_level_0__":854}
+{"text":"If the GPU utilization result is low, this suggests a potential bottleneck is present in your model. Common reasons: ","__index_level_0__":855}
+{"text":"\u2022Insufficient parallelism in kernels (i.e., low batch size) ","__index_level_0__":856}
+{"text":"\u2022Small kernels called in a loop. This is to say the launch overheads are not amortized ","__index_level_0__":857}
+{"text":"\u2022CPU or I\/O bottlenecks lead to the GPU not receiving enough work to keep busy ","__index_level_0__":858}
+{"text":"Looking of the overview page where the performance recommendation section is where you\u2019ll find potential suggestions on how to increase that GPU utilization. In this example, GPU utilization is low so the performance recommendation was to increase batch size. Increasing batch size 4 to 32, as per the performance recommendation, increased the GPU Utilization by 60.68%. ","__index_level_0__":859}
+{"text":"GPU Utilization: the step interval time in the profiler when a GPU engine was executing a workload. The high the utilization %, the better. The drawback of using GPU utilization solely to diagnose performance bottlenecks is it is too high-level and coarse. It won\u2019t be able to tell you how many Streaming Multiprocessors are in use. Note that while this metric is useful for detecting periods of idleness, a high value does not indicate efficient use of the GPU, only that it is doing anything at all. For instance, a kernel with a single thread running continuously will get a GPU Utilization of 100% ","__index_level_0__":860}
+{"text":"Estimated Stream Multiprocessor Efficiency (Est. SM Efficiency) is a finer grained metric, it indicates what percentage of SMs are in use at any point in the trace This metric reports the percentage of time where there is at least one active warp on a SM and those that are stalled (NVIDIA [doc](https:\/\/forums.developer.nvidia.com\/t\/nvprof-question-about-the-sm-efficiency-metric\/72640#:~:text=My%20understanding%20from%20the%20profiler%20documentation%20is%20that,that%20%E2%80%9Cactive%20warps%E2%80%9D%20include%20warps%20that%20are%20stalled.)). Est. SM Efficiency also has it\u2019s limitation. For instance, a kernel with only one thread per block can\u2019t fully use each SM. SM Efficiency does not tell us how busy each SM is, only that they are doing anything at all, which can include stalling while waiting on the result of a memory load. To keep an SM busy, it is necessary to have a sufficient number of ready warps that can be run whenever a stall occurs","__index_level_0__":861}
+{"text":"Estimated Achieved Occupancy (Est. Achieved Occupancy) is a layer deeper than Est. SM Efficiency and GPU Utilization for diagnosing performance issues. Estimated Achieved Occupancy indicates how many warps can be active at once per SMs. Having a sufficient number of active warps is usually key to achieving good throughput. Unlike GPU Utilization and SM Efficiency, it is not a goal to make this value as high as possible. As a rule of thumb, good throughput gains can be had by improving this metric to 15% and above. But at some point you will hit diminishing returns. If the value is already at 30% for example, further gains will be uncertain. This metric reports the average values of all warp schedulers for the kernel execution period (NVIDIA [doc](https:\/\/docs.nvidia.com\/gameworks\/content\/developertools\/desktop\/analysis\/report\/cudaexperiments\/kernellevel\/achievedoccupancy.htm)). The larger the Est. Achieve Occupancy value is the better. ","__index_level_0__":862}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image7.png\" width=\"100%\">\n  <p>Overview details: Resnet50_batchsize4<\/p>\n<\/div>","__index_level_0__":863}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image8.png\" width=\"100%\">\n  <p>Overview details: Resnet50_batchsize32<\/p>\n<\/div>","__index_level_0__":864}
+{"text":"_Kernel View_\nThe kernel has \u201cBlocks per SM\u201d and \u201cEst. Achieved Occupancy\u201d which is a great tool to compare model runs. ","__index_level_0__":865}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image9.png\" width=\"100%\">\n<\/div>","__index_level_0__":866}
+{"text":"Mean Blocks per SM:  \nBlocks per SM = Blocks of this kernel \/ SM number of this GPU. If this number is less than 1, it indicates the GPU multiprocessors are not fully utilized. \u201cMean Blocks per SM\u201d is weighted average of all runs of this kernel name, using each run\u2019s duration as weight.  ","__index_level_0__":867}
+{"text":"Mean Est. Achieved Occupancy:  \nEst. Achieved Occupancy is defined as above in overview. \u201cMean Est. Achieved Occupancy\u201d is weighted average of all runs of this kernel name, using each run\u2019s duration as weight.  ","__index_level_0__":868}
+{"text":"_Trace View_\nThis trace view displays a timeline that shows the duration of operators in your model and which system executed the operation. This view can help you identify whether the high consumption and long execution is because of input or model training. Currently, this trace view shows GPU Utilization and Est. SM Efficiency on a timeline. ","__index_level_0__":869}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image10.png\" width=\"100%\">\n<\/div>","__index_level_0__":870}
+{"text":"GPU utilization is calculated independently and divided into multiple 10 millisecond buckets. The buckets\u2019 GPU utilization values are drawn alongside the timeline between 0 \u2013 100%. In the above example, the \u201cProfilerStep5\u201d GPU utilization during thread 28022\u2019s busy time is higher than the following the one during \u201cOptimizer.step\u201d. This is where you can zoom-in to investigate why that is. ","__index_level_0__":871}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image11.png\" width=\"100%\">\n<\/div>","__index_level_0__":872}
+{"text":"From above, we can see the former\u2019s kernels are longer than the later\u2019s kernels. The later\u2019s kernels are too short in execution, which results in lower GPU utilization. ","__index_level_0__":873}
+{"text":"Est. SM Efficiency: Each kernel has a calculated est. SM efficiency between 0 \u2013 100%. For example, the below kernel has only 64 blocks, while the SMs in this GPU is 80. Then its \u201cEst. SM Efficiency\u201d is 64\/80, which is 0.8.  ","__index_level_0__":874}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image12.png\" width=\"100%\">\n<\/div>","__index_level_0__":875}
+{"text":"### Cloud Storage Support","__index_level_0__":876}
+{"text":"After running pip install tensorboard, to have data be read through these cloud providers, you can now run: ","__index_level_0__":877}
+{"text":"``` sh \ntorch-tb-profiler[blob] \ntorch-tb-profiler[gs] \ntorch-tb-profiler[s3] \n``` \n```pip install torch-tb-profiler[blob]```, ```pip install torch-tb-profiler[gs]```, or ```pip install torch-tb-profiler[S3]``` to have data be read through these cloud providers. For more information, please refer to this [README](https:\/\/github.com\/pytorch\/kineto\/tree\/main\/tb_plugin). ","__index_level_0__":878}
+{"text":"### Jump to Source Code:","__index_level_0__":879}
+{"text":"One of the great benefits of having both TensorBoard and the PyTorch Profiler being integrated directly in Visual Studio Code (VS Code) is the ability to directly jump to the source code (file and line) from the profiler stack traces. VS Code Python Extension now [supports TensorBoard Integration](https:\/\/devblogs.microsoft.com\/python\/python-in-visual-studio-code-february-2021-release\/).","__index_level_0__":880}
+{"text":"Jump to source is ONLY available when Tensorboard is launched within VS Code. Stack tracing will appear on the plugin UI if the profiling with_stack=True. When you click on a stack trace from the PyTorch Profiler, VS Code will automatically open the corresponding file side by side and jump directly to the line of code of interest for you to debug. This allows you to quickly make actionable optimizations and changes to your code based on the profiling results and suggestions. ","__index_level_0__":881}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/profiler_1.9_image13.png\" width=\"100%\">\n  <p>Gify: Jump to Source using Visual Studio Code Plug In UI <\/p>\n<\/div>","__index_level_0__":882}
+{"text":"For how to optimize batch size performance, check out the step-by-step tutorial [here](https:\/\/opendatascience.com\/optimizing-pytorch-performance-batch-size-with-pytorch-profiler\/). PyTorch Profiler is also integrated with [PyTorch Lightning](https:\/\/pytorch-lightning.readthedocs.io\/en\/stable\/advanced\/profiler.html#pytorch-profiling) and you can simply launch your lightning training jobs with --```trainer.profiler=pytorch``` flag to generate the traces. Check out an example [here](https:\/\/github.com\/PyTorchLightning\/pytorch-lightning\/blob\/master\/pl_examples\/basic_examples\/profiler_example.py).  ","__index_level_0__":883}
+{"text":"## What\u2019s Next for the PyTorch Profiler?\nYou just saw how PyTorch Profiler can help optimize a model. You can now try the Profiler by ```pip install torch-tb-profiler``` to optimize your PyTorch model. ","__index_level_0__":884}
+{"text":"Look out for an advanced version of this tutorial in the future. We are also thrilled to continue to bring state-of-the-art tool to PyTorch users to improve ML performance. We'd love to hear from you. Feel free to open an issue [here](https:\/\/github.com\/pytorch\/kineto\/issues).   ","__index_level_0__":885}
+{"text":"For new and exciting features coming up with PyTorch Profiler, follow @PyTorch on Twitter and check us out on pytorch.org. ","__index_level_0__":886}
+{"text":"## Acknowledgements","__index_level_0__":887}
+{"text":"The author would like to thank the contributions of the following individuals to this piece. From the Facebook side: Geeta Chauhan, Gisle Dankel, Woo Kim, Sam Farahzad, and Mark Saroufim. On the Microsoft side: AI Framework engineers (Teng Gao, Mike Guo, and Yang Gu), Guoliang Hua, and Thuy Nguyen.","__index_level_0__":888}
+{"text":" \n source: https:\/\/pytorch.org\/blog\/pytorch-profiler-1.9-released\/ \n category: pytorch blogs","__index_level_0__":889}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Announcing the Winners of the 2020 Global PyTorch Summer Hackathon'\nauthor: Team PyTorch\n---","__index_level_0__":890}
+{"text":"More than 2,500 participants in this year\u2019s Global PyTorch Summer Hackathon pushed the envelope to create unique new tools and applications for PyTorch developers and researchers.","__index_level_0__":891}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/Summer_hackathon.png\" width=\"100%\">\n<\/div>","__index_level_0__":892}
+{"text":"***Notice**: None of the projects submitted to the hackathon are associated with or offered by Facebook, Inc.* ","__index_level_0__":893}
+{"text":"This year\u2019s projects fell into three categories:","__index_level_0__":894}
+{"text":"* **PyTorch Developer Tools:** a tool or library for improving productivity and efficiency for PyTorch researchers and developers.","__index_level_0__":895}
+{"text":"* **Web\/Mobile Applications Powered by PyTorch:** a web or mobile interface and\/or an embedded device built using PyTorch.","__index_level_0__":896}
+{"text":"* **PyTorch Responsible AI Development Tools:** a tool, library, or web\/mobile app to support researchers and developers in creating responsible AI that factors in fairness, security, privacy, and more throughout its entire development process.","__index_level_0__":897}
+{"text":"The virtual hackathon ran from June 22 to August 25, with more than 2,500 registered participants, representing 114 countries from Republic of Azerbaijan, to Zimbabwe, to Japan, submitting a total of 106 projects. Entrants were judged on their idea\u2019s quality, originality, potential impact, and how well they implemented it.","__index_level_0__":898}
+{"text":"Meet the winners of each category below. ","__index_level_0__":899}
+{"text":"## PyTorch Developer Tools","__index_level_0__":900}
+{"text":"**1st place** - [DeMask](https:\/\/devpost.com\/software\/asteroid-the-pytorch-based-source-separation-toolkit)","__index_level_0__":901}
+{"text":"DeMask is an end-to-end model for enhancing speech while wearing face masks \u2014 offering a clear benefit during times when face masks are mandatory in many spaces and for workers who wear face masks on the job. Built with [Asteroid](https:\/\/github.com\/mpariente\/asteroid), a PyTorch-based audio source separation toolkit, DeMask is trained to recognize distortions in speech created by the muffling from face masks and to adjust the speech to make it sound clearer. ","__index_level_0__":902}
+{"text":"This submission stood out in particular because it represents both a high-quality idea and an implementation that can be reproduced by other researchers.","__index_level_0__":903}
+{"text":"Here is an example on how to train a speech separation model in less than 20 lines:","__index_level_0__":904}
+{"text":"```python\nfrom torch import optim\nfrom pytorch_lightning import Trainer","__index_level_0__":905}
+{"text":"from asteroid import ConvTasNet\nfrom asteroid.losses import PITLossWrapper\nfrom asteroid.data import LibriMix\nfrom asteroid.engine import System","__index_level_0__":906}
+{"text":"train_loader, val_loader = LibriMix.loaders_from_mini(task='sep_clean', batch_size=4)\nmodel = ConvTasNet(n_src=2)\noptimizer = optim.Adam(model.parameters(), lr=1e-3)\nloss = PITLossWrapper(\n    lambda x, y: (x - y).pow(2).mean(-1),  # MSE\n    pit_from=\"pw_pt\",  # Point in the pairwise matrix.\n)","__index_level_0__":907}
+{"text":"system = System(model, optimizer, loss, train_loader, val_loader)","__index_level_0__":908}
+{"text":"trainer = Trainer(fast_dev_run=True)\ntrainer.fit(system)\n```","__index_level_0__":909}
+{"text":"**2nd place** - [carefree-learn](https:\/\/devpost.com\/software\/carefree-learn)","__index_level_0__":910}
+{"text":"A PyTorch-based automated machine learning (AutoML) solution, carefree-learn provides high-level APIs to make training models using tabular data sets simpler. It features an interface similar to [scikit-learn](https:\/\/scikit-learn.org\/stable\/) and functions as an end-to-end end pipeline for tabular data sets. It automatically detects feature column types and redundant feature columns, imputes missing values, encodes string columns and categorical columns, and preprocesses numerical columns, among other features. ","__index_level_0__":911}
+{"text":"**3rd Place** - [TorchExpo](https:\/\/devpost.com\/software\/torchexpo)","__index_level_0__":912}
+{"text":"TorchExpo is a collection of models and extensions that simplifies taking PyTorch from research to production in mobile devices. This library is more than a web and mobile application, and also comes with a Python library. The Python library is available via pip install and it helps researchers convert a state-of-the-art model in TorchScript and ONNX format in just one line. Detailed docs are available [here](https:\/\/torchexpo.readthedocs.io\/en\/latest\/).","__index_level_0__":913}
+{"text":"## Web\/Mobile Applications Powered by PyTorch","__index_level_0__":914}
+{"text":"**1st place** - [Q&Aid](https:\/\/devpost.com\/software\/pytorchxai)","__index_level_0__":915}
+{"text":"Q&Aid is a conceptual health-care chatbot aimed at making health-care diagnoses and facilitating communication between patients and doctors. It relies on a series of machine learning models to filter, label, and answer medical questions, based on a medical image and\/or questions in text provided by a patient. The transcripts from the chat app then can be forwarded to the local hospitals and the patient will be contacted by one of them to make an appointment to determine proper diagnosis and care. The team hopes that this concept application helps hospitals to work with patients more efficiently and provide proper care. ","__index_level_0__":916}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/Q_AID_architecture.png\" width=\"100%\">\n<\/div>","__index_level_0__":917}
+{"text":"**2nd place** - [Rasoee](https:\/\/devpost.com\/software\/groundwav)","__index_level_0__":918}
+{"text":"Rasoee is an application that can take images as input and output the name of the dish. It also lists the ingredients and recipe, along with the link to the original recipe online. Additionally, users can choose a cuisine from the list of cuisines in the drop menu, and describe the taste and\/or method of preparation in text. Then the application will return matching dishes from the [list of 308 identifiable dishes](https:\/\/github.com\/arijitgupta42\/Rasoee\/blob\/master\/Dishes.txt). The team has put a significant amount of effort gathering and cleaning various datasets to build more accurate and comprehensive models. You can check out the application [here](https:\/\/rasoee.herokuapp.com).","__index_level_0__":919}
+{"text":"**3rd place** - [Rexana the Robot \u2014 PyTorch](https:\/\/devpost.com\/software\/rexana-the-robot)","__index_level_0__":920}
+{"text":"Rexana is an AI voice assistant meant to lay the foundation for a physical robot that can complete basic tasks around the house. The system is capable of autonomous navigation (knowing its position around the house relative to landmarks), recognizing voice commands, and object detection and recognition \u2014 meaning it can be commanded to perform various household tasks (e.g., \"Rexana, water the potted plant in the lounge room.\u201d). Rexana can be controlled remotely via a mobile device, and the robot itself features customizable hands (magnets, grippers, etc.) for taking on different jobs.","__index_level_0__":921}
+{"text":"## PyTorch Responsible AI Development Tools","__index_level_0__":922}
+{"text":"**1st place**: [FairTorch](https:\/\/devpost.com\/software\/a-qeysp1)","__index_level_0__":923}
+{"text":"FairTorch is a fairness library for PyTorch. It lets developers add constraints to their models to equalize metrics across subgroups by simply adding a few lines of code. Model builders can choose a metric definition of fairness for their context, and enforce it at time of training. The library offers a suite of metrics that measure an AI system\u2019s performance among subgroups, and can apply to high-stakes examples where decision-making algorithms are deployed, such as hiring, school admissions, and banking.","__index_level_0__":924}
+{"text":"<div align=\"center\">\n      <a href=\"https:\/\/www.youtube.com\/watch?v=b2Cj4VflFKQ\">\n     <img \n      src=\"https:\/\/yt-embed.herokuapp.com\/embed?v=b2Cj4VflFKQ\" \n      alt=\"FairTorch\" \n      style=\"width:50%;\">\n      <\/a>\n    <\/div>","__index_level_0__":925}
+{"text":"**2nd place**: [Fluence](https:\/\/devpost.com\/software\/fluence-5g2s9m)","__index_level_0__":926}
+{"text":"Fluence is a PyTorch-based deep learning library for language research. It specifically addresses the large compute demands of natural language processing (NLP) research. Fluence aims to provide low-resource and computationally efficient algorithms for NLP, giving researchers algorithms that can enhance current NLP methods or help discover where current methods fall short.","__index_level_0__":927}
+{"text":"**3rd place**: [Causing: CAUSal INterpretation using Graphs](https:\/\/devpost.com\/software\/realrate-explainable-ai-for-company-ratings)","__index_level_0__":928}
+{"text":"Causing (CAUSal INterpretation using Graphs) is a multivariate graphic analysis tool for bringing transparency to neural networks. It explains causality and helps researchers and developers interpret the causal effects of a given equation system to ensure fairness. Developers can input data and a model describing the dependencies between the variables within the data set into Causing, and Causing will output a colored graph of quantified effects acting between the model\u2019s variables. In addition, it also allows developers to estimate these effects to validate whether data fits a model.","__index_level_0__":929}
+{"text":"**The PyTorch team**","__index_level_0__":931}
+{"text":"\n \n source: https:\/\/pytorch.org\/blog\/announcing-the-winners-of-the-2020-global-pytorch-summer-hackathon\/ \n category: pytorch blogs","__index_level_0__":938}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch\u2019s Tracing Based Selective Build\"\nauthor: Dhruv Matani, Suraj Subramanian\nfeatured-img: \"\/assets\/images\/pytorchs-tracing-based-selective-build_Figure_4.png\"\n---","__index_level_0__":939}
+{"text":"## Introduction","__index_level_0__":940}
+{"text":"**TL;DR**: It can be challenging to run PyTorch on mobile devices, SBCs (Single Board Computers), and IOT devices. When compiled, the PyTorch library is huge and includes dependencies that might not be needed for the on-device use case. ","__index_level_0__":941}
+{"text":"To run a specific set of models on-device, we actually require only a small subset of the features in the PyTorch library. We found that using a PyTorch runtime generated using **selective build** can achieve up to 90% reduction in binary size (for the CPU and QuantizedCPU backends on an x86-64 build on Linux). In this blog, we share our experience of generating model-specific minimal runtimes using Selective Build and show you how to do the same.","__index_level_0__":942}
+{"text":"## Why is this important for app developers?","__index_level_0__":943}
+{"text":"Using a PyTorch runtime generated by **selective build** can reduce the size of AI-powered apps by 30+ MB - a significant reduction for a typical mobile app! Making mobile applications more lightweight has many benefits - they are runnable on a wider variety of devices, consume less cellular data, and can be downloaded and updated faster on user\u2019s devices.","__index_level_0__":944}
+{"text":"## What does the Developer Experience look like?","__index_level_0__":945}
+{"text":"This method can work seamlessly with any existing PyTorch Mobile deployment workflows. All you need to do is replace the general PyTorch runtime library with a runtime customized for the specific models you wish to use in your application. The general steps in this process are:","__index_level_0__":946}
+{"text":"1. Build the PyTorch Runtime in **instrumentation mode** (this is called an **instrumentation build** of PyTorch). This will record the used operators, kernels and features.\n2. Run your models through this instrumentation build by using the provided **model_tracer** binary. This will generate a single YAML file that stores all the features used by your model. These features will be preserved in the minimal runtime.\n3. Build PyTorch using this YAML file as input. This is the **selective build** technique, and it greatly reduces the size of the final PyTorch binary.\n4. Use this selectively-built PyTorch library to reduce the size of your mobile application!","__index_level_0__":947}
+{"text":"\nBuilding the PyTorch Runtime in a special **\u201cinstrumentation\u201d mode** ( by passing the `TRACING_BASED=1` build option) generates an **instrumentation build** runtime of PyTorch, along with a **model_tracer** binary. Running a model with this build allows us to trace the parts of PyTorch used by the model.","__index_level_0__":948}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/pytorchs-tracing-based-selective-build_Figure1.png\" width=\"100%\">\n<\/p>","__index_level_0__":949}
+{"text":"<p align=\"center\">\n  <i>Figure 1: Instrumentation build of PyTorch<\/i>\n<\/p>","__index_level_0__":950}
+{"text":"```python\n# Clone the PyTorch repo\ngit clone https:\/\/github.com\/pytorch\/pytorch.git\ncd pytorch","__index_level_0__":951}
+{"text":"# Build the model_tracer\nUSE_NUMPY=0 USE_DISTRIBUTED=0 USE_CUDA=0 TRACING_BASED=1 \\\n  python setup.py develop\n```","__index_level_0__":952}
+{"text":"Now this instrumentation build is used to run a model inference with representative inputs. The **model_tracer** binary observes parts of the instrumentation build that were activated during the inference run, and dumps it to a YAML file.","__index_level_0__":953}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/pytorchs-tracing-based-selective-build_Figure2.png\" width=\"100%\">\n<\/p>","__index_level_0__":954}
+{"text":"<p align=\"center\">\n  <i>Figure 2: YAML file generated by running model(s) on an instrumentation build<\/i>\n<\/p>","__index_level_0__":955}
+{"text":"```python\n# Generate YAML file\n.\/build\/bin\/model_tracer \\\n  --model_input_path \/tmp\/path_to_model.ptl \\\n  --build_yaml_path \/tmp\/selected_ops.yaml\n```","__index_level_0__":956}
+{"text":"Now we build the PyTorch Runtime again, but this time using the YAML file generated by the tracer. The runtime now only includes those parts that are needed for this model. This is called **\u201cSelectively built PyTorch runtime\u201d** in the diagram below.","__index_level_0__":957}
+{"text":"```python\n# Clean out cached configuration\nmake clean","__index_level_0__":958}
+{"text":"# Build PyTorch using Selected Operators (from the YAML file)\n# using the host toolchain, and use this generated library\nBUILD_PYTORCH_MOBILE_WITH_HOST_TOOLCHAIN=1 \\\nUSE_LIGHTWEIGHT_DISPATCH=0 \\\nBUILD_LITE_INTERPRETER=1 \\\nSELECTED_OP_LIST=\/tmp\/selected_ops.yaml \\\nTRACING_BASED=1 \\\n  .\/scripts\/build_mobile.sh\n```","__index_level_0__":959}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/pytorchs-tracing-based-selective-build_Figure3.png\" width=\"100%\">\n<\/p>","__index_level_0__":960}
+{"text":"<p align=\"center\">\n  <i>Figure 3: Selective Build of PyTorch and model execution on a selectively built PyTorch runtime<\/i>\n<\/p>","__index_level_0__":961}
+{"text":"### Show me the code!","__index_level_0__":962}
+{"text":"We\u2019ve put together a [notebook](https:\/\/gist.github.com\/dhruvbird\/65fd800983f362a72d78afe68031568c) to illustrate what the process above looks like in code using a simple PyTorch model. ","__index_level_0__":963}
+{"text":"For a more hands-on tutorial to deploy this on Android\/iOS [this tutorial](https:\/\/pytorch.org\/tutorials\/prototype\/tracing_based_selective_build.html) should be helpful.","__index_level_0__":964}
+{"text":"## Technical FAQs","__index_level_0__":965}
+{"text":"### Why is Tracing needed for a Selective Build of PyTorch?","__index_level_0__":966}
+{"text":"In PyTorch, CPU kernels can call other operators via the [PyTorch Dispatcher](http:\/\/blog.ezyang.com\/2020\/09\/lets-talk-about-the-pytorch-dispatcher\/). Simply including the set of root operators called directly by the model is not sufficient as there might be many more being called under-the-hood transitively. Running the model on representative inputs and observing the actual list of operators called (aka \u201ctracing\u201d) is the most accurate way of determining what parts of PyTorch are used.","__index_level_0__":967}
+{"text":"Additionally, factors such as which dtypes a kernel should handle are also runtime features that depend on actual input provided to the model. Hence, the tracing mechanism is extremely suitable for this purpose.","__index_level_0__":968}
+{"text":"### Which features can be selected (in or out) by using Tracing Based Selective Build?","__index_level_0__":969}
+{"text":"The following features can be selected for the PyTorch runtime during the tracing based selective build process:","__index_level_0__":970}
+{"text":"1. [CPU\/QuantizedCPU](https:\/\/codebrowser.bddppq.com\/pytorch\/pytorch\/build\/aten\/src\/ATen\/) kernels for [PyTorch\u2019s ATen Operators](https:\/\/pytorch.org\/cppdocs\/): If a PyTorch Operator is not needed by a model targeted at a selectively built runtime, then the registration of that CPU kernel is omitted in the runtime. This is controlled via [Torchgen code-gen](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torchgen\/gen.py).\n2. [Primary Operators](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/csrc\/jit\/runtime\/register_prim_ops.cpp): This is controlled by a macro named [TORCH_SELECTIVE_SCHEMA](https:\/\/codebrowser.bddppq.com\/pytorch\/pytorch\/torch\/library.h.html) (via templated selective build) that either selects a primary operator or de-selects it based on information in a generated header file.\n3. Code that handles [specific dtypes](https:\/\/codebrowser.bddppq.com\/pytorch\/pytorch\/aten\/src\/ATen\/Dispatch.h.html) in CPU kernels: This is performed by generating exception throws in specific case statements in the switch case generated by the macro [AT_PRIVATE_CHECK_SELECTIVE_BUILD](https:\/\/codebrowser.bddppq.com\/pytorch\/pytorch\/aten\/src\/ATen\/Dispatch.h.html#_M\/AT_PRIVATE_CHECK_SELECTIVE_BUILD).\n4. Registration of [Custom C++ Classes](https:\/\/pytorch.org\/tutorials\/advanced\/torch_script_custom_classes.html) that extend PyTorch: This is controlled by the macro [TORCH_SELECTIVE_CLASS](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/aten\/src\/ATen\/native\/quantized\/cpu\/fbgemm_utils.cpp#L385-L386), which can be used when registering Custom C++ Classes. The [torch::selective_class_<>](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/custom_class.h#L443-L460) helper is to be used in conjunction with the macro [TORCH_SELECTIVE_CLASS](https:\/\/codebrowser.bddppq.com\/pytorch\/pytorch\/torch\/library.h.html#_M\/TORCH_SELECTIVE_CLASS).","__index_level_0__":971}
+{"text":"### What is the structure of the YAML file used during the build?","__index_level_0__":972}
+{"text":"The YAML file generated after tracing looks like the example below. It encodes all the elements of the \u201cselectable\u201d build feature as specified above.","__index_level_0__":973}
+{"text":"```python\ninclude_all_non_op_selectives: false\nbuild_features: []\noperators:\n    aten::add.Tensor:\n        is_used_for_training: false\n        is_root_operator: true\n        include_all_overloads: false\n    aten::len.t:\n        is_used_for_training: false\n        is_root_operator: true\n        include_all_overloads: false\nkernel_metadata:\n    _local_scalar_dense_cpu:\n    - Float\n    add_stub:\n    - Float\n    copy_:\n    - Bool\n    - Byte\n    mul_cpu:\n    - Float\ncustom_classes: []\n```","__index_level_0__":974}
+{"text":"### How exactly is code eliminated from the generated binary?","__index_level_0__":975}
+{"text":"Depending on the specific scenario, there are 2 main techniques that are used to hint the compiler and linker about unused and unreachable code. This code is then cleaned up by the compiler or linker as unreachable code.","__index_level_0__":976}
+{"text":"#### [1] Unreferenced functions removed by the Linker","__index_level_0__":977}
+{"text":"When a function that isn\u2019t transitively referenced from any visible function is present in the compiled object files that are being linked together, the linker will remove it (if the right build flags are provided). This is leveraged in 2 scenarios by the selective build system.","__index_level_0__":978}
+{"text":"##### Kernel Registration in the Dispatcher","__index_level_0__":979}
+{"text":"If an operator\u2019s kernel isn\u2019t needed, then it isn\u2019t registered with the dispatcher. An unregistered kernel means that the function is unreachable, and it will be removed by the linker.","__index_level_0__":980}
+{"text":"##### Templated Selective Build","__index_level_0__":981}
+{"text":"The general idea here is that a class template specialization is used to select a class that either captures a reference to a function or not (depending on whether it\u2019s used) and the linker can come along and clean out the unreferenced function.","__index_level_0__":982}
+{"text":"For example, in the code below, there\u2019s no reference to the function \u201c`fn2`\u201d, so it will be cleaned up by the linker since it\u2019s not referenced anywhere.","__index_level_0__":983}
+{"text":"```python\n#include <vector>\n#include <cstdio>","__index_level_0__":984}
+{"text":"template <typename T, bool>\nstruct FunctionSelector {\n    T fn_;\n    FunctionSelector(T fn): fn_(fn) {}\n    T get() { return this->fn_; }\n};","__index_level_0__":985}
+{"text":"\/\/ The \"false\" specialization of this class does NOT retain the argument passed\n\/\/ to the class constructor, which means that the function pointer passed in\n\/\/ is considered to be unreferenced in the program (unless it is referenced\n\/\/ elsewhere).\ntemplate <typename T>\nstruct FunctionSelector<T, false> {\n    FunctionSelector(T) {}\n};","__index_level_0__":986}
+{"text":"template <typename T>\nFunctionSelector<T, true> make_function_selector_true(T fn) {\n    return FunctionSelector<T, true>(fn);\n}","__index_level_0__":987}
+{"text":"template <typename T>\nFunctionSelector<T, false> make_function_selector_false(T fn) {\n    return FunctionSelector<T, false>(fn);\n}","__index_level_0__":988}
+{"text":"typedef void(*fn_ptr_type)();","__index_level_0__":989}
+{"text":"std::vector<fn_ptr_type> fns;","__index_level_0__":990}
+{"text":"template <typename T>\nvoid add_fn(FunctionSelector<T, true> fs) {\n    fns.push_back(fs.get());\n}","__index_level_0__":991}
+{"text":"template <typename T>\nvoid add_fn(FunctionSelector<T, false>) {\n    \/\/ Do nothing.\n}","__index_level_0__":992}
+{"text":"\/\/ fn1 will be kept by the linker since it is added to the vector \"fns\" at\n\/\/ runtime.\nvoid fn1() {\n    printf(\"fn1\\n\");\n}","__index_level_0__":993}
+{"text":"\/\/ fn2 will be removed by the linker since it isn't referenced at all.\nvoid fn2() {\n    printf(\"fn2\\n\");\n}","__index_level_0__":994}
+{"text":"int main() {\n    add_fn(make_function_selector_true(fn1));\n    add_fn(make_function_selector_false(fn2));\n}\n```","__index_level_0__":995}
+{"text":"#### [2] Dead Code Eliminated by the Compiler","__index_level_0__":996}
+{"text":"C++ Compilers can detect dead ([unreachable](https:\/\/en.wikipedia.org\/wiki\/Unreachable_code)) code by analyzing the code\u2019s control flow statically. For example, if there\u2019s a code-path that comes after an **unconditional exception throw**, then all the code after it will be marked as dead code and not converted to object code by the compiler. Typically, compilers require the use of the `-fdce` flag to eliminate dead code.","__index_level_0__":997}
+{"text":"In the example below, you can see that the C++ code on the left (in the red boxes) doesn\u2019t have any corresponding generated object code on the right.","__index_level_0__":998}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/pytorchs-tracing-based-selective-build_Figure_4.png\" width=\"100%\">\n<\/p>","__index_level_0__":999}
+{"text":"<p align=\"center\">\n  <i>Figure 4: Dead Code Elimination by C++ Compilers<\/i>\n<\/p>","__index_level_0__":1000}
+{"text":"This property is leveraged in the bodies of PyTorch kernel implementations that have a lot of repeated code to handle multiple dtypes of a Tensor. A [dtype](https:\/\/pytorch.org\/docs\/stable\/tensor_attributes.html) is the underlying data-type that the Tensor stores elements of. This can be one of float, double, int64, bool, int8, etc\u2026","__index_level_0__":1001}
+{"text":"Almost every PyTorch CPU kernel uses a macro of the form AT_DISPATCH_ALL_TYPES* that is used to substitute some code specialized for every dtype that the kernel needs to handle. For example:","__index_level_0__":1002}
+{"text":"```python\nAT_DISPATCH_ALL_TYPES_AND_COMPLEX_AND3(\n    kBool, kHalf, kBFloat16, dtype, \"copy_kernel\", [&] {\n  cpu_kernel_vec(\n      iter,\n      [=](scalar_t a) -> scalar_t { return a; },\n      [=](Vectorized<scalar_t> a) -> Vectorized<scalar_t> { return a; });\n});\n```","__index_level_0__":1003}
+{"text":"The macro `AT_DISPATCH_ALL_TYPES_AND_COMPLEX_AND3` internally has a switch-case statement that looks like the code in Figure-4 above. The tracing process records the dtypes triggered for the kernel tag \"`copy_kernel`\" and the build process processes these tags and inserts `throw` statements in every `case` statement that is handling the dtype that isn\u2019t required for this kernel tag.","__index_level_0__":1004}
+{"text":"This is how dtype selectivity is implemented in PyTorch\u2019s Tracing Based Selective Build.","__index_level_0__":1005}
+{"text":"## Conclusion","__index_level_0__":1006}
+{"text":"Tracing Based Selective Build is a practical and scalable approach to selecting only the used parts of an application to retain code that static analysis can not detect. This code is usually extremely data\/input dependent in nature.","__index_level_0__":1007}
+{"text":"This article provides detailed insights into how Tracing Based Selective Build works under the hood, and the technical details related to its implementation. These techniques can also be applied to other applications and situations that can benefit from reduced binary size. \n source: https:\/\/pytorch.org\/blog\/pytorchs-tracing-based-selective-build\/ \n category: pytorch blogs","__index_level_0__":1008}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch & OpenXLA: The Path Forward\"\nauthor: Milad Mohammadi, Jack Cao, Shauheen Zahirazami, Joe Spisak, and Jiewen Tan \n---","__index_level_0__":1009}
+{"text":"As we celebrate the release of [OpenXLA](https:\/\/opensource.googleblog.com\/2023\/03\/openxla-is-ready-to-accelerate-and-simplify-ml-development.html), [PyTorch 2.0](https:\/\/pytorch.org\/blog\/pytorch-2.0-release\/), and [PyTorch\/XLA 2.0](https:\/\/pytorch.org\/blog\/pytorch-2.0-xla\/), it\u2019s worth taking a step back and sharing where we see it all going in the short to medium term. With PyTorch adoption leading in the AI space and XLA supporting best-in-class compiler features, PyTorch\/XLA is well positioned to provide a cutting edge development stack for both model training and inference. To achieve this, we see investments in three main areas:","__index_level_0__":1010}
+{"text":"* **Training Large Models** - Large language models (LLM) and diffusion models have quickly risen in popularity and many cutting edge applications today are built on them. Further to this, training these models requires scale and more specifically the ability to train across thousands of accelerators. To achieve this we are investing in features such as AMP for mixed precision training, PjRt for increased runtime performance, SPMD \/ FSDP for efficient model sharding, Dynamic Shapes to enable new research approaches, faster data loading through Ray and tf.data, and a toolchain that packages all of these features together into a seamless workflow. Some of these features are already available in experimental or beta stages, and others are coming up this year with many heavily leveraging the underlying OpenXLA compiler stack.\n* **Model Inference** - With large models continuing to grow in size and computational cost, deployment becomes the next challenge as these models continue to find their way into applications. With the introduction of Dynamo in the PyTorch 2.0 release, PyTorch\/XLA delivers performance competitive inference. We are, however, incorporating additional inference-oriented including model serving support, Dynamo for sharded large models, quantization via Torch.Export and StableHLO.\n* **Ecosystem integration** - We are expanding integration with [Hugging Face](https:\/\/huggingface.co\/) and [PyTorch Lightning](https:\/\/lightning.ai\/docs\/pytorch\/stable\/) so users can take advantage of upcoming PyTorch\/XLA cutting edge features (e.g. FSDP support in Hugging Face) and the downstream OpenXLA features (e.g. Quantization) through familiar APIs.","__index_level_0__":1011}
+{"text":"Additionally, PyTorch\/XLA is set to migrate to the open source [OpenXLA](https:\/\/github.com\/openxla) as its default downstream compiler; allowing the PyTorch community to gain access to a leading, framework-agnostic compiler stack that enjoys industry-wide contribution and innovation. To achieve this, we will begin supporting StableHLO. As a result, OpenXLA will replace the existing TF:XLA dependency, overall streamlining the dependencies and creating leverage from the broader compiler ecosystem. PyTorch\/XLA will also sunset the XRT runtime after migration. You can see the resulting high level stack below with the TensorFlow dependency stricken out:","__index_level_0__":1012}
+{"text":"![the upcoming PyTorch\/XLA features and integrations](\/assets\/images\/PyTorch_XLA Future Stack.svg){:style=\"max-height:800px; width:100%\"}       ","__index_level_0__":1013}
+{"text":"<small style=\"line-height: 1.1\"><em>**Figure:** the upcoming PyTorch\/XLA features and integrations are illustrated here<\/em><\/small>","__index_level_0__":1014}
+{"text":"We cannot be more excited about what\u2019s ahead for PyTorch\/XLA and invite the community to join us. PyTorch\/XLA is developed fully in open source so please file issues, submit pull requests, and send RFCs to [GitHub](https:\/\/github.com\/pytorch\/xla) such that we can openly collaborate. You can also [try out](https:\/\/colab.sandbox.google.com\/github\/pytorch\/xla\/blob\/master\/contrib\/colab\/getting-started.ipynb) PyTorch\/XLA for yourself on various XLA devices including TPUs and GPUs.","__index_level_0__":1015}
+{"text":"Cheers,  \nThe PyTorch\/XLA Team at Google \n source: https:\/\/pytorch.org\/blog\/pytorch-2.0-xla-path-forward\/ \n category: pytorch blogs","__index_level_0__":1016}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Scaling Multimodal Foundation Models in TorchMultimodal with Pytorch Distributed\"\nauthor: Ankita De, Edward Wang (EcoF), Rohan Varma, Anjali Sridhar, Kartikay Khandelwal\nfeatured-img: \"\/assets\/images\/scaling-multimodal-image1-diagram-of-multimodal-flava-new.png\"\n---","__index_level_0__":1017}
+{"text":"## Introduction","__index_level_0__":1018}
+{"text":"In recent years, scaling model sizes has become a promising area of research. In the field of NLP, language models have gone from hundreds of millions of parameters (BERT) to hundreds of billions of parameters (GPT-3) demonstrating significant improvements on downstream tasks. The [scaling laws](https:\/\/arxiv.org\/pdf\/2001.08361.pdf) for large scale language models have also been studied extensively in the industry. A similar trend can be observed in the vision field, with the community moving to transformer based models (like [Vision Transformer](https:\/\/arxiv.org\/pdf\/2010.11929.pdf), [Masked Auto Encoders](https:\/\/arxiv.org\/pdf\/2111.06377.pdf)) as well. It is clear that individual modalities - text, image, video - have benefited massively from recent advancements in scale, and frameworks have quickly adapted to accommodate larger models.","__index_level_0__":1019}
+{"text":"At the same time, multimodality is becoming increasingly important in research with tasks like image-text retrieval, visual question-answering, visual dialog and text to image generation gaining traction in real world applications. Training large scale multimodal models is the natural next step and we already see several efforts in this area like [CLIP](https:\/\/openai.com\/blog\/clip\/) from OpenAI, [Parti](https:\/\/parti.research.google\/) from Google and [CM3](https:\/\/arxiv.org\/pdf\/2201.07520.pdf) from Meta.","__index_level_0__":1020}
+{"text":"In this blog, we present a case study demonstrating the scaling of [FLAVA](https:\/\/flava-model.github.io\/) to 10B params using techniques from PyTorch Distributed. FLAVA is a vision and language foundation model, available in [TorchMultimodal](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/main\/torchmultimodal\/models\/flava), which has shown competitive performance on both unimodal and multimodal benchmarks. We also give the relevant code pointers in this blog. The instructions for running an example script to scale FLAVA can be found [here](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/main\/examples\/flava\/native).","__index_level_0__":1021}
+{"text":"## Scaling FLAVA Overview","__index_level_0__":1022}
+{"text":"FLAVA is a foundation multimodal model which consists of transformer based image and text encoders followed by a transformer-based multimodal fusion module. It is pretrained on both unimodal and multimodal data with a diverse set of losses. This includes masked language, image and multimodal modeling losses that require the model to reconstruct the original input from its context (self-supervised learning). It also uses image text matching loss over positive and negative examples of aligned image-text pairs as well as CLIP style contrastive loss. In addition to multimodal tasks (like image-text retrieval), FLAVA demonstrated competitive performance on unimodal benchmarks as well (GLUE tasks for NLP and image classification for vision).","__index_level_0__":1023}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/scaling-multimodal-image1-diagram-of-multimodal-flava-new.png\" width=\"100%\">\n<\/p>","__index_level_0__":1024}
+{"text":"The original FLAVA model has ~350M parameters and uses ViT-B16 configurations (from the [Vision Transformer paper](https:\/\/arxiv.org\/pdf\/2010.11929.pdf)) for image and text encoders. The multimodal fusion transformer follows the unimodal encoders but with half the number of layers. We explore increasing the size of each encoder to larger ViT variants. ","__index_level_0__":1025}
+{"text":"Another aspect of scaling is adding the ability to increase the batch size. FLAVA makes use of contrastive loss over in-batch negatives, which typically benefits from large batch size (as studied [here](https:\/\/openreview.net\/pdf?id=U2exBrf_SJh)). The largest training efficiency or throughput is also generally achieved when operating near maximum possible batch sizes as determined by the amount of GPU memory available (also see the experiments section). ","__index_level_0__":1026}
+{"text":"The following table displays the different model configurations we experimented with. We also determine the maximum batch size that was able to fit in memory for each configuration in the experiments section.","__index_level_0__":1027}
+{"text":"|  Approx Model params  |  Hidden size  | MLP size |  Heads  |  Unimodal layers  |  Multimodal layers  |  Model size (fp32)  |\n|-----------------------|---------------|----------|---------|-------------------|---------------------|---------------------|\n|  350M (original)      |          768  |    3072  |     12  |               12  |                  6  |             1.33GB  |\n|  900M                 |         1024  |    4096  |     16  |               24  |                 12  |             3.48GB  |\n|  1.8B                 |         1280  |    5120  |     16  |               32  |                 16  |             6.66GB  |\n|  2.7B                 |         1408  |    6144  |     16  |               40  |                 20  |             10.3GB  |\n|  4.8B                 |         1664  |    8192  |     16  |               48  |                 24  |             18.1GB  |\n|  10B                  |         2048  |   10240  |     16  |               64  |                 40  |               38GB  |","__index_level_0__":1028}
+{"text":"## Optimization overview","__index_level_0__":1029}
+{"text":"PyTorch offers several native techniques to efficiently scale models. In the following sections, we go over some of these techniques and show how they can be applied to scale up a FLAVA model to 10 billion parameters.","__index_level_0__":1030}
+{"text":"## Distributed Data Parallel","__index_level_0__":1031}
+{"text":"A common starting point for distributed training is data parallelism. Data parallelism replicates the model across each worker (GPU), and partitions the dataset across the workers. Different workers process different data partitions in parallel and synchronize their gradients (via all reduce) before model weights are updated. The figure below showcases the flow (forward, backward, and weight update steps) for processing a single example for data parallelism:","__index_level_0__":1032}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/scaling-multimodal-image2-diagram-of-standard-data-parallel-training.png\" width=\"100%\">\n<\/p>","__index_level_0__":1033}
+{"text":"<p align=\"center\">\n  Source: <a href=\"https:\/\/engineering.fb.com\/2021\/07\/15\/open-source\/fsdp\/\">https:\/\/engineering.fb.com\/2021\/07\/15\/open-source\/fsdp\/<\/a>\n<\/p>","__index_level_0__":1034}
+{"text":"PyTorch provides a native API, [DistributedDataParallel](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.parallel.DistributedDataParallel.html) (DDP) to enable data parallelism which can be used as a module wrapper as showcased below. Please see PyTorch Distributed [documentation](https:\/\/pytorch.org\/docs\/stable\/distributed.html#) for more details.","__index_level_0__":1035}
+{"text":"```Python\nfrom torchmultimodal.models.flava.model import flava_model_for_pretraining\nimport torch\nimport torch.distributed as dist","__index_level_0__":1036}
+{"text":"model = flava_model_for_pretraining().cuda()\n# Initialize PyTorch Distributed process groups\n# Please see https:\/\/pytorch.org\/tutorials\/intermediate\/dist_tuto.html for details\ndist.init_process_group(backend=\u201dnccl\u201d)\n# Wrap model in DDP\nmodel = torch.nn.parallel.DistributedDataParallel(model, device_ids=[torch.cuda.current_device()])\n```","__index_level_0__":1037}
+{"text":"## Fully Sharded Data Parallel","__index_level_0__":1038}
+{"text":"GPU memory usage of a training application can roughly be broken down into model inputs, intermediate activations (needed for gradient computation), model parameters, gradients, and optimizer states. Scaling a model will typically increase each of these elements. Scaling a model with DDP can eventually result in out-of-memory issues when a single GPU's memory becomes insufficient since it replicates the parameters, gradients, and optimizer states on all workers.","__index_level_0__":1039}
+{"text":"To reduce this replication and save GPU memory, we can shard the model parameters, gradients, and optimizer states across all workers with each worker only managing a single shard. This technique was popularized by the [ZeRO-3](https:\/\/arxiv.org\/abs\/1910.02054) approach developed by Microsoft. A PyTorch-native implementation of this approach is available as [FullyShardedDataParallel](https:\/\/pytorch.org\/docs\/stable\/fsdp.html) (FSDP) API, released as a beta feature in PyTorch 1.12. During a module\u2019s forward and backward passes, FSDP unshards the model parameters as needed for computation (using all-gather) and reshards them after computation. It synchronizes gradients using the reduce-scatter collective to ensure sharded gradients are globally averaged. The forward and backward pass flow of a model wrapped in FSDP are detailed below:","__index_level_0__":1040}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/scaling-multimodal-image3-diagram-of-fully-shared-data-parallel-training.png\" width=\"100%\">\n<\/p>","__index_level_0__":1041}
+{"text":"<p align=\"center\">\n  Source: <a href=\"https:\/\/engineering.fb.com\/2021\/07\/15\/open-source\/fsdp\/\">https:\/\/engineering.fb.com\/2021\/07\/15\/open-source\/fsdp\/<\/a>\n<\/p>","__index_level_0__":1042}
+{"text":"To use FSDP, the submodules of a model need to be wrapped with the API to control when specific submodules are sharded or unsharded. FSDP provides an auto-wrapping API (see the [auto_wrap_policy](https:\/\/pytorch.org\/docs\/stable\/fsdp.html#torch.distributed.fsdp.FullyShardedDataParallel) argument) that can be used out of the box as well as several [wrapping policies](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/distributed\/fsdp\/wrap.py) and the ability to [write your own policy](https:\/\/github.com\/pytorch\/pytorch\/blob\/75c0e3a471c19b883feca15fd4ecfabedf746691\/torch\/distributed\/fsdp\/fully_sharded_data_parallel.py#L858).","__index_level_0__":1043}
+{"text":"The following example demonstrates wrapping the FLAVA model with FSDP. We specify the auto-wrapping policy as `transformer_auto_wrap_policy`. This will wrap individual transformer layers (`TransformerEncoderLayer`), the image transformer (`ImageTransformer`), text encoder (`BERTTextEncoder`) and multimodal encoder (`FLAVATransformerWithoutEmbeddings`) as individual FSDP units. This uses a recursive wrapping approach for efficient memory management. For example, after an individual transformer layer\u2019s forward or backward pass is finished, its parameters are discarded, freeing up memory thereby reducing peak memory usage.","__index_level_0__":1044}
+{"text":"FSDP also provides a number of configurable options to tune the performance of applications. For example, in our use case, we illustrate the use of the new `limit_all_gathers` flag, which prevents all-gathering model parameters too early thereby alleviating memory pressure on the application. We encourage users to experiment with this flag which can potentially improve the performance of applications with high active memory usage.","__index_level_0__":1045}
+{"text":"```Python\nimport torch\nfrom torch.distributed.fsdp import FullyShardedDataParallel as FSDP\nfrom torch.distributed.fsdp.wrap import transformer_auto_wrap_policy\nfrom torchmultimodal.models.flava.model import flava_model_for_pretraining\nfrom torchmultimodal.models.flava.text_encoder import BertTextEncoder\nfrom torchmultimodal.models.flava.image_encoder import ImageTransformer\nfrom torchmultimodal.models.flava.transformer import FLAVATransformerWithoutEmbeddings\nfrom torchmultimodal.modules.layers.transformer import TransformerEncoderLayer","__index_level_0__":1046}
+{"text":"model = flava_model_for_pretraining().cuda()\ndist.init_process_group(backend=\u201dnccl\u201d)","__index_level_0__":1047}
+{"text":"model = FSDP(\n               model,\n               device_id=torch.cuda.current_device(),\n               auto_wrap_policy=partial(\n                   transformer_auto_wrap_policy,\n                   transformer_layer_cls={\n                       TransformerEncoderLayer,\n                       ImageTransformer,\n                       BERTTextEncoder,\n                       FLAVATransformerWithoutEmbeddings\n                   },\n               ),\n               limit_all_gathers=True,\n           )\n```","__index_level_0__":1048}
+{"text":"## Activation Checkpointing","__index_level_0__":1049}
+{"text":"As discussed above, intermediate activations, model parameters, gradients, and optimizer states contribute to the overall GPU memory usage. FSDP can reduce memory consumption due to the latter three but does not reduce memory consumed by activations. Memory used by activations increases with increase in batch size or number of hidden layers. Activation checkpointing is a technique to decrease this memory usage by recomputing the activations during the backward pass instead of holding them in memory for a specific checkpointed module. For example, we observed ~4x reduction in the peak active memory after forward pass by applying activation checkpointing to the 2.7B parameter model. ","__index_level_0__":1050}
+{"text":"PyTorch offers a wrapper based activation checkpointing API. In particular, `checkpoint_wrapper` allows users to wrap an individual module with checkpointing, and `apply_activation_checkpointing` allows users to specify a policy with which to wrap modules within an overall module with checkpointing. Both these APIs can be applied to most models as they do not require any modifications to the model definition code. However, if more granular control over checkpointed segments, such as checkpointing specific functions within a module, is required, the functional `torch.utils.checkpoint` [API](https:\/\/pytorch.org\/docs\/stable\/checkpoint.html) can be leveraged, although this requires modification to the model code. The application of the activation checkpointing wrapper to individual FLAVA transformer layers (denoted by `TransformerEncoderLayer`) is shown below. For a thorough description of activation checkpointing, please see the description in the [PyTorch documentation](https:\/\/pytorch.org\/docs\/stable\/checkpoint.html).","__index_level_0__":1051}
+{"text":"```Python\nfrom torchmultimodal.models.flava.model import flava_model_for_pretraining\nfrom torch.distributed.algorithms._checkpoint.checkpoint_wrapper import apply_activation_checkpointing, checkpoint_wrapper, CheckpointImpl\nfrom torchmultimodal.modules.layers.transformer import TransformerEncoderLayer","__index_level_0__":1052}
+{"text":"model = flava_model_for_pretraining()\ncheckpoint_tformer_layers_policy = lambda submodule: isinstance(submodule, TransformerEncoderLayer)","__index_level_0__":1053}
+{"text":"apply_activation_checkpointing(\n               model,\n               checkpoint_wrapper_fn=checkpoint_wrapper,\n               check_fn=checkpoint_tformer_layers_policy,\n           )\n```\nUsed together, wrapping FLAVA transformer layers with activation checkpointing and wrapping the overall model with FSDP as demonstrated above, we are able to scale FLAVA to 10B parameters.","__index_level_0__":1054}
+{"text":"## Experiments","__index_level_0__":1055}
+{"text":"We conduct an empirical study about the impact of the different optimizations from the previous section on system performance. For all our experiments, we use a single node with 8 A100 40GB GPUs and run the pretraining for 1000 iterations. All runs also used PyTorch\u2019s [automatic mixed precision](https:\/\/pytorch.org\/docs\/stable\/amp.html) with the bfloat16 data type. [TensorFloat32](https:\/\/pytorch.org\/docs\/stable\/notes\/cuda.html#tensorfloat-32-tf32-on-ampere-devices) format is also enabled to improve matmul performance on the A100. We define throughput as the average number of items (text or image) processed per second (we ignore the first 100 iterations while measuring throughput to account for warmup). We leave training to convergence and its impact on downstream task metrics as an area for future study.","__index_level_0__":1056}
+{"text":"Figure 1 plots the throughput for each model configuration and optimization, both with a local batch size of 8 and then with the maximum batch size possible on 1 node. Absence of a data point for a model variant for an optimization indicates that the model could not be trained on a single node.","__index_level_0__":1057}
+{"text":"Figure 2 plots the maximum possible batch size per worker for each optimization. We observe a few things:","__index_level_0__":1058}
+{"text":"1. Scaling model size: DDP is only able to fit the 350M and 900M model on a node. With FSDP, due to memory savings, we are able to train ~3x bigger models compared to DDP  (i.e. the 1.8B and 2.7B variants). Combining activation checkpointing (AC) with FSDP enables training even bigger models, on the order of ~10x compared to DDP (i.e. 4.8B and 10B variants)\n2. Throughput:\n  - For smaller model sizes, at a constant batch size of 8, the throughput for DDP is slightly higher than or equal to FSDP, explainable by the additional communication required by FSDP. It is lowest for FSDP and AC combined together. This is because AC re-runs checkpointed forward passes during the backwards pass, trading off additional computation for memory savings. However, in the case of the 2.7B model, FSDP + AC actually has higher throughput compared to FSDP alone. This is because the 2.7B model with FSDP is operating close to the memory limit even at batch size 8 triggering CUDA malloc retries which tend to slow down training. AC helps with reducing the memory pressure and leads to no retries.\n  - For DDP and FSDP + AC, the throughput increases with an increase in batch size for each model. For FSDP alone, this is true for smaller variants. However, with the 1.8B and 2.7B parameter models, we observe throughput degradation when increasing batch size. A potential reason for this, as noted above also, is that at the memory limit, PyTorch\u2019s CUDA memory management may have to retry cudaMalloc calls and\/or run expensive defragmentation steps to find free memory blocks to handle the workload\u2019s memory requirements which can result in training slowdown.\n  - For larger models that can only be trained with FSDP (1.8B, 2.7B, 4.8B) the setting with highest throughput achieved is with FSDP + AC scaling to the maximum batch size. For 10B, we observe nearly equal throughput for smaller and maximum batch size. This might be counterintuitive as AC results in increased computation and maxing out batch size potentially leads to expensive defragmentation operations due to operating at CUDA memory limit. However, for these large models, the increase in batch size is large enough to mask this overhead.","__index_level_0__":1059}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/scaling-multimodal-image4-graph-experiments-figure1.png\" width=\"100%\">\n<\/p>","__index_level_0__":1060}
+{"text":"<p align=\"center\">\n  Figure 1: Training throughput for different configurations\n<\/p>","__index_level_0__":1061}
+{"text":"<ol start=\"3\">\n  <li>Batch size: FSDP alone enables slightly higher batch sizes compared to DDP. Using FSDP + AC enables ~3x batch size compared to DDP for the 350M param model and ~5.5x for 900M param model. Even for 10B, a max batch size of ~20 which is fairly decent. This essentially enables larger global batch size using fewer GPUs which is especially useful for contrastive learning tasks.<\/li>\n<\/ol>","__index_level_0__":1062}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/scaling-multimodal-image5-graph-experiments-figure-2.png\" width=\"100%\">\n<\/p>","__index_level_0__":1063}
+{"text":"<p align=\"center\">\n  Figure 2: Max local batchsize possible for different configurations\n<\/p>","__index_level_0__":1064}
+{"text":"## Conclusion","__index_level_0__":1065}
+{"text":"As the world moves towards multimodal foundation models, scaling model parameters and efficient training is becoming an area of focus. The PyTorch ecosystem aims to accelerate innovation in this field by providing different tools to the research community, both for training and scaling multimodal models. With FLAVA, we laid out an example of scaling a model for multimodal understanding. In the future, we plan to add support for other kinds of models like the ones for multimodal generation and demonstrate their scaling factors. We also hope to automate many of these scaling and memory saving techniques (such as sharding and activation checkpointing) to reduce the amount of user experimentation needed to achieve the desired scale and maximum training throughput.","__index_level_0__":1066}
+{"text":"## References","__index_level_0__":1067}
+{"text":"- [Introducing TorchMultimodal - a library for accelerating exploration in Multimodal AI](https:\/\/pytorch.org\/blog\/introducing-torchmultimodal\/)\n- [FLAVA paper](https:\/\/deploy-preview-1186--pytorch-dot-org-preview.netlify.app\/blog\/introducing-torchmultimodal\/)\n- [Introducing Pytorch FSDP](https:\/\/pytorch.org\/blog\/introducing-pytorch-fully-sharded-data-parallel-api\/) \n source: https:\/\/pytorch.org\/blog\/scaling-multimodal-foundation-models-in-torchmultimodal-with-pytorch-distributed\/ \n category: pytorch blogs","__index_level_0__":1068}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"A BetterTransformer for Fast Transformer Inference\"\nauthor: Michael Gschwind, Eric Han, Scott Wolchok, Rui Zhu, Christian Puhrsch\nfeatured-img: \"\/assets\/images\/2022-7-12-a-better-transformer-for-fast-transformer-encoder-inference-3.png\"\n---","__index_level_0__":1069}
+{"text":"**tl;dr** Transformers achieve state-of-the-art performance for NLP, and are becoming popular for a myriad of other tasks. They are computationally expensive which has been a blocker to their widespread productionisation. Launching with PyTorch 1.12, BetterTransformer implements a backwards-compatible fast path of `torch.nn.TransformerEncoder` for Transformer Encoder Inference and does not require model authors to modify their models. BetterTransformer improvements can exceed 2x in speedup and throughput for many common execution scenarios. To use BetterTransformer, [install](https:\/\/pytorch.org\/get-started\/locally\/) PyTorch 1.12 and start using high-quality, high-performance Transformer models with the PyTorch API today.","__index_level_0__":1070}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-12-a-better-transformer-for-fast-transformer-encoder-inference-1.png\" width=\"100%\">\n<\/p>","__index_level_0__":1071}
+{"text":"<p align=\"center\">\nDiagram of the Transformer Encoder Architecture (from \"<a href=\"https:\/\/arxiv.org\/abs\/1706.03762\" target=\"_blank\">Attention Is All You Need<\/a>\"). During Inference, the entire module will execute as a single PyTorch-native function.\n<\/p>","__index_level_0__":1072}
+{"text":"In this blog post, we share the following topics \u2014 Performance Improvements, Backwards compatibility, and Taking advantage of the FastPath. Learn more about these topics below.  ","__index_level_0__":1073}
+{"text":"## Performance Improvements","__index_level_0__":1074}
+{"text":"BetterTransformer launches with accelerated native implementations of MultiHeadAttention and TransformerEncoderLayer for CPUs and GPUs. These fast paths are integrated in the standard PyTorch Transformer APIs, and will accelerate [TransformerEncoder](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.TransformerEncoder.html), [TransformerEncoderLayer](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.TransformerEncoderLayer.html) and [MultiHeadAttention](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.MultiheadAttention.html) nn.modules. These new modules implement two types of optimizations: (1) fused kernels combine multiple individual operators normally used to implement Transformers to provide a more efficient implementation, and (2) take advantage of sparsity in the inputs to avoid performing unnecessary operations on padding tokens. Padding tokens frequently account for a large fraction of input batches in many Transformer models used for Natural Language Processing. ","__index_level_0__":1075}
+{"text":"## Backwards compatibility","__index_level_0__":1076}
+{"text":"Advantageously, **no model changes are necessary to benefit from the performance boost offered by BetterTransformer.** To benefit from fast path execution, inputs and operating conditions must satisfy some access conditions (see below). While the internal implementation of Transformer APIs has changed, PyTorch 1.12 maintains strict compatibility with Transformer modules shipped in previous versions, enabling PyTorch users to use models created and trained with previous PyTorch releases while benefiting from BetterTransformer improvements.","__index_level_0__":1077}
+{"text":"In addition to enabling the PyTorch nn.Modules, BetterTransformer provides improvements for PyTorch libraries. Performance benefits will become available through two different enablement paths:","__index_level_0__":1078}
+{"text":"1. <u><strong>Transparent acceleration:<\/strong><\/u> Current users of PyTorch nn.Modules such as [MultiHeadAttention](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.MultiheadAttention.html) as well as higher-level Transformer components will benefit from the improved performance of the new nn.Modules automatically. An example of this is the [visual transformer (ViT)](https:\/\/arxiv.org\/abs\/2010.11929) implementation used in the torchvision library ([code link](https:\/\/github.com\/pytorch\/vision\/blob\/87cde716b7f108f3db7b86047596ebfad1b88380\/torchvision\/models\/vision_transformer.py#L103)).","__index_level_0__":1079}
+{"text":"2. <u><strong>Torchtext library acceleration:<\/strong><\/u> As part of this project, we have optimized Torchtext to build on the PyTorch core API to benefit from BetterTransformer enhancements while maintaining strict and transparent compatibility with previous library versions and models trained with previous Torchtext versions. Using PyTorch Transformers in Torchtext also ensures that Torchtext will benefit from expected future enhancements to the PyTorch Transformer implementation.","__index_level_0__":1080}
+{"text":"## Taking advantage of the Fastpath","__index_level_0__":1081}
+{"text":"BetterTransformer is a fastpath for the PyTorch Transformer API. The fastpath is a native, specialized implementation of key Transformer functions for CPU and GPU that applies to common Transformer use cases. ","__index_level_0__":1082}
+{"text":"To take advantage of input sparsity (i.e. padding) in accelerating your model (see Figure 2), set the keyword argument `enable_nested_tensor=True` when instantiating a [TransformerEncoder](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.TransformerEncoder.html) and pass in the `src_key_padding_mask` argument (which denotes padding tokens) during inference. This requires the padding mask to be contiguous, which is the typical case.","__index_level_0__":1083}
+{"text":"Currently, the BetterTransformer speedup only applies to transformer encoder models used in inference. To benefit from fastpath execution, models must be composed of any of the following components: [TransformerEncoder](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.TransformerEncoder.html), [TransformerEncoderLayer](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.TransformerEncoderLayer.html) or [MultiheadAttention](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.MultiheadAttention.html) (MHA). Fastpath execution is also subject to some criteria. Most importantly, the model must be executed in inference mode and operate on input tensors that do not collect gradient tape information (e.g., running with torch.no_grad). The full list of conditions can be found at these links for [nn.MultiHeadAttention](https:\/\/github.com\/pytorch\/pytorch\/blob\/29189d2ba8e583b2355cd0e9517a1ee742ba12cf\/torch\/nn\/modules\/activation.py#L1060) and [nn.TransformerEncoder](https:\/\/github.com\/pytorch\/pytorch\/blob\/29189d2ba8e583b2355cd0e9517a1ee742ba12cf\/torch\/nn\/modules\/transformer.py#L206), respectively. If the criteria are not met, control flows to the legacy PyTorch 1.11 Transformer implementation which has the same API, but lacks the fastpath performance boost. ","__index_level_0__":1084}
+{"text":"Other transformer models (such as decoder models) which use the PyTorch MultiheadAttention module will benefit from the BetterTransformer fastpath. Planned future work is to expand the end-to-end BetterTransformer fastpath to models based on [TransformerDecoder](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.TransformerDecoder.html) to support popular seq2seq and decoder-only (e.g., [OPT](https:\/\/ai.facebook.com\/blog\/democratizing-access-to-large-scale-language-models-with-opt-175b\/)) model architectures, and to training.","__index_level_0__":1085}
+{"text":"## Speedups","__index_level_0__":1086}
+{"text":"The following graphs show the performance achieved for the [BERT](https:\/\/arxiv.org\/abs\/1810.04805)-base model with small and large-scale inputs:","__index_level_0__":1087}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-12-a-better-transformer-for-fast-transformer-encoder-inference-2.png\" width=\"80%\">\n<\/p>","__index_level_0__":1088}
+{"text":"<p align=\"center\">\n<b>Figure 1: PyTorch 1.12 Improvements with BetterTransformer fastpath execution<\/b>\n<\/p>","__index_level_0__":1089}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-12-a-better-transformer-for-fast-transformer-encoder-inference-3.png\" width=\"80%\">\n<\/p>","__index_level_0__":1090}
+{"text":"<p align=\"center\">\n<b>Figure 2: PyTorch 1.12 Improvements with BetterTransformer fastpath execution<br>\nwith sparsity optimization enabled by enable_nested_tensor=True<\/b>\n<\/p>","__index_level_0__":1091}
+{"text":"\nBetterTransformer includes two types of optimization: (1) fused kernels implementing multiple operations more efficiently in a single kernel, and (2) exploiting sparsity by avoiding unnecessary processing on padding tokens. Enhanced performance for small input sizes benefits primarily from the fused kernel implementations, and shows a constant performance improvement regardless of padding amount. While large inputs still benefit from fused kernels, the computation heavy processing limits the benefits that may be obtained by the fused kernels as baseline performance is already closer to the theoretical peak. However, as we increase the amount of padding, performance increases dramatically as increasingly large amounts of computation can be avoided by exploiting the sparsity introduced by padding in NLP workloads.","__index_level_0__":1092}
+{"text":"## Future Work","__index_level_0__":1093}
+{"text":"As part of our ongoing work on PyTorch BetterTransformer, we are working on extending BetterTransformer improvements to Transformer Decoders. We aim to expand beyond inference to training as well.","__index_level_0__":1094}
+{"text":"We are partnering to enable BetterTransformer on additional libraries such as FairSeq, MetaSeq, and HuggingFace to benefit all Transformer-based PyTorch models. We\u2019ll provide future updates on the progress of BetterTransformer accelerations for the larger PyTorch ecosystem as part of this blog series.","__index_level_0__":1095}
+{"text":"Acknowledgements: The authors would like to thank Lin Qiao, Ajit Mathews, Andrew Tulloch, Dmytro Dzhulgakov, Natalia Gimelshein, Emad El-Haraty, Mark Saroufim, Adnan Aziz, Geeta Chauhan, and Hamid Shojanazeri for their support, contributions and many helpful suggestions throughout the course of this project, and in the preparation of this blog. \n source: https:\/\/pytorch.org\/blog\/a-better-transformer-for-fast-transformer-encoder-inference\/ \n category: pytorch blogs","__index_level_0__":1096}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Experience the power of PyTorch 2.0 on AMD Solutions\"\nauthor: AMD\n---","__index_level_0__":1097}
+{"text":"PyTorch 2.0 represents a significant step forward for the PyTorch machine learning framework.  The stable release of PyTorch 2.0 brings new features that unlock even higher performance, while remaining backward compatible with prior releases and retaining the Pythonic focus which has helped to make PyTorch so enthusiastically adopted by the AI\/ML community. AMD has long been a strong proponent of PyTorch, and we are delighted that the PyTorch 2.0 stable release includes support for AMD Instinct\u2122 and Radeon\u2122 GPUs that are supported by the ROCm\u2122 software platform. ","__index_level_0__":1098}
+{"text":"With the stable PyTorch 2.0 release, PyTorch 2.0 introduces torch.compile as a beta feature underpinned by TorchInductor with support for AMD Instinct and Radeon GPUs through OpenAI Triton deep learning compiler. Through TorchInductor, developers can now generate low level kernels using Triton that are portable and performant to hand-written kernels on native hardware centric kernel programming models.","__index_level_0__":1099}
+{"text":"OpenAI Triton is a language and compiler for blocked algorithms, which aims to provide an abstraction layer between CUDA\/HIP and Torch at which developers can write efficient kernels more productively.  We have written a new backend which interfaces Triton's custom MLIR dialects with our ROCm compiler stack.","__index_level_0__":1100}
+{"text":"Triton can automatically optimize kernels generated by machine learning compilers such as TorchInductor for multiple AI accelerators including AMD Instinct GPU accelerator by leveraging hardware-specific features of the AMD CDNA\u2122 GPU architecture. This makes it easy for developers and users to switch seamlessly from any HW to AMD Instinct GPU accelerators and get great out of the box performance. ","__index_level_0__":1101}
+{"text":"In addition, compilers like Triton can also enable developers to use high-level programming languages, such as Python, to write machine learning code that can be efficiently compiled and executed on specialized hardware. This can help greatly improve the productivity of machine learning developers, as they can focus on the algorithmic aspects of their models and rely on the compiler to generate efficient code.","__index_level_0__":1102}
+{"text":"By design, PyTorch 2.0 is backward compatible to earlier PyTorch releases. This holds true for the ROCm build of PyTorch 2.0 as well. Developers using PyTorch with AMD GPUs can migrate to PyTorch 2.0 with the confidence that their existing code will continue to work without any required changes, so there is no penalty to access the improvements that come with this release. On the other hand, using PyTorch 2.0 and TorchInductor can result in significant performance improvement over the default eager-mode as shown below. ","__index_level_0__":1103}
+{"text":"The initial results using AMD Instinct MI250 GPUs already shows strong performance improvement with minimal optimization on TorchInductor compared to the default eager-mode. We see an average performance increase of up to 1.54X on 44 out of the 45 models on HuggingFace benchmarks suite with CamemBert, DistillGPT2 and T5Small being a few of the standout models with up to 1.5X or more performance improvement over eager-mode. We are looking forward to continued engagement with members of the PyTorch team at Meta to enable further optimization on ROCm software stack and the additional performance improvement for future PyTorch releases.  ","__index_level_0__":1104}
+{"text":"![Image 1: AMD MI250 GPU performance improvement for TorchInductor vs eager-mode using HuggingFace](\/assets\/images\/t-vs-eager-mode.svg){:style=\"max-height:800px; width:100%\"}   ","__index_level_0__":1105}
+{"text":"<small style=\"line-height: 1.1\"><em>Image 1: AMD MI250 GPU performance improvement for TorchInductor vs eager-mode using HuggingFace <sup>MI200-89.<\/sup><\/em><\/small>","__index_level_0__":1106}
+{"text":"PyTorch 2.0 follows the same set of install options as before to build and install for supporting AMD GPUs. These include an installable Python package hosted at [pytorch.org](https:\/\/pytorch.org\/), AMD\u2019s public PyTorch docker image, and of course the option to build from source using the upstream PyTorch repository. As with PyTorch builds for other platforms, the specific command line to be run for pip-based install is provided by the configurator at [https:\/\/pytorch.org\/get-started\/locally\/](https:\/\/pytorch.org\/get-started\/locally\/).","__index_level_0__":1107}
+{"text":"The GPUs supported by the ROCm software platform which forms the basis for PyTorch support on AMD GPUs are documented at [https:\/\/docs.amd.com\/bundle\/Hardware_and_Software_Reference_Guide\/page\/Hardware_and_Software_Support.html](https:\/\/docs.amd.com\/bundle\/Hardware_and_Software_Reference_Guide\/page\/Hardware_and_Software_Support.html)","__index_level_0__":1108}
+{"text":"## Conclusion","__index_level_0__":1109}
+{"text":"PyTorch 2.0 represents a major step in continuing to broaden support for ML developers by increasing performance while maintaining a simple, Pythonic interface. This performance uplift is made possible in large part by the new TorchInductor infrastructure, which in turn harnesses the Triton ML programming language and just-in-time compiler. AMD\u2019s support for these technologies allows users to realize the full promise of the new PyTorch architecture.  Our GPU support in PyTorch 2.0 is just one manifestation of a larger vision around AI and machine learning. AI\/ML plays an important role in multiple AMD product lines, including Instinct and Radeon GPUs, Alveo\u2122 data center accelerators, and both Ryzen\u2122 and EPYC processors. These hardware and software initiatives are all part of AMD\u2019s Pervasive AI vision, and we look forward to addressing the many new challenges and opportunities of this dynamic space.","__index_level_0__":1110}
+{"text":"MI200-89 \u2013 PyTorch Inductor mode HuggingFace Transformers training speedup, running the standard PyTorch 2.0 test suite, over PyTorch eager-mode comparison based on AMD internal testing on a single GCD as of 3\/10\/2023 using a 2P AMD EPYC\u2122 7763 production server with 4x AMD Instinct\u2122 MI250 (128GB HBM2e) 560W GPUs with Infinity Fabric\u2122 technology; host ROCm\u2122 5.3, guest ROCm\u2122 5.4.4, PyTorch 2.0.0, Triton 2.0. Server manufacturers may vary configurations, yielding different results. Performance may vary based on factors including use of latest drivers and optimizations. ","__index_level_0__":1111}
+{"text":"<small style=\"line-height: 1.1\">\u00a9 2023 Advanced Micro Devices, Inc. All rights reserved. AMD, the AMD Arrow logo, AMD CDNA, AMD Instinct, EPYC, Radeon, ROCm, Ryzen, and combinations thereof are trademarks of Advanced Micro Devices, Inc. Other product names used in this publication are for identification purposes only and may be trademarks of their respective owners.<\/small> \n source: https:\/\/pytorch.org\/blog\/experience-power-pytorch-2.0\/ \n category: pytorch blogs","__index_level_0__":1112}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Announcing PyTorch Developer Day 2021'\nauthor: Team PyTorch\nfeatured-img: 'assets\/images\/ptdevday21.gif'\n---","__index_level_0__":1113}
+{"text":"We are excited to announce PyTorch Developer Day (#PTD2), taking place virtually from December 1 & 2, 2021. Developer Day is designed for developers and users to discuss core technical developments, ideas, and roadmaps. ","__index_level_0__":1114}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/ptdevday21.gif\" width=\"100%\">\n<\/div>","__index_level_0__":1115}
+{"text":"## Event Details \n**Technical Talks Live Stream - December 1, 2021**","__index_level_0__":1116}
+{"text":"Join us for technical talks on a variety of topics, including updates to the core framework, new tools and libraries to support development across a variety of domains, responsible AI and industry use cases. All talks will take place on December 1 and will be live streamed on PyTorch channels. ","__index_level_0__":1117}
+{"text":"Stay up to date by following us on our social channels: [Twitter](https:\/\/twitter.com\/PyTorch), [Facebook](https:\/\/facebook.com\/PyTorch), or [LinkedIn](https:\/\/www.linkedin.com\/company\/pytorch).","__index_level_0__":1118}
+{"text":"**Poster Exhibition & Networking - December 2, 2021**","__index_level_0__":1119}
+{"text":"On the second day, we\u2019ll be hosting an online poster exhibition on Gather.Town. There will be opportunities to meet the authors and learn more about their PyTorch projects as well as network with the community. This poster and networking event is limited to people composed of PyTorch maintainers and contributors, long-time stakeholders and experts in areas relevant to PyTorch\u2019s future. Conversations from the networking event will strongly shape the future of PyTorch. As such, invitations are required to attend the networking event. ","__index_level_0__":1120}
+{"text":"Apply for an invitation to the networking event by clicking [here](https:\/\/pytorchdeveloperday.fbreg.com\/).","__index_level_0__":1121}
+{"text":"## Call for Content Now Open","__index_level_0__":1122}
+{"text":"Submit your poster abstracts today! Please send us the title and brief summary of your project, tools and libraries that could benefit PyTorch researchers in academia and industry, application developers, and ML engineers for consideration. The focus must be on academic papers, machine learning research, or open-source projects related to PyTorch development, Responsible AI or Mobile. Please no sales pitches. **Deadline for submission is September 24, 2021**. ","__index_level_0__":1123}
+{"text":"You can submit your poster abstract during your application & registration process [here](https:\/\/pytorchdeveloperday.fbreg.com\/apply).","__index_level_0__":1124}
+{"text":"Visit the [event website](https:\/\/pytorchdeveloperday.fbreg.com\/) for more information and we look forward to having you at PyTorch Developer Day. For any questions about the event, contact [pytorch@fbreg.com](mailto:pytorch@fbreg.com). \n \n source: https:\/\/pytorch.org\/blog\/pytorch-developer-day-2021\/ \n category: pytorch blogs","__index_level_0__":1125}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Efficient PyTorch: Tensor Memory Format Matters'\nauthor: 'Dhruv Matani, Suraj Subramanian'\nfeatured-img: ''\n---","__index_level_0__":1126}
+{"text":"Ensuring the right memory format for your inputs can significantly impact the running time of your PyTorch vision models. When in doubt, choose a Channels Last memory format.","__index_level_0__":1127}
+{"text":"When dealing with vision models in PyTorch that accept multimedia (for example image Tensorts) as input, the Tensor\u2019s memory format can significantly impact **the inference execution speed of your model on mobile platforms when using the CPU backend along with XNNPACK**. This holds true for training and inference on server platforms as well, but latency is particularly critical for mobile devices and users.","__index_level_0__":1128}
+{"text":"<style type=\"text\/css\">\narticle.pytorch-article table tr th, article.pytorch-article table td {line-height: 1.5rem}\n<\/style>","__index_level_0__":1129}
+{"text":"## Outline of this article\n1. Deep Dive into matrix storage\/memory representation in C++. Introduction to [Row and Column major order](https:\/\/en.wikipedia.org\/wiki\/Row-_and_column-major_order).\n2. Impact of looping over a matrix in the same or different order as the storage representation, along with an example.\n3. Introduction to Cachegrind; a tool to inspect the cache friendliness of your code.\n4. Memory formats supported by PyTorch Operators.\n5. Best practices example to ensure efficient model execution with XNNPACK optimizations","__index_level_0__":1130}
+{"text":"## Matrix Storage Representation in C++","__index_level_0__":1131}
+{"text":"Images are fed into PyTorch ML models as multi-dimensional Tensors. These Tensors have specific memory formats. To understand this concept better, let\u2019s take a look at how a 2-d matrix may be stored in memory.","__index_level_0__":1132}
+{"text":"Broadly speaking, there are 2 main ways of efficiently storing multi-dimensional data in memory.\n1. **Row Major Order:** In this format, the matrix is stored in row order, with each row stored before the next row in memory. I.e. row N comes before row N+1.\n2. **Column Major Order:** In this format, the matrix is stored in column-order, with each column stored before the next column in memory. I.e. column N comes before column N+1.","__index_level_0__":1133}
+{"text":"You can see the differences graphically below.","__index_level_0__":1134}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/tensor\/image1.png\" alt=\"C++ stores multi-dimensional data in row-major format.\" width=\"100%\">\n<br>\nC++ stores multi-dimensional data in row-major format.\n<\/p>","__index_level_0__":1135}
+{"text":"## Efficiently accessing elements of a 2d matrix","__index_level_0__":1136}
+{"text":"Similar to the storage format, there are 2 ways to access data in a 2d matrix.","__index_level_0__":1137}
+{"text":"1. **Loop Over Rows first:** All elements of a row are processed before any element of the next row.\n2. **Loop Over Columns first:** All elements of a column are processed before any element of the next column.","__index_level_0__":1138}
+{"text":"For maximum efficiency, one should always access data in the same format in which it is stored. I.e. if the data is stored in row-major order, then one should try to access it in that order.","__index_level_0__":1139}
+{"text":"The code below (main.cpp) shows [2 ways](https:\/\/stackoverflow.com\/questions\/9936132\/why-does-the-order-of-the-loops-affect-performance-when-iterating-over-a-2d-arra) of accessing all the elements of a 2d 4000x4000 matrix.","__index_level_0__":1140}
+{"text":"```python\n#include <iostream>\n#include <chrono>","__index_level_0__":1141}
+{"text":"\/\/ loop1 accesses data in matrix 'a' in row major order,\n\/\/ since i is the outer loop variable, and j is the\n\/\/ inner loop variable.\nint loop1(int a[4000][4000]) {\n int s = 0;\n for (int i = 0; i < 4000; ++i) {\n   for (int j = 0; j < 4000; ++j) {\n     s += a[i][j];\n   }\n }\n return s;\n}","__index_level_0__":1142}
+{"text":"\/\/ loop2 accesses data in matrix 'a' in column major order\n\/\/ since j is the outer loop variable, and i is the\n\/\/ inner loop variable.\nint loop2(int a[4000][4000]) {\n int s = 0;\n for (int j = 0; j < 4000; ++j) {\n   for (int i = 0; i < 4000; ++i) {\n     s += a[i][j];\n   }\n }\n return s;\n}","__index_level_0__":1143}
+{"text":"int main() {\n static int a[4000][4000] = {0};\n for (int i = 0; i < 100; ++i) {\n   int x = rand() % 4000;\n   int y = rand() % 4000;\n   a[x][y] = rand() % 1000;\n }","__index_level_0__":1144}
+{"text":" auto start = std::chrono::high_resolution_clock::now();\n auto end = start;\n int s = 0;","__index_level_0__":1145}
+{"text":"#if defined RUN_LOOP1\n start = std::chrono::high_resolution_clock::now();","__index_level_0__":1146}
+{"text":" s = 0;\n for (int i = 0; i < 10; ++i) {\n   s += loop1(a);\n   s = s % 100;\n }\n end = std::chrono::high_resolution_clock::now();","__index_level_0__":1147}
+{"text":" std::cout << \"s = \" << s << std::endl;\n std::cout << \"Time for loop1: \"\n   << std::chrono::duration<double, std::milli>(end - start).count()\n   << \"ms\" << std::endl;\n#endif","__index_level_0__":1148}
+{"text":"#if defined RUN_LOOP2\n start = std::chrono::high_resolution_clock::now();\n s = 0;\n for (int i = 0; i < 10; ++i) {\n   s += loop2(a);\n   s = s % 100;\n }\n end = std::chrono::high_resolution_clock::now();","__index_level_0__":1149}
+{"text":" std::cout << \"s = \" << s << std::endl;\n std::cout << \"Time for loop2: \"\n   << std::chrono::duration<double, std::milli>(end - start).count()\n   << \"ms\" << std::endl;\n#endif\n}","__index_level_0__":1150}
+{"text":"\nLet\u2019s build and run this program and see what it prints.","__index_level_0__":1151}
+{"text":"g++ -O2 main.cpp -DRUN_LOOP1 -DRUN_LOOP2\n.\/a.out","__index_level_0__":1152}
+{"text":"\nPrints the following:","__index_level_0__":1153}
+{"text":"s = 70\nTime for loop1: 77.0687ms\ns = 70\nTime for loop2: 1219.49ms\n```","__index_level_0__":1154}
+{"text":"loop1() is **15x faster** than loop2(). Why is that? Let\u2019s find out below!","__index_level_0__":1155}
+{"text":"## Measure cache misses using Cachegrind","__index_level_0__":1156}
+{"text":"[Cachegrind](https:\/\/courses.cs.washington.edu\/courses\/cse326\/05wi\/valgrind-doc\/cg_main.html) is a cache profiling tool used to see how many I1 (first level instruction), D1 (first level data), and LL (last level) cache misses your program caused.","__index_level_0__":1157}
+{"text":"Let\u2019s build our program with just loop1() and just loop2() to see how cache friendly each of these functions is.","__index_level_0__":1158}
+{"text":"### Build and run\/profile just loop1()","__index_level_0__":1159}
+{"text":"```python\ng++ -O2 main.cpp -DRUN_LOOP1\nvalgrind --tool=cachegrind .\/a.out\n```","__index_level_0__":1160}
+{"text":"#### Prints:","__index_level_0__":1161}
+{"text":"```python\n==3299700==\n==3299700== I   refs:      643,156,721\n==3299700== I1  misses:          2,077\n==3299700== LLi misses:          2,021\n==3299700== I1  miss rate:        0.00%\n==3299700== LLi miss rate:        0.00%\n==3299700==\n==3299700== D   refs:      160,952,192  (160,695,444 rd   + 256,748 wr)\n==3299700== D1  misses:     10,021,300  ( 10,018,723 rd   +   2,577 wr)\n==3299700== LLd misses:     10,010,916  ( 10,009,147 rd   +   1,769 wr)\n==3299700== D1  miss rate:         6.2% (        6.2%     +     1.0%  )\n==3299700== LLd miss rate:         6.2% (        6.2%     +     0.7%  )\n==3299700==\n==3299700== LL refs:        10,023,377  ( 10,020,800 rd   +   2,577 wr)\n==3299700== LL misses:      10,012,937  ( 10,011,168 rd   +   1,769 wr)\n==3299700== LL miss rate:          1.2% (        1.2%     +     0.7%  )\n```","__index_level_0__":1162}
+{"text":"### Build and run\/profile just loop2()","__index_level_0__":1163}
+{"text":"\n```python\ng++ -O2 main.cpp -DRUN_LOOP2\nvalgrind --tool=cachegrind .\/a.out\n```","__index_level_0__":1164}
+{"text":"#### Prints:","__index_level_0__":1165}
+{"text":"```python\n==3300389==\n==3300389== I   refs:      643,156,726\n==3300389== I1  misses:          2,075\n==3300389== LLi misses:          2,018\n==3300389== I1  miss rate:        0.00%\n==3300389== LLi miss rate:        0.00%\n==3300389==\n==3300389== D   refs:      160,952,196  (160,695,447 rd   + 256,749 wr)\n==3300389== D1  misses:    160,021,290  (160,018,713 rd   +   2,577 wr)\n==3300389== LLd misses:     10,014,907  ( 10,013,138 rd   +   1,769 wr)\n==3300389== D1  miss rate:        99.4% (       99.6%     +     1.0%  )\n==3300389== LLd miss rate:         6.2% (        6.2%     +     0.7%  )\n==3300389==\n==3300389== LL refs:       160,023,365  (160,020,788 rd   +   2,577 wr)\n==3300389== LL misses:      10,016,925  ( 10,015,156 rd   +   1,769 wr)\n==3300389== LL miss rate:          1.2% (        1.2%     +     0.7%  )\n```","__index_level_0__":1166}
+{"text":"The main differences between the 2 runs are:\n1. **D1 misses:** 10M v\/s 160M\n2. **D1 miss rate:** 6.2% v\/s 99.4%","__index_level_0__":1167}
+{"text":"As you can see, `loop2()` causes many many more (**~16x more**) L1 data cache misses than loop1(). This is why `loop1()` is ~15x faster than loop2().","__index_level_0__":1168}
+{"text":"## Memory Formats supported by PyTorch Operators","__index_level_0__":1169}
+{"text":"While PyTorch operators expect all tensors to be in [Channels First (NCHW) dimension format](https:\/\/discuss.pytorch.org\/t\/why-does-pytorch-prefer-using-nchw\/83637\/4), PyTorch operators support 3 output [memory formats](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/c10\/core\/MemoryFormat.h).","__index_level_0__":1170}
+{"text":"1. **Contiguous:** Tensor memory is in the same order as the tensor\u2019s dimensions.\n2. **ChannelsLast:** Irrespective of the dimension order, the 2d (image) tensor is laid out as an HWC or [NHWC](https:\/\/oneapi-src.github.io\/oneDNN\/dev_guide_understanding_memory_formats.html) (N: batch, H: height, W: width, C: channels) tensor in memory. The dimensions could be permuted in any order.\n3. **ChannelsLast3d:** For 3d tensors (video tensors), the memory is laid out in THWC (Time, Height, Width, Channels) or NTHWC (N: batch, T: time, H: height, W: width, C: channels) format. The dimensions could be permuted in any order.","__index_level_0__":1171}
+{"text":"The reason that ChannelsLast is preferred for vision models is because [XNNPACK](https:\/\/github.com\/google\/XNNPACK) (kernel acceleration library) used by PyTorch expects all inputs to be in **Channels Last** format, so if the input to the model isn\u2019t channels last, then it must first be converted to channels last, which is an additional operation.","__index_level_0__":1172}
+{"text":"Additionally, most PyTorch operators preserve the input tensor\u2019s memory format, so if the input is Channels First, then the operator needs to first convert to Channels Last, then perform the operation, and then convert back to Channels First.","__index_level_0__":1173}
+{"text":"When you combine it with the fact that accelerated operators work better with a channels last memory format, you\u2019ll notice that having the operator return back a channels-last memory format is better for subsequent operator calls or you\u2019ll end up having every operator convert to channels-last (should it be more efficient for that specific operator).","__index_level_0__":1174}
+{"text":"From the XNNPACK home page:","__index_level_0__":1175}
+{"text":"> \u201cAll operators in XNNPACK support NHWC layout, but additionally allow custom stride along the Channel dimension\".","__index_level_0__":1176}
+{"text":"## PyTorch Best Practice","__index_level_0__":1177}
+{"text":"The best way to get the most performance from your PyTorch vision models is to ensure that your input tensor is in a **Channels Last** [memory format](https:\/\/pytorch.org\/tutorials\/intermediate\/memory_format_tutorial.html) before it is fed into the model.","__index_level_0__":1178}
+{"text":"You can get even more speedups by optimizing your model to use the XNNPACK backend (by simply calling `optimize_for_mobile()` on your torchscripted model). Note that XNNPACK models will run slower if the inputs are contiguous, so definitely make sure it is in Channels-Last format.","__index_level_0__":1179}
+{"text":"## Working example showing speedup","__index_level_0__":1180}
+{"text":"Run this example on [Google Colab](https:\/\/colab.research.google.com\/gist\/suraj813\/ad9aebcbffbdd6d02b23ca7231130a30\/channels-last-with-xnnpack.ipynb#scrollTo=xvJN73YWXgDF) - note that runtimes on colab CPUs might not reflect accurate performance; it is recommended to run this code on your local machine.","__index_level_0__":1181}
+{"text":"```python\nimport torch\nfrom torch.utils.mobile_optimizer import optimize_for_mobile\nimport torch.backends.xnnpack\nimport time","__index_level_0__":1182}
+{"text":"print(\"XNNPACK is enabled: \", torch.backends.xnnpack.enabled, \"\\n\")","__index_level_0__":1183}
+{"text":"N, C, H, W = 1, 3, 200, 200\nx = torch.rand(N, C, H, W)\nprint(\"Contiguous shape: \", x.shape)\nprint(\"Contiguous stride: \", x.stride())\nprint()","__index_level_0__":1184}
+{"text":"xcl = x.to(memory_format=torch.channels_last)\nprint(\"Channels-Last shape: \", xcl.shape)\nprint(\"Channels-Last stride: \", xcl.stride())","__index_level_0__":1185}
+{"text":"## Outputs:\n \n# XNNPACK is enabled:  True\n \n# Contiguous shape:  torch.Size([1, 3, 200, 200])\n# Contiguous stride:  (120000, 40000, 200, 1)\n \n# Channels-Last shape:  torch.Size([1, 3, 200, 200])\n# Channels-Last stride:  (120000, 1, 600, 3)","__index_level_0__":1186}
+{"text":"The input shape stays the same for contiguous and channels-last formats. Internally however, the tensor's layout has changed as you can see in the strides. Now, the number of jumps required to go across channels is only 1 (instead of 40000 in the contiguous tensor).\nThis better data locality means convolution layers can access all the channels for a given pixel much faster. Let's see now how the memory format affects runtime:","__index_level_0__":1188}
+{"text":"```python\nfrom torchvision.models import resnet34, resnet50, resnet101","__index_level_0__":1189}
+{"text":"m = resnet34(pretrained=False)\n# m = resnet50(pretrained=False)\n# m = resnet101(pretrained=False)","__index_level_0__":1190}
+{"text":"def get_optimized_model(mm):\n  mm = mm.eval()\n  scripted = torch.jit.script(mm)\n  optimized = optimize_for_mobile(scripted)  # explicitly call the xnnpack rewrite \n  return scripted, optimized","__index_level_0__":1191}
+{"text":"\ndef compare_contiguous_CL(mm):\n  # inference on contiguous\n  start = time.perf_counter()\n  for i in range(20):\n    mm(x)\n  end = time.perf_counter()\n  print(\"Contiguous: \", end-start)","__index_level_0__":1192}
+{"text":"  # inference on channels-last\n  start = time.perf_counter()\n  for i in range(20):\n    mm(xcl)\n  end = time.perf_counter()\n  print(\"Channels-Last: \", end-start)","__index_level_0__":1193}
+{"text":"with torch.inference_mode():\n  scripted, optimized = get_optimized_model(m)","__index_level_0__":1194}
+{"text":"  print(\"Runtimes for torchscripted model: \")\n  compare_contiguous_CL(scripted.eval())\n  print()\n  print(\"Runtimes for mobile-optimized model: \")\n  compare_contiguous_CL(optimized.eval())","__index_level_0__":1195}
+{"text":"   \n## Outputs (on an Intel Core i9 CPU):\n \n# Runtimes for torchscripted model:\n# Contiguous:  1.6711160129999598\n# Channels-Last:  1.6678222839999535\n \n# Runtimes for mobile-optimized model:\n# Contiguous:  0.5712863490000473\n# Channels-Last:  0.46113000699995155","__index_level_0__":1196}
+{"text":"## Conclusion","__index_level_0__":1198}
+{"text":"The Memory Layout of an input tensor can significantly impact a model\u2019s running time. For Vision Models, prefer a **Channels Last** memory format to get the most out of your PyTorch models.","__index_level_0__":1199}
+{"text":"## References","__index_level_0__":1200}
+{"text":"- [Row\/Column Major matrix storage order](https:\/\/en.wikipedia.org\/wiki\/Row-_and_column-major_order)\n- [Loop order impact on performance](https:\/\/stackoverflow.com\/questions\/9936132\/why-does-the-order-of-the-loops-affect-performance-when-iterating-over-a-2d-arra)\n- [Cachegrind: a cache-miss profiler](https:\/\/courses.cs.washington.edu\/courses\/cse326\/05wi\/valgrind-doc\/cg_main.html)\n- [NHWC format explained](https:\/\/oneapi-src.github.io\/oneDNN\/dev_guide_understanding_memory_formats.html)\n- [Why does PyTorch prefer NCHW?](https:\/\/discuss.pytorch.org\/t\/why-does-pytorch-prefer-using-nchw\/83637\/4)\n- [XNNPACK](https:\/\/github.com\/google\/XNNPACK)\n- [PyTorch memory format tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/memory_format_tutorial.html)\n- [Supported operators](https:\/\/github.com\/pytorch\/pytorch\/wiki\/Operators-with-Channels-Last-support)\n \n source: https:\/\/pytorch.org\/blog\/tensor-memory-format-matters\/ \n category: pytorch blogs","__index_level_0__":1201}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch framework for cryptographically secure random number generation, torchcsprng, now available'\nauthor: Team PyTorch\n---","__index_level_0__":1202}
+{"text":"One of the key components of modern cryptography is the pseudorandom number generator. Katz and Lindell stated, \"The use of badly designed or inappropriate random number generators can often leave a good cryptosystem vulnerable to attack. Particular care must be taken to use a random number generator that is designed for cryptographic use, rather than a 'general-purpose' random number generator which may be fine for some applications but not ones that are required to be cryptographically secure.\"[1] Additionally, most pseudorandom number generators scale poorly to massively parallel high-performance computation because of their sequential nature. Others don\u2019t satisfy cryptographically secure properties.","__index_level_0__":1203}
+{"text":"[torchcsprng](https:\/\/github.com\/pytorch\/csprng) is a PyTorch [C++\/CUDA extension](https:\/\/pytorch.org\/tutorials\/advanced\/cpp_extension.html) that provides [cryptographically secure pseudorandom number generators](https:\/\/en.wikipedia.org\/wiki\/Cryptographically_secure_pseudorandom_number_generator) for PyTorch.","__index_level_0__":1204}
+{"text":"## torchcsprng overview ","__index_level_0__":1205}
+{"text":"Historically, PyTorch had only two pseudorandom number generator implementations: Mersenne Twister for CPU and Nvidia\u2019s cuRAND Philox for CUDA. Despite good performance properties, neither of them are suitable for cryptographic applications. Over the course of the past several months, the PyTorch team developed the torchcsprng extension API. Based on PyTorch dispatch mechanism and operator registration, it allows the users to extend c10::GeneratorImpl and implement their own custom pseudorandom number generator.","__index_level_0__":1206}
+{"text":"torchcsprng generates a random 128-bit key on the CPU using one of its generators and then runs AES128 in [CTR mode](https:\/\/en.wikipedia.org\/wiki\/Block_cipher_mode_of_operation#Counter_(CTR)) either on CPU or GPU using CUDA. This then generates a random 128-bit state and applies a transformation function to map it to target tensor values. This approach is based on [Parallel Random Numbers: As Easy as 1, 2, 3 (John K. Salmon, Mark A. Moraes, Ron O. Dror, and David E. Shaw, D. E. Shaw Research)](http:\/\/www.thesalmons.org\/john\/random123\/papers\/random123sc11.pdf). It makes torchcsprng both crypto-secure and parallel on both CPU and CUDA.","__index_level_0__":1207}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/torchcsprng.png\" width=\"100%\">\n<\/div>","__index_level_0__":1208}
+{"text":"Since torchcsprng is a PyTorch extension, it is available on the platforms where PyTorch is available (support for Windows-CUDA will be available in the coming months). ","__index_level_0__":1209}
+{"text":"## Using torchcsprng","__index_level_0__":1210}
+{"text":"The torchcsprng API is very simple to use and is fully compatible with the PyTorch random infrastructure:","__index_level_0__":1211}
+{"text":"**Step 1: Install via binary distribution**","__index_level_0__":1212}
+{"text":"```python\nconda install torchcsprng -c pytorch\n ```","__index_level_0__":1214}
+{"text":"```python\npip install torchcsprng\n ```","__index_level_0__":1216}
+{"text":"**Step 2: import packages as usual but add csprng**","__index_level_0__":1217}
+{"text":"```python\nimport torch\nimport torchcsprng as csprng\n ```","__index_level_0__":1218}
+{"text":"**Step 3: Create a cryptographically secure pseudorandom number generator from \/dev\/urandom:**","__index_level_0__":1219}
+{"text":"```python\nurandom_gen = csprng.create_random_device_generator('\/dev\/urandom')\n ```\n \nand simply use it with the existing PyTorch methods:","__index_level_0__":1220}
+{"text":"```python\ntorch.randn(10, device='cpu', generator=urandom_gen)\n ```","__index_level_0__":1221}
+{"text":"**Step 4: Test with Cuda**","__index_level_0__":1222}
+{"text":"One of the advantages of torchcsprng generators is that they can be used with both CPU and CUDA tensors:","__index_level_0__":1223}
+{"text":"```python\ntorch.randn(10, device='cuda', generator=urandom_gen)\n ```","__index_level_0__":1224}
+{"text":"Another advantage of torchcsprng generators is that they are parallel on CPU unlike the default PyTorch CPU generator.","__index_level_0__":1225}
+{"text":"## Getting Started","__index_level_0__":1226}
+{"text":"The easiest way to get started with torchcsprng is by visiting the [GitHub page](https:\/\/github.com\/pytorch\/csprng) where you can find installation and build instructions, and more how-to examples. ","__index_level_0__":1227}
+{"text":"The PyTorch Team","__index_level_0__":1229}
+{"text":"[1] [Introduction to Modern Cryptography: Principles and Protocols (Chapman & Hall\/CRC Cryptography and Network Security Series)](https:\/\/www.amazon.com\/Introduction-Modern-Cryptography-Principles-Protocols\/dp\/1584885513) by Jonathan Katz and Yehuda Lindell","__index_level_0__":1230}
+{"text":"\n \n source: https:\/\/pytorch.org\/blog\/torchcsprng-release-blog\/ \n category: pytorch blogs","__index_level_0__":1232}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Optimizing Production PyTorch Models\u2019 Performance with Graph Transformations\"\nauthor: Jade Nie, CK Luk, Xiaodong Wang, Jackie (Jiaqi) Xu\nfeatured-img: \"assets\/images\/blog1-3b.png\"\n---","__index_level_0__":1233}
+{"text":"## 1. Introduction","__index_level_0__":1234}
+{"text":"PyTorch supports two execution modes [1]: eager mode and graph mode. In eager mode, operators in a model are immediately executed as they are encountered. In contrast, in graph mode, operators are first synthesized into a graph, which will then be compiled and executed as a whole. Eager mode is easier to use, more suitable for ML researchers, and hence is the default mode of execution. On the other hand, graph mode typically delivers higher performance and hence is heavily used in production.","__index_level_0__":1235}
+{"text":"Specifically, graph mode enables operator fusion [2], wherein one operator is merged with another to reduce\/localize memory reads as well as total kernel launch overhead. Fusion can be horizontal\u2014taking a single operation (e.g., BatchNorm) that is independently applied to many operands and merging those operands into an array; and vertical\u2014merging a kernel with another kernel that consumes the output of the first kernel (e.g., Convolution followed by ReLU).","__index_level_0__":1236}
+{"text":"Torch.FX [3, 4] (abbreviated as FX) is a publicly available toolkit as part of the PyTorch package that supports graph mode execution. In particular, it (1) captures the graph from a PyTorch program and (2) allows developers to write transformations on the captured graph. It is used inside Meta to optimize the training throughput of production models. By introducing a number of FX-based optimizations developed at Meta, we demonstrate the approach of using graph transformation to optimize PyTorch\u2019s performance for production.","__index_level_0__":1237}
+{"text":"## 2. Background","__index_level_0__":1238}
+{"text":"Embedding tables are ubiquitous in recommendation systems. Section 3 will discuss three FX transformations that optimize accesses to embedding tables. In this section, we provide some background on FX (Section 2.1) and embedding tables (Section 2.2).","__index_level_0__":1239}
+{"text":"Figure 1 is a simple example adopted from [3] which illustrates using FX to transform a PyTorch program. It contains three steps: (1) capturing the graph from a program, (2) modifying the graph (in this example, all uses of RELU are replaced by GELU), and (3) generating a new program from the modified graph.","__index_level_0__":1241}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog1-fig-1.png\" width=\"70%\">\n<\/p>","__index_level_0__":1242}
+{"text":"**Figure 1: A FX example which replaces all uses of RELU by GELU in a PyTorch module.**","__index_level_0__":1243}
+{"text":"The FX API [4] provides many more functionalities for inspecting and transforming PyTorch program graphs.","__index_level_0__":1244}
+{"text":"### 2.2 Embedding Tables","__index_level_0__":1245}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog1-fig-2.png\" width=\"90%\">\n<\/p>","__index_level_0__":1246}
+{"text":"**Figure 2: Illustration of an embedding table for a sparse feature with batch size = 1**","__index_level_0__":1247}
+{"text":"In a recommendation system, sparse features (e.g., User ID, Story ID) are represented by embedding tables. An embedding table E is an HxD matrix, where H is the hash size, D is the embedding dimension. Each row of E is a vector of floats. Feature hashing [5] is used to map a sparse feature to a list of indices to E, say [S<sub>1<\/sub>,S<sub>2<\/sub>, \u2026, S<sub>k<\/sub>], where 0&lt;=S<sub>i<\/sub>&lt;H. Its output value is computed as f(E[S<sub>1<\/sub>], E[S<sub>2<\/sub>], \u2026, E[S<sub>k<\/sub>]), where E[S<sub>i<\/sub>] is the vector at row S<sub>i<\/sub>, and f is called the pooling function, which is typically one of the following functions: sum, average, maximum. See Figure 2 for an illustration.","__index_level_0__":1248}
+{"text":"To fully utilize the GPU, sparse features are usually processed in a batch. Each entity in a batch has its own list of indices. If a batch has B entities, a naive representation has B lists of indices. A more compact representation is to combine the B lists of indices into a single list of indices and add a list of the lengths of indices (one length for each entity in the batch). For example, if a batch has 3 entities whose lists of indices are as follows:","__index_level_0__":1249}
+{"text":"- Entity 1: indices = [10, 20]\n- Entity 2: indices = [5, 9, 77, 81]\n- Entity 3: indices = [15, 20, 45]","__index_level_0__":1250}
+{"text":"Then the indices and lengths for the entire batch will be:","__index_level_0__":1251}
+{"text":"- Indices = [10, 20, 5, 9, 77, 81, 15, 20, 45]\n- Lengths = [2, 4, 3]","__index_level_0__":1252}
+{"text":"And the output of the embedding table lookup for the whole batch is a BxD matrix.","__index_level_0__":1253}
+{"text":"## 3. Three FX Transformations","__index_level_0__":1254}
+{"text":"We have developed three FX transformations that accelerate accesses to embedding tables. Section 3.1 discusses a transformation that combines multiple small input tensors into a single big tensor; Section 3.2 a transformation that fuses multiple, parallel compute chains into a single compute chain; and Section 3.3 a transformation that overlaps communication with computation.","__index_level_0__":1255}
+{"text":"### 3.1 Combining Input Sparse Features","__index_level_0__":1256}
+{"text":"Recall that an input sparse feature in a batch is represented by two lists: a list of indices and a list of B lengths, where B is the batch size. In PyTorch, these two lists are implemented as two tensors. When a PyTorch model is run on a GPU, embedding tables are commonly stored in the GPU memory (which is closer to the GPU and has much higher read\/write bandwidth than the CPU memory). To use an input sparse feature, its two tensors need to be first copied from CPU to GPU. Nevertheless, per host-to-device memory copying requires a kernel launch, which is relatively expensive compared to the actual data transfer time. If a model uses many input sparse features, this copying could become a performance bottleneck (e.g., 1000 input sparse features would require copying 2000 tensors from host to device).","__index_level_0__":1257}
+{"text":"An optimization that reduces the number of host-to-device memcpy is to combine multiple input sparse features before sending them to the device. For instance, given the following three input features:","__index_level_0__":1258}
+{"text":"- Feature_A: indices = [106, 211, 7], lengths = [2, 1]\n- Feature_B: indices = [52, 498, 616, 870, 1013], lengths = [3, 2]\n- Feature_C: indices = [2011, 19, 351, 790], lengths = [1, 3]","__index_level_0__":1259}
+{"text":"The combined form is:","__index_level_0__":1260}
+{"text":"- Features_A_B_C: indices = [106, 211, 7, 52, 498, 616, 870, 1013, 2011, 19, 351, 790], lengths = [2, 1, 3, 2, 1, 3]","__index_level_0__":1261}
+{"text":"So, instead of copying 3x2=6 tensors from host to device, we only need to copy 2 tensors.","__index_level_0__":1262}
+{"text":"Figure 3(b) describes an implementation of this optimization, which has two components:","__index_level_0__":1263}
+{"text":"- On the CPU side: The input pipeline is modified to combine all the indices of sparse features into a single tensor and similarly all the lengths into another tensor. Then the two tensors are copied to the GPU.\n- On the GPU side: Using FX, we insert a Permute_and_Split op into the model graph to recover the indices and lengths tensors of individual features from the combined tensors, and route them to the corresponding nodes downstream.","__index_level_0__":1264}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog1-fig-3a.png\" width=\"90%\">\n<\/p>","__index_level_0__":1265}
+{"text":"(a). **Without the optimization**","__index_level_0__":1266}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog1-fig-3b.png\" width=\"90%\">\n<\/p>","__index_level_0__":1267}
+{"text":"(b). **With the optimization**","__index_level_0__":1268}
+{"text":"**Figure 3: Combining input sparse features**","__index_level_0__":1269}
+{"text":"### 3.2 Horizontal fusion of computation chains started with accesses to embedding tables","__index_level_0__":1270}
+{"text":"In a production model, it is fairly common to have 10s of embedding tables residing on each GPU. For performance reasons, lookups to these tables are grouped together so that their outputs are concatenated in a single big tensor (see the red part in Figure 4(a)). To apply computations to individual feature outputs, a Split op is used to divide the big tensors into N smaller tensors (where N is the number of features) and then the desired computations are applied to each tensor. This is shown in Figure 4(a), where the computation applied to each feature output O is Tanh(LayerNorm(O)). All the computation results are concatenated back to a big tensor, which is then passed to downstream ops (Op1 in Figure 4(a)).","__index_level_0__":1271}
+{"text":"The main runtime cost here is the GPU kernel launch overhead. For instance, the number of GPU kernel launches in Figure 4(a) is 2\\*N + 3 (each oval in the figure is a GPU kernel). This could become a performance issue because execution times of LayerNorm and Tanh on the GPU are short compared to their kernel launch times. In addition, the Split op may create an extra copy of the embedding output tensor, consuming additional GPU memory.","__index_level_0__":1272}
+{"text":"We use FX to implement an optimization called horizontal fusion which dramatically reduces the number of GPU kernel launches (in this example, the optimized number of GPU kernel launches is 5, see Figure 4(b)). Instead of doing an explicit Split, we use the Add_middle_dim op to reshape the 2D embedding tensor of shape (B, NxD) to a 3D tensor of shape (B, N, D). Then a single LayerNorm is applied to the last dimension of it. Then a single Tanh is applied to the result of the LayerNorm. At the end, we use the Remove_middle_dim op to reshape the Tanh\u2019s result back to a 2D tensor. In addition, since Add_middle_dim and Remove_middle_dim only reshape the tensor without creating an extra copy, the amount of GPU memory consumption could be reduced as well.","__index_level_0__":1273}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog1-fig-4a.png\" width=\"90%\">\n<\/p>","__index_level_0__":1274}
+{"text":"(a). **Without the optimization**","__index_level_0__":1275}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog1-fig-4b.png\" width=\"90%\">\n<\/p>","__index_level_0__":1276}
+{"text":"(b). **With the optimization**","__index_level_0__":1277}
+{"text":"**Figure 4: Horizontal fusion**","__index_level_0__":1278}
+{"text":"### 3.3 Overlapping Computation with Communication","__index_level_0__":1279}
+{"text":"Training of a production recommendation model is typically done on a distributed GPU system. Since the capacity of the device memory per GPU is not big enough to hold all the embedding tables in the model, they need to be distributed among the GPUs.","__index_level_0__":1280}
+{"text":"Within a training step, a GPU needs to read\/write feature values from\/to the embedding tables on the other GPUs. This is known as all-to-all communication [6] and can be a major performance bottleneck.","__index_level_0__":1281}
+{"text":"We use FX to implement a transformation that can overlap computation with all-to-all communication. Figure 5(a) shows the example of a model graph which has embedding table accesses (EmbeddingAllToAll) and other ops. Without any optimization, they are sequentially executed on a GPU stream, as shown in Figure 5(b). Using FX, we break EmbeddingAllToAll into EmbeddingAllToAll_Request and EmbeddingAllToAll_Wait, and schedule independent ops in between them.","__index_level_0__":1282}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog1-fig-5a.png\" width=\"70%\">\n<\/p>","__index_level_0__":1283}
+{"text":"**(a) Model graph**","__index_level_0__":1284}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog1-fig-5b.png\" width=\"70%\">\n<\/p>","__index_level_0__":1285}
+{"text":"**(b) Original execution order**","__index_level_0__":1286}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog1-fig-5c.png\" width=\"70%\">\n<\/p>","__index_level_0__":1287}
+{"text":"**(c)Optimized execution order**","__index_level_0__":1288}
+{"text":"**Figure 5: Overlapping Computation with Communication**","__index_level_0__":1289}
+{"text":"### 3.4 Summary","__index_level_0__":1290}
+{"text":"Table 1 summarizes the optimizations discussed in this section and the corresponding performance bottlenecks addressed.","__index_level_0__":1291}
+{"text":"<table>\n  <tr>\n   <td><strong>Optimization<\/strong>\n   <\/td>\n   <td><strong>Performance Bottleneck Addressed<\/strong>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>Combining Input Sparse Features\n   <\/td>\n   <td>Host-to-device memory copy\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>Horizontal fusion\n   <\/td>\n   <td>GPU kernel launch overhead\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>Overlapping Computation with Communication\n   <\/td>\n   <td>Embedding all-to-all access time\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":1292}
+{"text":"**Table 1: Summary of the optimizations and the performance bottlenecks addressed**","__index_level_0__":1293}
+{"text":"We have also developed other FX transformations which are not discussed in this section due to space limitations.","__index_level_0__":1294}
+{"text":"To discover which models would benefit from these transformations, we analyzed the performance data collected by MAIProf [7] from the models that run at Meta\u2019s data centers. Altogether, these transformations provide up to 2-3x of speedups compared to eager mode on a set of production models.","__index_level_0__":1295}
+{"text":"## 4. Concluding Remarks","__index_level_0__":1296}
+{"text":"The graph mode in PyTorch is preferred over the eager mode for production use for performance reasons. FX is a powerful tool for capturing and optimizing the graph of a PyTorch program. We demonstrate three FX transformations that are used to optimize production recommendation models inside Meta. We hope that this blog can motivate other PyTorch model developers to use graph transformations to boost their models\u2019 performance.","__index_level_0__":1297}
+{"text":"[1] [End-to-end Machine Learning Framework](https:\/\/pytorch.org\/features\/)","__index_level_0__":1299}
+{"text":"[2] [DNNFusion: Accelerating Deep Neural Networks Execution with Advanced Operator Fusion](https:\/\/arxiv.org\/abs\/2108.13342)","__index_level_0__":1300}
+{"text":"[3] [Torch.FX: Practical Program Capture and Transformation for Deep Learning In Python](https:\/\/arxiv.org\/pdf\/2112.08429.pdf), MLSys 2022.","__index_level_0__":1301}
+{"text":"[4] [Torch.fx\u2014PyTorch 1.12 documentation](https:\/\/pytorch.org\/docs\/stable\/fx.html)","__index_level_0__":1302}
+{"text":"[5] [Feature Hashing for Large Scale Multitask Learning](https:\/\/alex.smola.org\/papers\/2009\/Weinbergeretal09.pdf)","__index_level_0__":1303}
+{"text":"[6] [NVIDIA Collective Communication Library Documentation](https:\/\/docs.nvidia.com\/deeplearning\/nccl\/user-guide\/docs\/)","__index_level_0__":1304}
+{"text":"[7] [Performance Debugging of Production PyTorch Models at Meta](https:\/\/pytorch.org\/blog\/performance-debugging-of-production-pytorch-models-at-meta\/)\n \n source: https:\/\/pytorch.org\/blog\/optimizing-production-pytorch-performance-with-graph-transformations\/ \n category: pytorch blogs","__index_level_0__":1305}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 1.3 adds mobile, privacy, quantization, and named tensors'\nauthor: Team PyTorch\n---","__index_level_0__":1306}
+{"text":"PyTorch continues to gain momentum because of its focus on meeting the needs of researchers, its streamlined workflow for production use, and most of all because of the enthusiastic support it has received from the AI community. PyTorch citations in papers on ArXiv [grew 194 percent in the first half of 2019 alone, as noted by O\u2019Reilly](https:\/\/www.oreilly.com\/ideas\/one-simple-graphic-researchers-love-pytorch-and-tensorflow?fbclid=IwAR3kYmlyD7zky37IYFu0cafQn7yemhl8P-7MNyB30z0q5RDzxcTOrP8kxDk), and the number of contributors to the platform has grown more than 50 percent over the last year, to nearly 1,200. Facebook, Microsoft, Uber, and other organizations across industries are increasingly using it as the foundation for their most important machine learning (ML) research and production workloads.","__index_level_0__":1307}
+{"text":"We are now advancing the platform further with the release of PyTorch 1.3, which includes experimental support for features such as seamless model deployment to mobile devices, model quantization for better performance at inference time, and front-end improvements, like the ability to name tensors and create clearer code with less need for inline comments. We\u2019re also launching a number of additional tools and libraries to support model interpretability and bringing multimodal research to production.","__index_level_0__":1308}
+{"text":"Additionally, we\u2019ve collaborated with Google and Salesforce to add broad support for Cloud Tensor Processing Units, providing a significantly accelerated option for training large-scale deep neural networks. [Alibaba Cloud](https:\/\/data.aliyun.com\/bigdata\/pai-pytorch?spm=5176.12825654.a9ylfrljh.d112.7b652c4ayuOO4M&scm=20140722.1068.1.1098&aly_as=-PvJ5e4c) also joins Amazon Web Services, Microsoft Azure, and Google Cloud as supported cloud platforms for PyTorch users. You can get started now at [pytorch.org](https:\/\/pytorch.org\/get-started\/locally\/).","__index_level_0__":1309}
+{"text":"# PyTorch 1.3","__index_level_0__":1310}
+{"text":"The 1.3 release of PyTorch brings significant new features, including experimental support for mobile device deployment, eager mode quantization at 8-bit integer, and the ability to name tensors. With each of these enhancements, we look forward to additional contributions and improvements from the PyTorch community.","__index_level_0__":1311}
+{"text":"## Named tensors (experimental)","__index_level_0__":1312}
+{"text":"Cornell University\u2019s [Sasha Rush has argued](http:\/\/nlp.seas.harvard.edu\/NamedTensor) that, despite its ubiquity in deep learning, the traditional implementation of tensors has significant shortcomings, such as exposing private dimensions, broadcasting based on absolute position, and keeping type information in documentation. He proposed named tensors as an alternative approach.","__index_level_0__":1313}
+{"text":"Today, we name and access dimensions by comment:","__index_level_0__":1314}
+{"text":"```python\n# Tensor[N, C, H, W]\n images = torch.randn(32, 3, 56, 56)\n images.sum(dim=1)\n images.select(dim=1, index=0)\n```","__index_level_0__":1315}
+{"text":"But naming explicitly leads to more readable and maintainable code:","__index_level_0__":1316}
+{"text":"```python\nNCHW = [\u2018N\u2019, \u2018C\u2019, \u2018H\u2019, \u2018W\u2019]\n   images = torch.randn(32, 3, 56, 56, names=NCHW)\n   images.sum('C')\n   images.select('C', index=0)\n```","__index_level_0__":1317}
+{"text":"## Quantization (experimental)","__index_level_0__":1318}
+{"text":"It\u2019s important to make efficient use of both server-side and on-device compute resources when developing ML applications. To support more efficient deployment on servers and edge devices, PyTorch 1.3 now supports 8-bit model quantization using the familiar eager mode Python API. Quantization refers to techniques used to perform computation and storage at reduced precision, such as 8-bit integer. This currently experimental feature includes support for post-training quantization, dynamic quantization, and quantization-aware training. It leverages the [FBGEMM](https:\/\/github.com\/pytorch\/FBGEMM) and [QNNPACK](https:\/\/github.com\/pytorch\/QNNPACK) state-of-the-art quantized kernel back ends, for x86 and ARM CPUs, respectively, which are integrated with PyTorch and now share a common API.","__index_level_0__":1319}
+{"text":"To learn more about the design and architecture, check out the API docs [here](https:\/\/pytorch.org\/docs\/master\/quantization.html), and get started with any of the supported techniques using the tutorials available [here](https:\/\/pytorch.org\/tutorials\/).","__index_level_0__":1320}
+{"text":"## PyTorch mobile (experimental)","__index_level_0__":1321}
+{"text":"Running ML on edge devices is growing in importance as applications continue to demand lower latency. It is also a foundational element for privacy-preserving techniques such as federated learning. To enable more efficient on-device ML, PyTorch 1.3 now supports an end-to-end workflow from Python to deployment on iOS and Android.","__index_level_0__":1322}
+{"text":"This is an early, experimental release, optimized for end-to-end development. Coming releases will focus on:","__index_level_0__":1323}
+{"text":"* Optimization for size: Build level optimization and selective compilation depending on the operators needed for user applications (i.e., you pay binary size for only the operators you need)\n* Performance: Further improvements to performance and coverage on mobile CPUs and GPUs\n* High level API: Extend mobile native APIs to cover common preprocessing and integration tasks needed for incorporating ML in mobile applications. e.g. Computer vision and NLP","__index_level_0__":1324}
+{"text":"Learn more or get started on Android or iOS [here](http:\/\/pytorch.org\/mobile).","__index_level_0__":1325}
+{"text":"# New tools for model interpretability and privacy","__index_level_0__":1326}
+{"text":"As models become ever more complex, it is increasingly important to develop new methods for model interpretability. To help address this need, we\u2019re launching Captum, a tool to help developers working in PyTorch understand why their model generates a specific output. Captum provides state-of-the-art tools to understand how the importance of specific neurons and layers and affect predictions made by the models. Captum\u2019s algorithms include integrated gradients, conductance, SmoothGrad and VarGrad, and DeepLift.","__index_level_0__":1328}
+{"text":"The example below shows how to apply model interpretability algorithms on a pretrained ResNet model and then visualize the attributions for each pixel by overlaying them on the image.","__index_level_0__":1329}
+{"text":"```python\nnoise_tunnel = NoiseTunnel(integrated_gradients)","__index_level_0__":1330}
+{"text":"attributions_ig_nt, delta = noise_tunnel.attribute(input, n_samples=10, nt_type='smoothgrad_sq', target=pred_label_idx)\n_ = viz.visualize_image_attr_multiple([\"original_image\", \"heat_map\"],\n                                      [\"all\", \"positive\"],\n                                      np.transpose(attributions_ig_nt.squeeze().cpu().detach().numpy(), (1,2,0)),\n                                      np.transpose(transformed_img.squeeze().cpu().detach().numpy(), (1,2,0)),\n                                      cmap=default_cmap,\n                                      show_colorbar=True)\n```","__index_level_0__":1331}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/Captum 1.jpg\" width=\"100%\">\n<\/div>\n<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/Captum 2.png\" width=\"100%\">\n<\/div>","__index_level_0__":1332}
+{"text":"Learn more about Captum at [captum.ai](https:\/\/www.captum.ai\/).","__index_level_0__":1333}
+{"text":"Practical applications of ML via cloud-based or machine-learning-as-a-service (MLaaS) platforms pose a range of security and privacy challenges. In particular, users of these platforms may not want or be able to share unencrypted data, which prevents them from taking full advantage of ML tools. To address these challenges, the ML community is exploring a number of technical approaches, at various levels of maturity. These include homomorphic encryption, secure multiparty computation, trusted execution environments, on-device computation, and differential privacy.","__index_level_0__":1335}
+{"text":"To provide a better understanding of how some of these technologies can be applied, we are releasing CrypTen, a new community-based research platform for taking the field of privacy-preserving ML forward. Learn more about CrypTen [here](https:\/\/ai.facebook.com\/blog\/crypten-a-new-research-tool-for-secure-machine-learning-with-pytorch). It is available on GitHub [here](https:\/\/github.com\/facebookresearch\/CrypTen).","__index_level_0__":1336}
+{"text":"# Tools for multimodal AI systems","__index_level_0__":1337}
+{"text":"Digital content is often made up of several modalities, such as text, images, audio, and video. For example, a single public post might contain an image, body text, a title, a video, and a landing page. Even one particular component may have more than one modality, such as a video that contains both visual and audio signals, or a landing page that is composed of images, text, and HTML sources.","__index_level_0__":1338}
+{"text":"The ecosystem of tools and libraries that work with PyTorch offer enhanced ways to address the challenges of building multimodal ML systems. Here are some of the latest libraries launching today:","__index_level_0__":1339}
+{"text":"## Detectron2","__index_level_0__":1340}
+{"text":"Object detection and segmentation are used for tasks ranging from autonomous vehicles to content understanding for platform integrity. To advance this work, Facebook AI Research (FAIR) is releasing Detectron2, an object detection library now implemented in PyTorch. Detectron2 provides support for the latest models and tasks, increased flexibility to aid computer vision research, and improvements in maintainability and scalability to support production use cases.","__index_level_0__":1341}
+{"text":"Detectron2 is available [here](https:\/\/github.com\/facebookresearch\/detectron2) and you can learn more [here](https:\/\/ai.facebook.com\/blog\/-detectron2-a-pytorch-based-modular-object-detection-library-).","__index_level_0__":1342}
+{"text":"## Speech extensions to fairseq","__index_level_0__":1343}
+{"text":"Language translation and audio processing are critical components in systems and applications such as search, translation, speech, and assistants. There has been tremendous progress in these fields recently thanks to the development of new architectures like transformers, as well as large-scale pretraining methods. We\u2019ve extended fairseq, a framework for sequence-to-sequence applications such as language translation, to include support for end-to-end learning for speech and audio recognition tasks.These extensions to fairseq enable faster exploration and prototyping of new speech research ideas while offering a clear path to production.","__index_level_0__":1344}
+{"text":"Get started with fairseq [here](https:\/\/github.com\/pytorch\/fairseq\/tree\/master\/examples\/speech_recognition).","__index_level_0__":1345}
+{"text":"# Cloud provider and hardware ecosystem support","__index_level_0__":1346}
+{"text":"Cloud providers such as Amazon Web Services, Microsoft Azure, and Google Cloud provide extensive support for anyone looking to develop ML on PyTorch and deploy in production. We\u2019re excited to share the general availability of Google Cloud TPU support and a newly launched integration with Alibaba Cloud. We\u2019re also expanding hardware ecosystem support.","__index_level_0__":1347}
+{"text":"* Google Cloud TPU support now broadly available. To accelerate the largest-scale machine learning (ML) applications deployed today and enable rapid development of the ML applications of tomorrow, Google created custom silicon chips called Tensor Processing Units ([TPUs](https:\/\/cloud.google.com\/tpu\/)). When assembled into multi-rack ML supercomputers called [Cloud TPU Pods](https:\/\/cloud.google.com\/blog\/products\/ai-machine-learning\/cloud-tpu-pods-break-ai-training-records), these TPUs can complete ML workloads in minutes or hours that previously took days or weeks on other systems. Engineers from Facebook, Google, and Salesforce worked together to enable and pilot Cloud TPU support in PyTorch, including experimental support for Cloud TPU Pods. PyTorch support for Cloud TPUs is also available in Colab. Learn more about how to get started with PyTorch on Cloud TPUs [here](https:\/\/github.com\/pytorch\/xla).\n* Alibaba adds support for PyTorch in Alibaba Cloud. The initial integration involves a one-click solution for PyTorch 1.x, Data Science Workshop notebook service, distributed training with Gloo\/NCCL, as well as seamless integration with Alibaba IaaS such as OSS, ODPS, and NAS. Together with the toolchain provided by Alibaba, we look forward to significantly reducing the overhead necessary for adoption, as well as helping Alibaba Cloud\u2019s global customer base leverage PyTorch to develop new AI applications.\n* ML hardware ecosystem expands. In addition to key GPU and CPU partners, the PyTorch ecosystem has also enabled support for dedicated ML accelerators. Updates from [Intel](https:\/\/www.intel.ai\/nnpi-glow-pytorch\/) and [Habana](https:\/\/medium.com\/@HabanaLabs\/unlocking-ai-scaling-through-software-and-hardware-interface-standardization-77561cb7598b) showcase how PyTorch, connected to the Glow optimizing compiler, enables developers to utilize these market-specific solutions.","__index_level_0__":1348}
+{"text":"# Growth in the PyTorch community","__index_level_0__":1349}
+{"text":"As an open source, community-driven project, PyTorch benefits from wide range of contributors bringing new capabilities to the ecosystem. Here are some recent examples:","__index_level_0__":1350}
+{"text":"* Mila SpeechBrain aims to provide an open source, all-in-one speech toolkit based on PyTorch. The goal is to develop a single, flexible, user-friendly toolkit that can be used to easily develop state-of-the-art systems for speech recognition (both end to end and HMM-DNN), speaker recognition, speech separation, multi-microphone signal processing (e.g., beamforming), self-supervised learning, and many others. [Learn more](https:\/\/speechbrain.github.io\/)\n* SpaCy is a new wrapping library with consistent and easy-to-use interfaces to several models, in order to extract features to power NLP pipelines. Support is provided for via spaCy\u2019s standard training API. The library also calculates an alignment so the transformer features can be related back to actual words instead of just wordpieces. [Learn more](https:\/\/explosion.ai\/blog\/spacy-pytorch-transformers)\n* HuggingFace PyTorch-Transformers (formerly known as pytorch-pretrained-bert is a library of state-of-the-art pretrained models for Natural Language Processing (NLP). The library currently contains PyTorch implementations, pretrained model weights, usage scripts, and conversion utilities for models such as BERT, GPT-2, RoBERTa, and DistilBERT. It has also grown quickly, with more than 13,000 GitHub stars and a broad set of users. [Learn more](https:\/\/github.com\/huggingface\/transformers)\n* PyTorch Lightning is a Keras-like ML library for PyTorch. It leaves core training and validation logic to you and automates the rest. Reproducibility is a crucial requirement for many fields of research, including those based on ML techniques. As the number of research papers submitted to arXiv and conferences skyrockets into the tens of thousands, scaling reproducibility becomes difficult. [Learn more](https:\/\/github.com\/williamFalcon\/pytorch-lightning).","__index_level_0__":1351}
+{"text":"We recently held the first online Global PyTorch Summer Hackathon, where researchers and developers around the world were invited to build innovative new projects with PyTorch. Nearly 1,500 developers participated, submitting projects ranging from livestock disease detection to AI-powered financial assistants. The winning projects were:","__index_level_0__":1352}
+{"text":"* Torchmeta, which provides extensions for PyTorch to simplify the development of meta-learning algorithms in PyTorch. It features a unified interface inspired by TorchVision for both few-shot classification and regression problems, to allow easy benchmarking on multiple data sets to aid with reproducibility.\n* Open-Unmix, a system for end-to-end music demixing with PyTorch. Demixing separates the individual instruments or vocal track from any stereo recording.\n* Endless AI-Generated Tees, a store featuring AI-generated T-shirt designs that can be purchased and delivered worldwide. The system uses a state-of-the-art generative model (StyleGAN) that was built with PyTorch and then trained on modern art.","__index_level_0__":1353}
+{"text":"Visit [pytorch.org](https:\/\/pytorch.org\/) to learn more and get started with PyTorch 1.3 and the latest libraries and ecosystem projects. We look forward to the contributions, exciting research advancements, and real-world applications that the community builds with PyTorch.","__index_level_0__":1354}
+{"text":"*We\u2019d like to thank the entire PyTorch team and the community for all their contributions to this work.*\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1-dot-3-adds-mobile-privacy-quantization-and-named-tensors\/ \n category: pytorch blogs","__index_level_0__":1355}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"New library updates in PyTorch 1.12\"\nauthor: Team PyTorch\nfeatured-img: ''\n---","__index_level_0__":1356}
+{"text":"We are bringing a number of improvements to the current PyTorch libraries, alongside the [PyTorch 1.12 release](https:\/\/github.com\/pytorch\/pytorch\/releases\/tag\/v1.12.0). These updates demonstrate our focus on developing common and extensible APIs across all domains to make it easier for our community to build ecosystem projects on PyTorch. ","__index_level_0__":1357}
+{"text":"Summary:\n- **TorchVision** - Added multi-weight support API, new architectures, model variants, and pretrained weight. See the release notes [here](https:\/\/github.com\/pytorch\/vision\/releases).\n- **TorchAudio** - Introduced beta features including a streaming API, a CTC beam search decoder, and new beamforming modules and methods. See the release notes [here](https:\/\/github.com\/pytorch\/audio\/releases).\n- **TorchText** - Extended support for scriptable BERT tokenizer and added datasets for GLUE benchmark. See the release notes [here](https:\/\/github.com\/pytorch\/text\/releases).\n- **TorchRec** - Added EmbeddingModule benchmarks, examples for TwoTower Retrieval, inference and sequential embeddings, metrics, improved planner and demonstrated integration with production components. See the release notes [here](https:\/\/github.com\/pytorch\/torchrec\/releases).\n- **TorchX** - Launch PyTorch trainers developed on local workspaces onto five different types of schedulers. See the release notes [here](https:\/\/github.com\/pytorch\/torchx\/blob\/main\/CHANGELOG.md?plain=1#L3).\n- **FBGemm** - Added and improved kernels for Recommendation Systems inference workloads, including table batched embedding bag, jagged tensor operations, and other special-case optimizations.","__index_level_0__":1358}
+{"text":"## TorchVision v0.13","__index_level_0__":1359}
+{"text":"### Multi-weight support API","__index_level_0__":1360}
+{"text":"TorchVision v0.13 offers a new [Multi-weight support API](https:\/\/pytorch.org\/blog\/introducing-torchvision-new-multi-weight-support-api\/) for loading different weights to the existing model builder methods:","__index_level_0__":1361}
+{"text":"```python\nfrom torchvision.models import *","__index_level_0__":1362}
+{"text":"# Old weights with accuracy 76.130%\nresnet50(weights=ResNet50_Weights.IMAGENET1K_V1)","__index_level_0__":1363}
+{"text":"# New weights with accuracy 80.858%\nresnet50(weights=ResNet50_Weights.IMAGENET1K_V2)","__index_level_0__":1364}
+{"text":"# Best available weights (currently alias for IMAGENET1K_V2)\n# Note that these weights may change across versions\nresnet50(weights=ResNet50_Weights.DEFAULT)","__index_level_0__":1365}
+{"text":"# Strings are also supported\nresnet50(weights=\"IMAGENET1K_V2\")","__index_level_0__":1366}
+{"text":"# No weights - random initialization\nresnet50(weights=None)\n```","__index_level_0__":1367}
+{"text":"The new API bundles along with the weights important details such as the preprocessing transforms and meta-data such as labels. Here is how to make the most out of it:","__index_level_0__":1368}
+{"text":"```python\nfrom torchvision.io import read_image\nfrom torchvision.models import resnet50, ResNet50_Weights","__index_level_0__":1369}
+{"text":"img = read_image(\"test\/assets\/encode_jpeg\/grace_hopper_517x606.jpg\")","__index_level_0__":1370}
+{"text":"# Step 1: Initialize model with the best available weights\nweights = ResNet50_Weights.DEFAULT\nmodel = resnet50(weights=weights)\nmodel.eval()","__index_level_0__":1371}
+{"text":"# Step 2: Initialize the inference transforms\npreprocess = weights.transforms()","__index_level_0__":1372}
+{"text":"# Step 3: Apply inference preprocessing transforms\nbatch = preprocess(img).unsqueeze(0)","__index_level_0__":1373}
+{"text":"# Step 4: Use the model and print the predicted category\nprediction = model(batch).squeeze(0).softmax(0)\nclass_id = prediction.argmax().item()\nscore = prediction[class_id].item()\ncategory_name = weights.meta[\"categories\"][class_id]\nprint(f\"{category_name}: {100 * score:.1f}%\")\n```","__index_level_0__":1374}
+{"text":"You can read more about the new API in the [docs](https:\/\/pytorch.org\/vision\/0.13\/models.html). To provide your feedback, please use this dedicated [Github issue](https:\/\/github.com\/pytorch\/vision\/issues\/5088).","__index_level_0__":1375}
+{"text":"### New architectures and model variants","__index_level_0__":1376}
+{"text":"#### Classification","__index_level_0__":1377}
+{"text":"The [Swin Transformer](https:\/\/arxiv.org\/abs\/2103.14030) and [EfficienetNetV2](https:\/\/arxiv.org\/abs\/2104.00298) are two popular classification models which are often used for downstream vision tasks. This release includes 6 pre-trained weights for their classification variants. Here is how to use the new models:","__index_level_0__":1378}
+{"text":"```python\nimport torch\nfrom torchvision.models import *","__index_level_0__":1379}
+{"text":"image = torch.rand(1, 3, 224, 224)\nmodel = swin_t(weights=\"DEFAULT\").eval()\nprediction = model(image)","__index_level_0__":1380}
+{"text":"image = torch.rand(1, 3, 384, 384)\nmodel = efficientnet_v2_s(weights=\"DEFAULT\").eval()\nprediction = model(image)\n```","__index_level_0__":1381}
+{"text":"In addition to the above, we also provide new variants for existing architectures such as ShuffleNetV2, ResNeXt and MNASNet. The accuracies of all the new pre-trained models obtained on ImageNet-1K are seen below:","__index_level_0__":1382}
+{"text":"| **Model**                      | **Acc@1** | **Acc@5** |\n|--------------------------------|-----------|-----------|\n| swin_t                         |    81.474 |    95.776 |\n| swin_s                         |    83.196 |     96.36 |\n| swin_b                         |    83.582 |     96.64 |\n| efficientnet_v2_s              |    84.228 |    96.878 |\n| efficientnet_v2_m              |    85.112 |    97.156 |\n| efficientnet_v2_l              |    85.808 |    97.788 |\n| resnext101_64x4d               |    83.246 |    96.454 |\n| resnext101_64x4d (quantized)   |    82.898 |    96.326 |\n| shufflenet_v2_x1_5             |    72.996 |    91.086 |\n| shufflenet_v2_x1_5 (quantized) |    72.052 |     0.700 |\n| shufflenet_v2_x2_0             |    76.230 |    93.006 |\n| shufflenet_v2_x2_0 (quantized) |    75.354 |    92.488 |\n| mnasnet0_75                    |    71.180 |    90.496 |\n| mnas1_3                        |    76.506 |    93.522 |","__index_level_0__":1383}
+{"text":"We would like to thank Hu Ye for contributing to TorchVision the Swin Transformer implementation.","__index_level_0__":1384}
+{"text":"#### (BETA) Object Detection and Instance Segmentation","__index_level_0__":1385}
+{"text":"We have introduced 3 new model variants for RetinaNet, FasterRCNN and MaskRCNN that include several [post-paper architectural optimizations](https:\/\/github.com\/pytorch\/vision\/pull\/5444) and improved training recipes. All models can be used similarly:","__index_level_0__":1386}
+{"text":"```python\nimport torch\nfrom torchvision.models.detection import *","__index_level_0__":1387}
+{"text":"images = [torch.rand(3, 800, 600)]\nmodel = retinanet_resnet50_fpn_v2(weights=\"DEFAULT\")\n# model = fasterrcnn_resnet50_fpn_v2(weights=\"DEFAULT\")\n# model = maskrcnn_resnet50_fpn_v2(weights=\"DEFAULT\")\nmodel.eval()\nprediction = model(images)\n```","__index_level_0__":1388}
+{"text":"Below we present the metrics of the new variants on COCO val2017. In parenthesis we denote the improvement over the old variants:","__index_level_0__":1389}
+{"text":"| **Model**                  | **Box mAP** | **Mask mAP** |\n|----------------------------|-------------|--------------|\n| retinanet_resnet50_fpn_v2  | 41.5 (+5.1) | -            |\n| fasterrcnn_resnet50_fpn_v2 | 46.7 (+9.7) | -            |\n| maskrcnn_resnet50_fpn_v2   | 47.4 (+9.5) | 41.8 (+7.2)  |","__index_level_0__":1390}
+{"text":"We would like to thank Ross Girshick, Piotr Dollar, Vaibhav Aggarwal, Francisco Massa and Hu Ye for their past research and contributions to this work.","__index_level_0__":1391}
+{"text":"### New pre-trained weights ","__index_level_0__":1392}
+{"text":"#### SWAG weights","__index_level_0__":1393}
+{"text":"The ViT and RegNet model variants offer new pre-trained [SWAG](https:\/\/arxiv.org\/abs\/2201.08371) (\u200b\u200bSupervised Weakly from hashtAGs) weights. One of the biggest of these models achieves a whopping 88.6% accuracy on ImageNet-1K. We currently offer two versions of the weights: 1) fine-tuned end-to-end weights on ImageNet-1K (highest accuracy) and 2) frozen trunk weights with a linear classifier fit on ImageNet-1K (great for transfer learning). Below we see the detailed accuracies of each model variant:","__index_level_0__":1394}
+{"text":"| **Model Weights**                                | **Acc@1** | **Acc@5** |\n|--------------------------------------------------|-----------|-----------|\n| RegNet_Y_16GF_Weights.IMAGENET1K_SWAG_E2E_V1     |    86.012 |    98.054 |\n| RegNet_Y_16GF_Weights.IMAGENET1K_SWAG_LINEAR_V1  |    83.976 |    97.244 |\n| RegNet_Y_32GF_Weights.IMAGENET1K_SWAG_E2E_V1     |    86.838 |    98.362 |\n| RegNet_Y_32GF_Weights.IMAGENET1K_SWAG_LINEAR_V1  |    84.622 |     97.48 |\n| RegNet_Y_128GF_Weights.IMAGENET1K_SWAG_E2E_V1    |    88.228 |    98.682 |\n| RegNet_Y_128GF_Weights.IMAGENET1K_SWAG_LINEAR_V1 |    86.068 |    97.844 |\n| ViT_B_16_Weights.IMAGENET1K_SWAG_E2E_V1          |    85.304 |     97.65 |\n| ViT_B_16_Weights.IMAGENET1K_SWAG_LINEAR_V1       |    81.886 |     96.18 |\n| ViT_L_16_Weights.IMAGENET1K_SWAG_E2E_V1          |    88.064 |    98.512 |\n| ViT_L_16_Weights.IMAGENET1K_SWAG_LINEAR_V1       |    85.146 |    97.422 |\n| ViT_H_14_Weights.IMAGENET1K_SWAG_E2E_V1          |    88.552 |    98.694 |\n| ViT_H_14_Weights.IMAGENET1K_SWAG_LINEAR_V1       |    85.708 |     97.73 |","__index_level_0__":1395}
+{"text":"The SWAG weights are released under the [Attribution-NonCommercial 4.0 International](https:\/\/github.com\/facebookresearch\/SWAG\/blob\/main\/LICENSE) license. We would like to thank Laura Gustafson, Mannat Singh and Aaron Adcock for their work and support in making the weights available to TorchVision.","__index_level_0__":1396}
+{"text":"#### Model Refresh","__index_level_0__":1397}
+{"text":"The release of the Multi-weight support API enabled us to refresh the most popular models and offer more accurate weights. We improved on average each model by ~3 points. The new recipe used was learned on top of ResNet50 and its details were covered on a [previous blog post](https:\/\/pytorch.org\/blog\/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives\/). ","__index_level_0__":1398}
+{"text":"| **Model**                    | **Old weights** | **New weights** |\n|------------------------------|-----------------|-----------------|\n| efficientnet_b1              |          78.642 |          79.838 |\n| mobilenet_v2                 |          71.878 |          72.154 |\n| mobilenet_v3_large           |          74.042 |          75.274 |\n| regnet_y_400mf               |          74.046 |          75.804 |\n| regnet_y_800mf               |           76.42 |          78.828 |\n| regnet_y_1_6gf               |           77.95 |          80.876 |\n| regnet_y_3_2gf               |          78.948 |          81.982 |\n| regnet_y_8gf                 |          80.032 |          82.828 |\n| regnet_y_16gf                |          80.424 |          82.886 |\n| regnet_y_32gf                |          80.878 |          83.368 |\n| regnet_x_400mf               |          72.834 |          74.864 |\n| regnet_x_800mf               |          75.212 |          77.522 |\n| regnet_x_1_6gf               |           77.04 |          79.668 |\n| regnet_x_3_2gf               |          78.364 |          81.196 |\n| regnet_x_8gf                 |          79.344 |          81.682 |\n| regnet_x_16gf                |          80.058 |          82.716 |\n| regnet_x_32gf                |          80.622 |          83.014 |\n| resnet50                     |           76.13 |          80.858 |\n| resnet50 (quantized)         |           75.92 |          80.282 |\n| resnet101                    |          77.374 |          81.886 |\n| resnet152                    |          78.312 |          82.284 |\n| resnext50_32x4d              |          77.618 |          81.198 |\n| resnext101_32x8d             |          79.312 |          82.834 |\n| resnext101_32x8d (quantized) |          78.986 |          82.574 |\n| wide_resnet50_2              |          78.468 |          81.602 |\n| wide_resnet101_2             |          78.848 |           82.51 |","__index_level_0__":1399}
+{"text":"We would like to thank Piotr Dollar, Mannat Singh and Hugo Touvron for their past research and contributions to this work.","__index_level_0__":1400}
+{"text":"### New Augmentations, Layers and Losses","__index_level_0__":1401}
+{"text":"This release brings a bunch of new primitives which can be used to produce SOTA models. Some highlights include the addition of [AugMix](https:\/\/arxiv.org\/abs\/1912.02781) data-augmentation method, the [DropBlock](https:\/\/arxiv.org\/abs\/1810.12890) layer, the [cIoU\/dIoU](https:\/\/arxiv.org\/abs\/1911.08287) loss and [many more](https:\/\/github.com\/pytorch\/vision\/issues\/5410). We would like to thank Aditya Oke, Abhijit Deo, Yassine Alouini and Hu Ye for contributing to the project and for helping us maintain TorchVision relevant and fresh.","__index_level_0__":1402}
+{"text":"### Documentation","__index_level_0__":1403}
+{"text":"We completely revamped our models documentation to make them easier to browse, and added various key information such as supported image sizes, or image pre-processing steps of pre-trained weights. We now have a [main model page](https:\/\/pytorch.org\/vision\/main\/models.html) with various [summary tables](https:\/\/pytorch.org\/vision\/main\/models.html#table-of-all-available-classification-weights) of available weights, and each model has a [dedicated page](https:\/\/pytorch.org\/vision\/main\/models\/resnet.html). Each model builder is also documented in their [own page](https:\/\/pytorch.org\/vision\/main\/models\/generated\/torchvision.models.resnet50.html#torchvision.models.resnet50), with more details about the available weights, including accuracy, minimal image size, link to training recipes, and other valuable info. For comparison, our previous models docs are [here](https:\/\/pytorch.org\/vision\/0.12\/models.html). To provide feedback on the new documentation, please use the dedicated [Github issue](https:\/\/github.com\/pytorch\/vision\/issues\/5511).","__index_level_0__":1404}
+{"text":"## TorchAudio v0.12","__index_level_0__":1405}
+{"text":"### (BETA) Streaming API","__index_level_0__":1406}
+{"text":"<p align=\"middle\" float=\"left\">\n  <img src=\"\/assets\/images\/streamingapi.jpeg\" width=\"40%\"\/> <img src=\"\/assets\/images\/torchaudio-0-12-streaming-ASR-2.gif\" width=\"50%\"\/>\n<\/p>","__index_level_0__":1407}
+{"text":"\nStreamReader is TorchAudio\u2019s new I\/O API. It is backed by FFmpeg\u2020, and allows users to:\n- Decode audio and video formats, including MP4 and AAC\n- Handle input forms, such as local files, network protocols, microphones, webcams, screen captures and file-like objects\n- Iterate over and decode chunk-by-chunk, while changing the sample rate or frame rate\n- Apply audio and video filters, such as low-pass filter and image scaling\n- Decode video with Nvidia's hardware-based decoder (NVDEC)","__index_level_0__":1408}
+{"text":"For usage details, please check out the [documentation](https:\/\/pytorch.org\/audio\/0.12.0\/io.html#streamreader) and tutorials:\n- [Media Stream API - Pt.1](https:\/\/pytorch.org\/audio\/0.12.0\/tutorials\/streaming_api_tutorial.html)\n- [Media Stream API - Pt.2](https:\/\/pytorch.org\/audio\/0.12.0\/tutorials\/streaming_api2_tutorial.html)\n- [Online ASR with Emformer RNN-T](https:\/\/pytorch.org\/audio\/0.12.0\/tutorials\/online_asr_tutorial.html)\n- [Device ASR with Emformer RNN-T](https:\/\/pytorch.org\/audio\/0.12.0\/tutorials\/device_asr.html)\n- [Accelerated Video Decoding with NVDEC](https:\/\/pytorch.org\/audio\/0.12.0\/hw_acceleration_tutorial.html)","__index_level_0__":1409}
+{"text":"\u2020 To use StreamReader, FFmpeg libraries are required. Please install FFmpeg. The coverage of codecs depends on how these libraries are configured. TorchAudio official binaries are compiled to work with FFmpeg 4 libraries; FFmpeg 5 can be used if TorchAudio is built from source.","__index_level_0__":1410}
+{"text":"### (BETA) CTC Beam Search Decoder","__index_level_0__":1411}
+{"text":"TorchAudio integrates the wav2letter CTC beam search decoder from [Flashlight](https:\/\/arxiv.org\/pdf\/2201.12465.pdf) ([GitHub](https:\/\/github.com\/flashlight\/flashlight)). The addition of this inference time decoder enables running end-to-end CTC ASR evaluation using TorchAudio utils.","__index_level_0__":1412}
+{"text":"Customizable lexicon and lexicon-free decoders are supported, and both are compatible with KenLM n-gram language models or without using a language model. TorchAudio additionally supports downloading token, lexicon, and pretrained KenLM files for the LibriSpeech dataset.","__index_level_0__":1413}
+{"text":"For usage details, please check out the [documentation](https:\/\/pytorch.org\/audio\/0.12.0\/models.decoder.html#ctcdecoder) and [ASR inference tutorial](https:\/\/pytorch.org\/audio\/0.12.0\/tutorials\/asr_inference_with_ctc_decoder_tutorial.html).","__index_level_0__":1414}
+{"text":"### (BETA) New Beamforming Modules and Methods","__index_level_0__":1415}
+{"text":"To improve flexibility in usage, the release adds two new beamforming modules under torchaudio.transforms: [SoudenMVDR](https:\/\/pytorch.org\/audio\/0.12.0\/transforms.html#soudenmvdr) and [RTFMVDR](https:\/\/pytorch.org\/audio\/0.12.0\/transforms.html#rtfmvdr). The main differences from [MVDR](https:\/\/pytorch.org\/audio\/0.11.0\/transforms.html#mvdr) are:\n- Use power spectral density (PSD) and relative transfer function (RTF) matrices as inputs instead of time-frequency masks. The module can be integrated with neural networks that directly predict complex-valued STFT coefficients of speech and noise\n- Add \\'reference_channel\\' as an input argument in the forward method, to allow users to select the reference channel in model training or dynamically change the reference channel in inference","__index_level_0__":1416}
+{"text":"Besides the two modules, new function-level beamforming methods are added under torchaudio.functional. These include:\n- [psd](https:\/\/pytorch.org\/audio\/0.12.0\/functional.html#psd)\n- [mvdr_weights_souden](https:\/\/pytorch.org\/audio\/0.12.0\/functional.html#mvdr-weights-souden)\n- [mvdr_weights_rtf](https:\/\/pytorch.org\/audio\/0.12.0\/functional.html#mvdr-weights-rtf)\n- [rtf_evd](https:\/\/pytorch.org\/audio\/0.12.0\/functional.html#rtf-evd)\n- [rtf_power](https:\/\/pytorch.org\/audio\/0.12.0\/functional.html#rtf-power)\n- [apply_beamforming](https:\/\/pytorch.org\/audio\/0.12.0\/functional.html#apply-beamforming)","__index_level_0__":1417}
+{"text":"For usage details, please check out the documentation at [torchaudio.transforms](https:\/\/pytorch.org\/audio\/0.12.0\/transforms.html#multi-channel) and [torchaudio.functional](https:\/\/pytorch.org\/audio\/0.12.0\/functional.html#multi-channel) and the [Speech Enhancement with MVDR Beamforming tutorial](https:\/\/pytorch.org\/audio\/0.12.0\/tutorials\/mvdr_tutorial.html).","__index_level_0__":1418}
+{"text":"## TorchText v0.13","__index_level_0__":1419}
+{"text":"### Glue Datasets","__index_level_0__":1420}
+{"text":"We increased the number of datasets in TorchText from 22 to 30 by adding the remaining 8 datasets from the GLUE benchmark (SST-2 was already supported). The complete list of GLUE datasets is as follows:\n- [CoLA](https:\/\/nyu-mll.github.io\/CoLA\/) ([paper](https:\/\/arxiv.org\/pdf\/1805.12471.pdf)): Single sentence binary classification acceptability task\n- [SST-2](https:\/\/nlp.stanford.edu\/sentiment\/) ([paper](https:\/\/nlp.stanford.edu\/~socherr\/EMNLP2013_RNTN.pdf)): Single sentence binary classification sentiment task\n- [MRPC](https:\/\/nlp.stanford.edu\/~socherr\/EMNLP2013_RNTN.pdf) ([paper](https:\/\/www.microsoft.com\/en-us\/research\/wp-content\/uploads\/2016\/02\/I05-50025B15D.pdf)): Dual sentence binary classification paraphrase task\n- [QQP](https:\/\/quoradata.quora.com\/First-Quora-Dataset-Release-Question-Pairs): Dual sentence binary classification paraphrase task\n- [STS-B](https:\/\/ixa2.si.ehu.eus\/stswiki\/index.php\/STSbenchmark) ([paper](https:\/\/aclanthology.org\/S17-2001.pdf)): Single sentence to float regression sentence similarity task\n- [MNLI](https:\/\/cims.nyu.edu\/~sbowman\/multinli\/) ([paper](https:\/\/cims.nyu.edu\/~sbowman\/multinli\/paper.pdf)): Sentence ternary classification NLI task\n- [QNLI](https:\/\/gluebenchmark.com\/) ([paper](https:\/\/arxiv.org\/pdf\/1804.07461.pdf)): Sentence binary classification QA and NLI tasks\n- [RTE](https:\/\/aclweb.org\/aclwiki\/Recognizing_Textual_Entailment) ([paper](https:\/\/arxiv.org\/pdf\/2010.03061.pdf)): Dual sentence binary classification NLI task\n- [WNLI](https:\/\/cs.nyu.edu\/~davise\/papers\/WinogradSchemas\/WS.html) ([paper](http:\/\/commonsensereasoning.org\/2011\/papers\/Levesque.pdf)): Dual sentence binary classification coreference and NLI tasks","__index_level_0__":1421}
+{"text":"### Scriptable BERT Tokenizer","__index_level_0__":1422}
+{"text":"TorchText has extended support for scriptable tokenizer by adding the WordPiece tokenizer used in BERT. It is one of the commonly used algorithms for splitting input text into sub-words units and was introduced in [Japanese and Korean Voice Search (Schuster et al., 2012)](https:\/\/static.googleusercontent.com\/media\/research.google.com\/ja\/\/pubs\/archive\/37842.pdf).  ","__index_level_0__":1423}
+{"text":"TorchScriptabilty support would allow users to embed the BERT text-preprocessing natively in C++ without needing the support of python runtime. As TorchText now supports the CMAKE build system to natively link torchtext binaries with application code, users can easily integrate BERT tokenizers for deployment needs.","__index_level_0__":1424}
+{"text":"For usage details, please refer to the corresponding [documentation](https:\/\/pytorch.org\/text\/main\/transforms.html#torchtext.transforms.BERTTokenizer).","__index_level_0__":1425}
+{"text":"## TorchRec v0.2.0","__index_level_0__":1426}
+{"text":"### EmbeddingModule + DLRM benchmarks","__index_level_0__":1427}
+{"text":"A set of [benchmarking tests](https:\/\/github.com\/pytorch\/torchrec\/tree\/main\/benchmarks), showing performance characteristics of TorchRec\u2019s base modules  and research models built out of TorchRec.","__index_level_0__":1428}
+{"text":"### TwoTower Retrieval Example, with FAISS","__index_level_0__":1429}
+{"text":"We provide an [example](https:\/\/github.com\/pytorch\/torchrec\/tree\/main\/examples\/retrieval) demonstrating training a distributed TwoTower (i.e. User-Item) Retrieval model that is sharded using TorchRec. The projected item embeddings are added to an IVFPQ FAISS index for candidate generation. The retrieval model and KNN lookup are bundled in a Pytorch model for efficient end-to-end retrieval.","__index_level_0__":1430}
+{"text":"### Integrations","__index_level_0__":1431}
+{"text":"We demonstrate that TorchRec works out of the box with many components commonly used alongside PyTorch models in production like systems, such as \n- [Training](https:\/\/github.com\/pytorch\/torchrec\/tree\/main\/examples\/ray) a TorchRec model on Ray Clusters utilizing the Torchx Ray scheduler\n- [Preprocessing](https:\/\/github.com\/pytorch\/torchrec\/tree\/main\/torchrec\/datasets\/scripts\/nvt) and DataLoading with NVTabular on DLRM\n- [Training](https:\/\/github.com\/pytorch\/torchrec\/tree\/main\/examples\/torcharrow) a TorchRec model with on-the-fly preprocessing with TorchArrow showcasing RecSys domain UDFs","__index_level_0__":1432}
+{"text":"### Sequential Embeddings Example: Bert4Rec","__index_level_0__":1433}
+{"text":"We provide an [example](https:\/\/github.com\/pytorch\/torchrec\/tree\/main\/examples\/bert4rec), using TorchRec, that reimplements the [BERT4REC](https:\/\/arxiv.org\/abs\/1904.06690) paper, showcasing EmbeddingCollection for non-pooled embeddings. Using DistributedModelParallel we see a 35% QPS gain over conventional data parallelism.","__index_level_0__":1434}
+{"text":"### (Beta) Planner","__index_level_0__":1435}
+{"text":"The TorchRec library includes a built-in [planner](https:\/\/pytorch.org\/torchrec\/torchrec.distributed.planner.html) that selects near optimal sharding plan for a given model.  The planner attempts to identify the best sharding plan by evaluating a series of proposals which are statically analyzed and fed into an integer partitioner.  The planner is able to automatically adjust plans for a wide range of hardware setups, allowing users to scale performance seamlessly from local development environment to large scale production hardware. See this [notebook](https:\/\/github.com\/pytorch\/torchrec\/blob\/main\/torchrec\/distributed\/planner\/Planner_Introduction.ipynb) for a more detailed tutorial.","__index_level_0__":1436}
+{"text":"### (Beta) Inference","__index_level_0__":1437}
+{"text":"[TorchRec Inference](https:\/\/github.com\/pytorch\/torchrec\/tree\/main\/torchrec\/inference) is a C++ library that supports multi-gpu inference. The TorchRec library is used to shard models written and packaged in Python via torch.package (an alternative to TorchScript). The torch.deploy library is used to serve inference from C++ by launching multiple Python interpreters carrying the packaged model, thus subverting the GIL. Two models are provided as examples: [DLRM multi-GPU](https:\/\/github.com\/pytorch\/torchrec\/blob\/main\/examples\/inference\/dlrm_predict.py) (sharded via TorchRec) and [DLRM single-GPU](https:\/\/github.com\/pytorch\/torchrec\/blob\/main\/examples\/inference\/dlrm_predict_single_gpu.py).","__index_level_0__":1438}
+{"text":"### (Beta) RecMetrics","__index_level_0__":1439}
+{"text":"RecMetrics is a [metrics](https:\/\/github.com\/pytorch\/torchrec\/tree\/main\/torchrec\/metrics) library that collects common utilities and optimizations for Recommendation models.  It extends [torchmetrics](https:\/\/torchmetrics.readthedocs.io\/en\/stable\/).\n- A centralized metrics module that allows users to add new metrics\n- Commonly used metrics, including AUC, Calibration, CTR, MSE\/RMSE, NE & Throughput\n- Optimization for metrics related operations to reduce the overhead of metric computation\n- Checkpointing","__index_level_0__":1440}
+{"text":"### (Prototype) Single process Batched + Fused Embeddings","__index_level_0__":1441}
+{"text":"Previously TorchRec\u2019s abstractions (EmbeddingBagCollection\/EmbeddingCollection) over FBGEMM kernels, which provide benefits such as table batching, optimizer fusion, and UVM placement, could only be used in conjunction with DistributedModelParallel. We\u2019ve decoupled these notions from sharding, and introduced the [FusedEmbeddingBagCollection](https:\/\/github.com\/pytorch\/torchrec\/blob\/eb1247d8a2d16edc4952e5c2617e69acfe5477a5\/torchrec\/modules\/fused_embedding_modules.py#L271), which can be used as a standalone module, with all of the above features, and can also be sharded.","__index_level_0__":1442}
+{"text":"## TorchX v0.2.0","__index_level_0__":1443}
+{"text":"TorchX is a job launcher that makes it easier to run PyTorch in distributed training clusters with many scheduler integrations including Kubernetes and Slurm. We're excited to release TorchX 0.2.0 with a number of improvements. TorchX is currently being used in production in both on-premise and cloud environments.","__index_level_0__":1444}
+{"text":"Check out the [quickstart](https:\/\/pytorch.org\/torchx\/main\/quickstart.html) to start launching local and remote jobs.","__index_level_0__":1445}
+{"text":"### Workspaces","__index_level_0__":1446}
+{"text":"TorchX [now supports workspaces](https:\/\/pytorch.org\/torchx\/main\/workspace.html) which allows users to easily launch training jobs using their local workspace. TorchX can automatically build a patch with your local training code on top of a base image to minimize iteration time and time to training.","__index_level_0__":1447}
+{"text":"### .torchxconfig","__index_level_0__":1448}
+{"text":"Specifying options in [.torchxconfig](https:\/\/pytorch.org\/torchx\/latest\/runner.config.html) saves you from having to type long CLI commands each time you launch a job. You can also define project level generic configs and drop a config file in your home directory for user-level overrides.","__index_level_0__":1449}
+{"text":"### Expanded Scheduler Support","__index_level_0__":1450}
+{"text":"TorchX now supports [AWS Batch](https:\/\/pytorch.org\/torchx\/main\/schedulers\/aws_batch.html) and [Ray (experimental)](https:\/\/pytorch.org\/torchx\/main\/schedulers\/ray.html) schedulers in addition to our existing integrations.","__index_level_0__":1451}
+{"text":"### Distributed Training On All Schedulers","__index_level_0__":1452}
+{"text":"The TorchX dist.ddp component now works on all schedulers without any configuration. Distributed training workers will automatically discover each other when using [torchelastic](https:\/\/pytorch.org\/docs\/stable\/distributed.elastic.html) via [the builtin dist.ddp component](https:\/\/pytorch.org\/torchx\/main\/components\/distributed.html).","__index_level_0__":1453}
+{"text":"### Hyper Parameter Optimization","__index_level_0__":1454}
+{"text":"TorchX [integrates with Ax](https:\/\/ax.dev\/versions\/latest\/api\/runners.html#module-ax.runners.torchx) to let you scale hyper-parameter optimizations (HPO) by launching the search trials onto remote clusters.","__index_level_0__":1455}
+{"text":"### File and Device Mounts","__index_level_0__":1456}
+{"text":"TorchX now supports [remote filesystem mounts and custom devices](https:\/\/pytorch.org\/torchx\/main\/specs.html#mounts). This enables your PyTorch jobs to efficiently access cloud storage such as NFS or Lustre. The device mounts enables usage of network accelerators like Infiniband and custom inference\/training accelerators.","__index_level_0__":1457}
+{"text":"## FBGemm v0.2.0","__index_level_0__":1458}
+{"text":"The FBGEMM library contains optimized kernels meant to improve the performance of PyTorch workloads. We\u2019ve added a number of new features and optimizations over the last few months that we are excited to report.","__index_level_0__":1459}
+{"text":"### Inference Table Batched Embedding (TBE)","__index_level_0__":1460}
+{"text":"The [table batched embedding bag](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/fbgemm_gpu\/split_table_batched_embeddings_ops.py#L1541) (TBE) operator is an important base operation for embedding lookup for recommendation system inference on GPU. We added the following enhancements for performance and flexibility:","__index_level_0__":1461}
+{"text":"Alignment restriction removed\n- Embedding dimension \\* data type size had to be multiple of 4B before and now, it is 1B.","__index_level_0__":1462}
+{"text":"Unified Virtual Memory (UVM) caching kernel optimizations\n- UVM caching kernels now scale linearly with # of tables using UVM caching. Previously, it was having similar overhead as all tables using UVM caching\n- UVM caching kernel overhead is much smaller than before","__index_level_0__":1463}
+{"text":"### Inference FP8 Table Batched Embedding (TBE) ","__index_level_0__":1464}
+{"text":"The [table batched embedding bag](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/fbgemm_gpu\/split_table_batched_embeddings_ops.py#L1541) (TBE) previously supported FP32, FP16, INT8, INT4, and INT2 embedding weight types.  While these weight types work well in many models, we integrate FP8 weight types (in both GPU and CPU operations) to allow for numerical and performance evaluations of FP8 in our models.  Compared to INT8, FP8 does not require the additional bias and scale storage and calculations.  Additionally, the next generation of H100 GPUs has the FP8 support on Tensor Core (mainly matmul ops).","__index_level_0__":1465}
+{"text":"### Jagged Tensor Kernels","__index_level_0__":1466}
+{"text":"We added optimized kernels to speed up [TorchRec JaggedTensor](https:\/\/pytorch.org\/torchrec\/torchrec.sparse.html). The purpose of JaggedTensor is to handle the case where one dimension of the input data is \u201cjagged\u201d, meaning that each consecutive row in a given dimension may be a different length, which is often the case with sparse feature inputs in recommendation systems. The internal representation is shown below:","__index_level_0__":1467}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/Jagged-Tensor-Figure-from-FBGEMM-section.png\" width=\"80%\">\n<\/p>","__index_level_0__":1468}
+{"text":"We added ops for [converting jagged tensors from sparse to dense formats](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/src\/jagged_tensor_ops_cpu.cpp#L982) [and back](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/src\/jagged_tensor_ops_cpu.cpp#L968), performing [matrix multiplications with jagged tensors](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/src\/jagged_tensor_ops_cpu.cpp#L996), and [elementwise ops](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/src\/jagged_tensor_ops_cpu.cpp#L995).\n  \n### Optimized permute102-baddbmm-permute102","__index_level_0__":1469}
+{"text":"It is difficult to fuse various matrix multiplications where the batch size is not the batch size of the model, switching the batch dimension is a quick solution. We created the [permute102_baddbmm_permute102](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/src\/sparse_ops_cpu.cpp#L2401) operation that switches the first and the second dimension, performs the batched matrix multiplication and then switches back. Currently we only support forward pass with FP16 data type and will support FP32 type and backward pass in the future.","__index_level_0__":1470}
+{"text":"### Optimized index_select for dim 0 index selection","__index_level_0__":1471}
+{"text":"index_select is normally used as part of a sparse operation. While PyTorch supports a generic index_select for an arbitrary-dimension index selection, its performance for a special case like the dim 0 index selection is suboptimal. For this reason, we implement a [specialized index_select for dim 0](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/src\/sparse_ops_cpu.cpp#L2421). In some cases, we have observed 1.4x performance gain from FBGEMM\u2019s index_select compared to the one from PyTorch (using uniform index distribution).","__index_level_0__":1472}
+{"text":"More about the implementation of influential instances can be found on our [GitHub](https:\/\/github.com\/pytorch\/captum\/tree\/master\/captum\/influence) page and [tutorials](https:\/\/captum.ai\/tutorials\/TracInCP_Tutorial).","__index_level_0__":1473}
+{"text":"Thanks for reading, If you\u2019re interested in these updates and want to join the PyTorch community, we encourage you to join the [discussion forums](https:\/\/discuss.pytorch.org\/) and [open GitHub issues](https:\/\/github.com\/pytorch\/pytorch\/issues). To get the latest news from PyTorch, follow us on [Twitter](https:\/\/twitter.com\/PyTorch), [Medium](https:\/\/medium.com\/pytorch), [YouTube](https:\/\/www.youtube.com\/pytorch), and [LinkedIn](https:\/\/www.linkedin.com\/company\/pytorch).","__index_level_0__":1474}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.12-new-library-releases\/ \n category: pytorch blogs","__index_level_0__":1476}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'The torch.linalg module: Accelerated Linear Algebra with Autograd in PyTorch'\nauthor: Mike Ruberry, Ivan Yashchuk, Xiao Wang, Mario Lezcano and Natalia Gimelshein\nfeatured-img: 'assets\/images\/cholesky-decomposition.png'\n---","__index_level_0__":1477}
+{"text":"Linear algebra is essential to deep learning and scientific computing, and it\u2019s always been a core part of PyTorch. PyTorch 1.9 extends PyTorch\u2019s support for linear algebra operations with the ```torch.linalg``` module. This module, documented [here](https:\/\/pytorch.org\/docs\/master\/linalg.html?highlight=linalg#module-torch.linalg), has 26 operators, including faster and easier to use versions of older PyTorch operators, every function from [NumPy\u2019s linear algebra module](https:\/\/numpy.org\/doc\/stable\/reference\/routines.linalg.html) extended with accelerator and autograd support, and a few operators that are completely new. This makes the ```torch.linalg``` immediately familiar to NumPy users and an exciting update to PyTorch\u2019s linear algebra support.","__index_level_0__":1478}
+{"text":"# NumPy-like linear algebra in PyTorch","__index_level_0__":1479}
+{"text":"If you\u2019re familiar with NumPy\u2019s linear algebra module then it\u2019ll be easy to start using ```torch.linalg```. In most cases it\u2019s a drop-in replacement. Let\u2019s looking at drawing samples from a [multivariate normal distribution](https:\/\/en.wikipedia.org\/wiki\/Multivariate_normal_distribution) using the [Cholesky decomposition](https:\/\/en.wikipedia.org\/wiki\/Cholesky_decomposition) as a motivating example to demonstrate this:","__index_level_0__":1480}
+{"text":"```python\nimport numpy as np","__index_level_0__":1481}
+{"text":"# Creates inputs\nnp.random.seed(0)\nmu_np = np.random.rand(4)\nL = np.random.rand(4, 4)\n# Covariance matrix sigma is positive-definite\nsigma_np = L @ L.T + np.eye(4)\nnormal_noise_np = np.random.standard_normal(mu_np.size)","__index_level_0__":1482}
+{"text":"def multivariate_normal_sample_np(mu, sigma, normal_noise):\n    return mu + np.linalg.cholesky(sigma) @ normal_noise","__index_level_0__":1483}
+{"text":"print(\"Random sample: \", \n      multivariate_normal_sample_np(mu_np, sigma_np, normal_noise_np))\n: Random sample: [2.9502426 1.78518077 1.83168697 0.90798228]\n```","__index_level_0__":1484}
+{"text":"Now let\u2019s see the same sampler implemented in PyTorch:","__index_level_0__":1485}
+{"text":"```python\nimport torch","__index_level_0__":1486}
+{"text":"def multivariate_normal_sample_torch(mu, sigma, normal_noise):\n    return mu + torch.linalg.cholesky(sigma) @ normal_noise\n```","__index_level_0__":1487}
+{"text":"The two functions are identical, and we can validate their behavior by calling the function with the same arguments wrapped as PyTorch tensors:","__index_level_0__":1488}
+{"text":"```python\n# NumPy arrays are wrapped as tensors and share their memory\nmu_torch = torch.from_numpy(mu_np)\nsigma_torch = torch.from_numpy(sigma_np)\nnormal_noise_torch = torch.from_numpy(normal_noise_np)","__index_level_0__":1489}
+{"text":"multivariate_normal_sample_torch(mu_torch, sigma_torch, normal_noise_torch)\n: tensor([2.9502, 1.7852, 1.8317, 0.9080], dtype=torch.float64)\n```","__index_level_0__":1490}
+{"text":"The only difference is in how PyTorch prints tensors by default. ","__index_level_0__":1491}
+{"text":"The Cholesky decomposition can also help us quickly compute the probability density function of the non-degenerate multivariate normal distribution. One of the expensive terms in that computation is the square root of the determinant of the covariance matrix. Using [properties of the determinant](https:\/\/en.wikipedia.org\/wiki\/Determinant#Properties_of_the_determinant) and the Cholesky decomposition we can calculate the same result faster than the naive computation, however. Here\u2019s the NumPy program that demonstrates this:","__index_level_0__":1492}
+{"text":"```python\nsqrt_sigma_det_np = np.sqrt(np.linalg.det(sigma_np))\nsqrt_L_det_np = np.prod(np.diag(np.linalg.cholesky(sigma_np)))","__index_level_0__":1493}
+{"text":"print(\"|sigma|^0.5 = \", sqrt_sigma_det_np)\n: |sigma|^0.5 = 4.237127491242027\n \nprint(\"|L| = \", sqrt_L_det_np)\n: |L| = 4.237127491242028\n```","__index_level_0__":1494}
+{"text":"And here\u2019s the same validation in PyTorch:","__index_level_0__":1495}
+{"text":"```python\nsqrt_sigma_det_torch = torch.sqrt(torch.linalg.det(sigma_torch))\nsqrt_L_det_torch = torch.prod(torch.diag(torch.linalg.cholesky(sigma_torch)))","__index_level_0__":1496}
+{"text":"print(\"|sigma|^0.5 = \", sqrt_sigma_det_torch)\n: |sigma|^0.5 = tensor(4.2371, dtype=torch.float64) ","__index_level_0__":1497}
+{"text":"print(\"|L| = \", sqrt_L_det_torch)\n: |L| = tensor(4.2371, dtype=torch.float64)\n```","__index_level_0__":1498}
+{"text":"We can measure the difference in run time using PyTorch\u2019s built-in benchmark utility:","__index_level_0__":1499}
+{"text":"```python\nimport torch.utils.benchmark as benchmark","__index_level_0__":1500}
+{"text":"t0 = benchmark.Timer(\n    stmt='torch.sqrt(torch.linalg.det(sigma))',\n    globals={'sigma': sigma_torch})","__index_level_0__":1501}
+{"text":"t1 = benchmark.Timer(\n    stmt='torch.prod(torch.diag(torch.linalg.cholesky(sigma)))',\n    globals={'sigma': sigma_torch})","__index_level_0__":1502}
+{"text":"print(t0.timeit(100))\n: torch.sqrt(torch.linalg.det(sigma))\n  80.80 us\n  1 measurement, 100 runs , 1 thread","__index_level_0__":1503}
+{"text":"\nprint(t1.timeit(100))\n: torch.prod(torch.diag(torch.linalg.cholesky(sigma)))\n  11.56 us\n  1 measurement, 100 runs , 1 thread\n  ```\n  \nDemonstrating that the approach using the Cholesky decomposition can be significantly faster. Behind the scenes, PyTorch\u2019s linear algebra module uses OpenBLAS or MKL implementations of the LAPACK standard to maximize its CPU performance.","__index_level_0__":1504}
+{"text":"# Autograd Support","__index_level_0__":1505}
+{"text":"PyTorch\u2019s linear algebra module doesn\u2019t just implement the same functions as NumPy\u2019s linear algebra module (and a few more), it also extends them with autograd and CUDA support.","__index_level_0__":1506}
+{"text":"Let\u2019s look at a very simple program that just computes an inverse and the gradient of that operation to show how autograd works:","__index_level_0__":1507}
+{"text":"```python\nt = torch.tensor(((1, 2), (3, 4)), dtype=torch.float32, requires_grad=True)","__index_level_0__":1508}
+{"text":"inv = torch.linalg.inv(t)\ninv.backward(torch.ones_like(inv))","__index_level_0__":1509}
+{"text":"print(t.grad)\n: tensor([[-0.5000, 0.5000],\n          [ 0.5000, -0.5000]])\n```","__index_level_0__":1510}
+{"text":"We can mimic the same computation in NumPy by defining the autograd formula ourselves:","__index_level_0__":1511}
+{"text":"```python\na = np.array(((1, 2), (3, 4)), dtype=np.float32)","__index_level_0__":1512}
+{"text":"inv_np = np.linalg.inv(a)","__index_level_0__":1513}
+{"text":"def inv_backward(result, grad):\n    return -(result.transpose(-2, -1) @ (grad @ result.transpose(-2, -1)))\ngrad_np = inv_backward(inv_np, np.ones_like(inv_np))","__index_level_0__":1514}
+{"text":"print(grad_np)\n: [[-0.5 0.5]\n   [ 0.5 -0.5]]\n```","__index_level_0__":1515}
+{"text":"Of course, as programs become more complicated it\u2019s convenient to have builtin autograd support, and PyTorch\u2019s linear algebra module supports both real and complex autograd.","__index_level_0__":1516}
+{"text":"# CUDA Support","__index_level_0__":1517}
+{"text":"Support for autograd and accelerators, like CUDA devices, is a core part of PyTorch. The ```torch.linalg``` module was developed with NVIDIA\u2019s PyTorch and cuSOLVER teams, who helped optimize its performance on CUDA devices with the cuSOLVER, cuBLAS, and MAGMA libraries. These improvements make PyTorch\u2019s CUDA linear algebra operations faster than ever. For example, let\u2019s look at the performance of PyTorch 1.9\u2019s ```torch.linalg.cholesky``` vs. PyTorch 1.8\u2019s (now deprecated) ```torch.cholesky```:","__index_level_0__":1518}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/cholesky-decomposition.png\" width=\"100%\">\n<\/div>","__index_level_0__":1519}
+{"text":"(The above charts were created using an Ampere A100 GPU with CUDA 11.3, cuSOLVER 11.1.1.58, and MAGMA 2.5.2. Matrices are in double precision.)","__index_level_0__":1520}
+{"text":"These charts show that performance has increased significantly on larger matrices, and that batched performance is better across the board. Other linear algebra operations, including ```torch.linalg.qr``` and ```torch.linalg.lstsq```, have also had their CUDA performance improved.","__index_level_0__":1521}
+{"text":"# Beyond NumPy","__index_level_0__":1522}
+{"text":"In addition to offering all the functions in NumPy\u2019s linear algebra module with support for autograd and accelerators, ```torch.linalg``` has a few new functions of its own. NumPy\u2019s ```linalg.norm``` does not allow users to compute vector norms over arbitrary subsets of dimensions, so to enable this functionality we added ```torch.linalg.vector_norm```. We\u2019ve also started modernizing other linear algebra functionality in PyTorch, so we created ```torch.linalg.householder_product``` to replace the older ```torch.orgqr```, and we plan to continue adding more linear algebra functionality in the future, too.","__index_level_0__":1523}
+{"text":"# The Future of Linear Algebra in PyTorch","__index_level_0__":1524}
+{"text":"The ```torch.linalg``` module is fast and familiar with great support for autograd and accelerators. It\u2019s already being used in libraries like [botorch](https:\/\/github.com\/pytorch\/botorch), too. But we\u2019re not stopping here. We plan to continue updating more of PyTorch\u2019s existing linear algebra functionality (like ```torch.lobpcg```) and offering more support for low rank and sparse linear algebra. We also want to hear your feedback on how we can improve, so start a conversation on the [forum](https:\/\/discuss.pytorch.org\/) or file an issue on our [Github](https:\/\/github.com\/pytorch\/pytorch) and share your thoughts. ","__index_level_0__":1525}
+{"text":"We look forward to hearing from you and seeing what the community does with PyTorch\u2019s new linear algebra functionality!\n \n source: https:\/\/pytorch.org\/blog\/torch-linalg-autograd\/ \n category: pytorch blogs","__index_level_0__":1526}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Democratizing AI with PyTorch Foundation and ROCm\u2122 support for PyTorch\"\nauthor: AMD\n---","__index_level_0__":1527}
+{"text":"![AMD Founding Member](\/assets\/images\/2023-02-14-democratizing-ai-with-pytorch-1.png){:width=\"50%\" style=\"display:block; margin-left:auto; margin-right:auto\"}","__index_level_0__":1528}
+{"text":"Last year, Meta announced that [PyTorch](https:\/\/pytorch.org\/) joined the Linux Foundation as a neutral home for growing the machine learning project and community with AMD representation as a part of the founding membership and governing board.","__index_level_0__":1529}
+{"text":"[PyTorch Foundation\u2019s](https:\/\/pytorch.org\/foundation) mission is to drive AI adoption by democratizing its software ecosystem through open source principles aligning with the AMD core principle of an Open software ecosystem. AMD strives to foster innovation through the support for latest generations of hardware, tools, libraries, and other components to simplify and accelerate adoption of AI across a broad range of scientific discoveries.","__index_level_0__":1530}
+{"text":"<div class=\"d-md-flex\">\n<div style=\"flex-basis: 60%;\">\n<p>\nAMD, along with key PyTorch codebase developers (including those at Meta AI), delivered a set of updates to the <a href=\"https:\/\/www.amd.com\/en\/graphics\/servers-solutions-rocm\" target=\"_blank\">ROCm\u2122<\/a> open software ecosystem that brings stable support for <a href=\"https:\/\/www.amd.com\/en\/graphics\/instinct-server-accelerators\" target=\"_blank\">AMD Instinct\u2122<\/a> accelerators as well as many Radeon\u2122 GPUs. This now gives PyTorch developers the ability to build their next great AI solutions leveraging AMD GPU accelerators & ROCm. The support from PyTorch community in identifying gaps, prioritizing key updates, providing feedback for performance optimizing and supporting our journey from \u201cBeta\u201d to \u201cStable\u201d was immensely helpful and we deeply appreciate the strong collaboration between the two teams at AMD and PyTorch. The move for ROCm support from \u201cBeta\u201d to \u201cStable\u201d came in the PyTorch 1.12 release (June 2022) brings the added support to easily run PyTorch on native environment without having to configure custom dockers. This is a sign of confidence about the quality of support and performance of PyTorch using AMD Instinct and ROCm. The results of these collaborative efforts are evident in the performance measured on key industry benchmarks like Microsoft\u2019s SuperBench shown below in Graph 1.\n<\/p>\n<\/div>\n<div style=\"\n  border: 1px solid #d0d0d0;\n  border-radius: 10px;\n  box-sizing: border-box;\n  -webkit-filter: drop-shadow(0 2px 5px rgba(0,0,0,.1));\n  filter: drop-shadow(0 2px 5px rgba(0,0,0,.1));\n  padding: 30px;\n  background-color: #f8f8f8;\n  margin: 20px;\n  color: black;\n  font-size: 1.6rem;\n  flex-basis: 40%;\n\">\n<p>\n<em>\u201cWe are excited to see the significant impact of developers at AMD to contribute to and extend features within PyTorch to make AI models run in a more performant, efficient, and scalable way. A great example of this is the thought-leadership around unified memory approaches between the framework and future hardware systems, and we look forward to seeing that feature progress.\u201d<\/em><br\/> \n- Soumith Chintala, PyTorch lead-maintainer and Director of Engineering, Meta AI\n<\/p>\n<\/div>\n<\/div>","__index_level_0__":1531}
+{"text":"\nThe progressive improvements on both the AMD CDNA\u2122 architecture as well as ROCm and PyTorch shows single GPU model throughput increase from AMD Instinct MI100 to the latest generation AMD Instinct MI200 family GPUs going from ROCm 4.2 to ROCm 5.3 and from PyTorch 1.7 to PyTorch 1.12.","__index_level_0__":1532}
+{"text":"![Graph 1: ML model performance over generation using Microsoft Superbench Suite](\/assets\/images\/2023-02-14-democratizing-ai-with-pytorch-2.png){:width=\"100%\"}","__index_level_0__":1533}
+{"text":"<small><em>Graph 1: ML model performance over generation using Microsoft Superbench Suite <sup>1, 2, 3<\/sup><\/em><\/small>","__index_level_0__":1534}
+{"text":"\nBelow are a few of the key updates for ROCm support since the PyTorch 1.12 release","__index_level_0__":1535}
+{"text":"## Full Continuous Integration (CI) for ROCm on PyTorch","__index_level_0__":1537}
+{"text":"With the ROCm support for PyTorch move from \u201cBeta\u201d to \u201cStable,\u201d all the functions and features commits are now verified through a full Continuous Integration (CI) process. The CI process helps ensure the proper build and test process ahead of an expected Docker and PIP wheel release with stable commits forthcoming.","__index_level_0__":1538}
+{"text":"\n## Support for [Kineto Profiler](https:\/\/github.com\/pytorch\/kineto)","__index_level_0__":1539}
+{"text":"The addition of Kineto profiler support to ROCm now helps developers and users understand performance bottlenecks through effective diagnosis and profiling tools. The tool also provides recommendations to improve known issues and visualization through TensorBoard UI.","__index_level_0__":1540}
+{"text":"## Key PyTorch Libraries support added","__index_level_0__":1541}
+{"text":"PyTorch ecosystem libraries like [TorchText](https:\/\/pytorch.org\/tutorials\/beginner\/text_sentiment_ngrams_tutorial.html) (Text classification), [TorchRec](https:\/\/pytorch.org\/torchrec\/) (libraries for recommender systems - RecSys), [TorchVision](https:\/\/pytorch.org\/vision\/stable\/index.html) (Computer Vision), [TorchAudio](https:\/\/pytorch.org\/audio\/stable\/index.html) (audio and signal processing) are fully supported since ROCm 5.1 and upstreamed with PyTorch 1.12.","__index_level_0__":1542}
+{"text":"Key libraries provided with the ROCm software stack including [MIOpen](https:\/\/github.com\/ROCmSoftwarePlatform\/MIOpen) (Convolution models), [RCCL](https:\/\/github.com\/ROCmSoftwarePlatform\/rccl) (ROCm Collective Communications) and [rocBLAS](https:\/\/github.com\/ROCmSoftwarePlatform\/rocBLAS) (BLAS for transformers) were further optimized to offer new potential efficiencies and higher performance.","__index_level_0__":1543}
+{"text":"MIOpen innovates on several fronts, such as implementing fusion to optimize for memory bandwidth and GPU launch overheads, providing an auto-tuning infrastructure to overcome the large design space of problem configurations, and implementing different algorithms to optimize convolutions for different filter and input sizes. MIOpen is one of the first libraries to publicly support the bfloat16 data-type for convolutions, allowing efficient training at lower precision maintaining expected accuracy.","__index_level_0__":1544}
+{"text":"RCCL (pronounced \"Rickle\") is a stand-alone library of standard collective communication routines for GPUs, implementing all-reduce, all-gather, reduce, broadcast, reduce-scatter, gather, scatter, and all-to-all. There is support for direct GPU-to-GPU send and receive operations. It has been optimized to achieve high bandwidth on platforms using PCIe\u00ae, Infinity Fabric\u2122 (GPU to GPU) as well as networking using InfiniBand Verbs or TCP\/IP sockets. RCCL supports an arbitrary number of GPUs installed in single or multiple nodes and can be used in either single- or multi-process (e.g., MPI) applications.","__index_level_0__":1545}
+{"text":"Along with the above key highlights, over 50 features and functionality improvements were completed jointly between AMD and PyTorch to add stable support for ROCm. These include improvements to tools, compilers, runtime, graph optimizations through TorchScript, INT8 quant path usage, and [ONNX runtime integration](https:\/\/onnxruntime.ai\/) including support for Navi 21 based Radeon\u2122 PRO datacenter graphics card to name a few.","__index_level_0__":1546}
+{"text":"## [AITemplate](https:\/\/github.com\/facebookincubator\/AITemplate) Inference Engine","__index_level_0__":1547}
+{"text":"MetaAI recently published a blog announcing the release of its open source AITemplate ([link](https:\/\/ai.facebook.com\/blog\/gpu-inference-engine-nvidia-amd-open-source\/)) for a unified inference system supporting AMD Instinct GPU accelerators using the AMD ROCm stack. This Python based framework can help significantly improve performance through increased utilization of AMD matrix cores for transformer blocks. This is achieved through the AMD [Composable Kernel (CK) library](https:\/\/github.com\/ROCmSoftwarePlatform\/composable_kernel) which provides performance critical Kernels for ML AI workloads across multiple architectures including GPUs and CPUs through HIP & C++.","__index_level_0__":1548}
+{"text":"Moreover, the AITemplate also provides out-of-the-box support for widely used AI models like BERT, ResNET, Vision Transformer, Stable Diffusion etc. simplifying deployment process through these pretrained models.","__index_level_0__":1549}
+{"text":" \n## What\u2019s coming with future ROCm releases?","__index_level_0__":1550}
+{"text":"### Unified memory models for CPU + GPU","__index_level_0__":1551}
+{"text":"As system architecture evolves to address the complexity of large problem sizes and data sets, memory management becomes a key performance bottle neck that needs a cohesive strategy to be addressed through innovations at both hardware and software levels. AMD is uniquely positioned to address this problem with its effective data center solutions integrating AMD EPYC\u2122 CPU cores with its AMD Instinct GPU compute units in a truly unified datacenter APU (Accelerated Processing Unit) form factor set to be launched in 2H 2023.","__index_level_0__":1553}
+{"text":"The software work to leverage the unified CPU + GPU memory has already started in collaboration with the PyTorch team, to enable the usage of a fast, low latency, synchronized memory model that enables not only AMD but also other AI accelerators to address the complex memory management problem of today. We are looking forward to this joint effort and announcement soon.","__index_level_0__":1554}
+{"text":"## Acknowledgement","__index_level_0__":1555}
+{"text":"The content in this blog highlights the joint work between AMD and key PyTorch contributors including Meta, working on many of the core features, as well as Microsoft enabling ONNX Runtime support. We are looking forward to working with the other founding members at the PyTorch Foundation on the next steps and improvements to democratize and grow adoption of PyTorch across the industry.","__index_level_0__":1556}
+{"text":"## CAUTIONARY STATEMENT ","__index_level_0__":1557}
+{"text":"<small>\nThis blog contains forward-looking statements concerning Advanced Micro Devices, Inc. (AMD) such as the availability, timing and expected benefits of an AMD datacenter APU form factor, which are made pursuant to the Safe Harbor provisions of the Private Securities Litigation Reform Act of 1995. Forward-looking statements are commonly identified by words such as \"would,\" \"may,\" \"expects,\" \"believes,\" \"plans,\" \"intends,\" \"projects\" and other terms with similar meaning. Investors are cautioned that the forward-looking statements in this blog are based on current beliefs, assumptions and expectations, speak only as of the date of this blog and involve risks and uncertainties that could cause actual results to differ materially from current expectations. Such statements are subject to certain known and unknown risks and uncertainties, many of which are difficult to predict and generally beyond AMD's control, that could cause actual results and other future events to differ materially from those expressed in, or implied or projected by, the forward-looking information and statements. Investors are urged to review in detail the risks and uncertainties in AMD\u2019s Securities and Exchange Commission filings, including but not limited to AMD\u2019s most recent reports on Forms 10-K and 10-Q. AMD does not assume, and hereby disclaims, any obligation to update forward-looking statements made in this blog, except as may be required by law. \n<\/small>\n ","__index_level_0__":1558}
+{"text":"## Endnotes","__index_level_0__":1559}
+{"text":"\n1. <small>MI100D-01 SuperBench v0.5 model training results based on AMD internal testing as of 11\/09\/2022 measuring the total training throughput, at half precision, using a 2P AMD EPYC\u2122 7763 CPU server tested with 1x AMD Instinct\u2122 MI100 (32GB HBM2e) 300W GPU, SBIOS 2.2, Ubuntu\u00ae 20.04.5 LTS, host ROCm\u2122 5.2.0, guest ROCm 4.2,    PyTorch 1.7.0. Server manufacturers may vary configurations, yielding different results. Performance may vary based factors including use of latest drivers and optimizations.<\/small>\n2. <small>MI200D-01 SuperBench v0.6 model training results based on AMD internal testing as of 11\/09\/2022 measuring the total training throughput, at half precision, using a 2P AMD EPYC\u2122 7763 CPU server tested with 1x AMD Instinct\u2122 MI210 (64GB HBM2e) 300W GPU, SBIOS 2.2, Ubuntu 20.04.5 LTS, host ROCm 5.3.0, guest ROCm 5.3, PyTorch 1.12. Server manufacturers may vary configurations, yielding different results. Performance may vary based factors including use of latest drivers and optimizations.<\/small>\n3. <small>MI200D-02: SuperBench v0.6 model training results based on AMD internal testing as of 11\/09\/2022 measuring the total training throughput, at half precision, using a 2P AMD EPYC\u2122\ufe0f 7763 CPU server tested with 1x AMD Instinct\u2122\ufe0f MI250 (128GB HBM2e) 560W GPU, SBIOS M12, Ubuntu 20.04 LTS, host ROCm 5.3.0, guest ROCm 5.3, PyTorch 1.12. Server manufacturers may vary configurations, yielding different results. Performance may vary based factors including use of latest drivers and optimizations.<\/small>","__index_level_0__":1560}
+{"text":" \n source: https:\/\/pytorch.org\/blog\/democratizing-ai-with-pytorch\/ \n category: pytorch blogs","__index_level_0__":1561}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Introducing PyTorch Fully Sharded Data Parallel (FSDP) API\"\nauthor: Yanli Zhao, Rohan Varma, Chien-Chin Huang, Shen Li, Min Xu, Alban Desmaison\nfeatured-img: \"assets\/images\/pytorch-logo.jpg\"\n---","__index_level_0__":1562}
+{"text":"Recent studies have shown that large model training will be beneficial for improving model quality. During the last 3 years, model size grew 10,000 times from [BERT](https:\/\/arxiv.org\/abs\/1810.04805) with 110M parameters to [Megatron-2](https:\/\/arxiv.org\/abs\/2104.04473) with one trillion. However, training large AI models is not easy\u2014aside from the need for large amounts of computing resources, software engineering complexity is also challenging. PyTorch has been working on building tools and infrastructure to make it easier.","__index_level_0__":1563}
+{"text":"PyTorch Distributed data parallelism is a staple of scalable deep learning because of its robustness and simplicity. It however requires the model to fit on one GPU. Recent approaches like DeepSpeed ZeRO and FairScale\u2019s Fully Sharded Data Parallel allow us to break this barrier by sharding a model\u2019s parameters, gradients and optimizer states across data parallel workers while still maintaining the simplicity of data parallelism.","__index_level_0__":1564}
+{"text":"With PyTorch 1.11 we\u2019re adding native support for Fully Sharded Data Parallel (FSDP), currently available as a prototype feature. Its implementation heavily borrows from FairScale\u2019s version while bringing more streamlined APIs and additional performance improvements.","__index_level_0__":1565}
+{"text":"Scaling tests of PyTorch FSDP on AWS show it can scale up to train dense models with 1T parameters. Realized performance in our experiments reached 84 TFLOPS per A100 GPU for GPT 1T model and 159 TFLOPS per A100 GPU for GPT 175B model on AWS cluster. Native FSDP implementation also dramatically improved model initialization time compared to FairScale\u2019s original when CPU offloading was enabled.","__index_level_0__":1566}
+{"text":"In future PyTorch versions, we\u2019re going to enable users to seamlessly switch between DDP, ZeRO-1, ZeRO-2 and FSDP flavors of data parallelism, so that users can train different scales of models with simple configurations in the unified API.","__index_level_0__":1567}
+{"text":"### How FSDP Works","__index_level_0__":1568}
+{"text":"FSDP is a type of data-parallel training, but unlike traditional data-parallel, which maintains a per-GPU copy of a model\u2019s parameters, gradients and optimizer states, it shards all of these states across data-parallel workers and can optionally offload the sharded model parameters to CPUs. ","__index_level_0__":1569}
+{"text":"The figure below shows how FSDP works for 2 data-parallel processes:","__index_level_0__":1570}
+{"text":"\n<p align=\"center\">\n  <img src=\"\/assets\/images\/fsdp_workflow.png\" width=\"100%\">\n<\/p>","__index_level_0__":1571}
+{"text":"<p align = \"center\">\nFigure 1. FSDP workflow\n<\/p>","__index_level_0__":1572}
+{"text":"Usually, model layers are wrapped with FSDP in a nested way, so that only layers in a single FSDP instance need to gather the full parameters to a single device during forward or backward computations. The gathered full parameters will be freed immediately after computation, and the freed memory can be used for the next layer\u2019s computation. In this way, peak GPU memory could be saved and thus training can be scaled to use a larger model size or larger batch size. To further maximize memory efficiency, FSDP can offload the parameters, gradients and optimizer states to CPUs when the instance is not active in the computation.","__index_level_0__":1573}
+{"text":"### Using FSDP in PyTorch","__index_level_0__":1574}
+{"text":"There are two ways to wrap a model with PyTorch FSDP. Auto wrapping is a drop-in replacement for DDP; manual wrapping needs minimal changes of model definition code with the ability to explore complex sharding strategies.","__index_level_0__":1575}
+{"text":"\n#### Auto Wrapping","__index_level_0__":1576}
+{"text":"Model layers should be wrapped in FSDP in a nested way to save peak memory and enable communication and computation overlapping. The simplest way to do it is auto wrapping, which can serve as a drop-in replacement for DDP without changing the rest of the code.","__index_level_0__":1577}
+{"text":"fsdp_auto_wrap_policy argument allows specifying a callable function to recursively wrap layers with FSDP. default_auto_wrap_policy function provided by the PyTorch FSDP recursively wraps layers with the number of parameters larger than 100M. You can supply your own wrapping policy as needed. The example of writing a customized wrapping policy is shown in the [FSDP API doc](https:\/\/pytorch.org\/docs\/stable\/fsdp.html).","__index_level_0__":1578}
+{"text":"In addition, cpu_offload could be configured optionally to offload wrapped parameters to CPUs when these parameters are not used in computation. This can further improve memory efficiency at the cost of data transfer overhead between host and device.","__index_level_0__":1579}
+{"text":"The example below shows how FSDP is wrapped using auto wrapping.","__index_level_0__":1580}
+{"text":"```python\nfrom torch.distributed.fsdp import (\n   FullyShardedDataParallel,\n   CPUOffload,\n)\nfrom torch.distributed.fsdp.wrap import (\n   default_auto_wrap_policy,\n)\nimport torch.nn as nn\n \nclass model(nn.Module):\n   def __init__(self):\n       super().__init__()\n       self.layer1 = nn.Linear(8, 4)\n       self.layer2 = nn.Linear(4, 16)\n       self.layer3 = nn.Linear(16, 4)\n \nmodel = DistributedDataParallel(model())\nfsdp_model = FullyShardedDataParallel(\n   model(),\n   fsdp_auto_wrap_policy=default_auto_wrap_policy,\n   cpu_offload=CPUOffload(offload_params=True),\n)\n```","__index_level_0__":1581}
+{"text":"#### Manual Wrapping","__index_level_0__":1582}
+{"text":"Manual wrapping can be useful to explore complex sharding strategies by applying `wrap` selectively to some parts of the model. Overall settings can be passed to the enable_wrap()  context manager.","__index_level_0__":1583}
+{"text":"```python\nfrom torch.distributed.fsdp import (\n   FullyShardedDataParallel,\n   CPUOffload,\n)\nfrom torch.distributed.fsdp.wrap import (\n   enable_wrap,\n   wrap,\n)\nimport torch.nn as nn\nfrom typing import Dict\n \n \nclass model(nn.Module):\n   def __init__(self):\n       super().__init__()\n       self.layer1 = wrap(nn.Linear(8, 4))\n       self.layer2 = nn.Linear(4, 16)\n       self.layer3 = wrap(nn.Linear(16, 4))\n \nwrapper_kwargs = Dict(cpu_offload=CPUOffload(offload_params=True))\nwith enable_wrap(wrapper_cls=FullyShardedDataParallel, **wrapper_kwargs):\n   fsdp_model = wrap(model())\n```","__index_level_0__":1584}
+{"text":"After wrapping the model with FSDP using one of the two above approaches, the model can be trained in a similar way as local training, like this:","__index_level_0__":1585}
+{"text":"```python\noptim = torch.optim.Adam(fsdp_model.parameters(), lr=0.0001)\nfor sample, label in next_batch():\n  out = fsdp_model(input)\n  loss = criterion(out, label)\n  loss.backward()\n  optim.step()\n```","__index_level_0__":1586}
+{"text":"### Benchmark Results","__index_level_0__":1587}
+{"text":"We ran extensive scaling tests for 175B and 1T GPT models on AWS clusters using PyTorch FSDP. Each cluster node is an instance with 8 [NVIDIA A100-SXM4-40GB](https:\/\/www.nvidia.com\/content\/dam\/en-zz\/Solutions\/Data-Center\/a100\/pdf\/nvidia-a100-datasheet-us-nvidia-1758950-r4-web.pdf) GPUs, and inter-nodes are connected via AWS Elastic Fabric Adapter (EFA) with 400 Gbps network bandwidth.","__index_level_0__":1588}
+{"text":"GPT models are implemented using [minGPT](https:\/\/github.com\/karpathy\/minGPT). A randomly generated input dataset is used for benchmarking purposes. All experiments ran with 50K vocabulary size, fp16 precision and [SGD](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.optim.SGD.html) optimizer.","__index_level_0__":1589}
+{"text":"| Model    | Number of layers | Hidden size | Attention heads | Model size, billions of parameters |\n|----------|------------------|-------------|-----------------|------------------------------------|\n| GPT 175B | 96               | 12288       | 96              | 175                                |\n| GPT 1T   | 128              | 25600       | 160             | 1008                               |","__index_level_0__":1590}
+{"text":"In addition to using FSDP with parameters CPU offloading in the experiments, the [activation checkpointing feature](https:\/\/pytorch.org\/docs\/stable\/checkpoint.html) in PyTorch is also applied in the tests.","__index_level_0__":1591}
+{"text":"The maximum per-GPU throughput of 159 teraFLOP\/s (51% of NVIDIA A100 peak theoretical performance 312 teraFLOP\/s\/GPU) is achieved with batch size 20 and sequence length 512 on 128 GPUs for the GPT 175B model; further increase of the number of GPUs leads to per-GPU throughput degradation because of growing communication between the nodes.","__index_level_0__":1592}
+{"text":"For the GPT 1T model, the maximum per-GPU throughput of 84 teraFLOP\/s (27% of the peak teraFLOP\/s) is achieved with batch size 4 and sequence length 2048 on 128 GPUs. However, further increase of the number of GPUs doesn\u2019t affect the per-GPU throughput too much because we observed that the largest bottleneck in the 1T model training is not from communication but from the slow CUDA cache allocator when peak GPU memory is reaching the limit. The use of A100 80G GPUs with larger memory capacity will mostly resolve this issue and also help scale the batch size to achieve much larger throughput.","__index_level_0__":1593}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/175b_throught.png\" width=\"60%\">\n<\/p>","__index_level_0__":1594}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/1t_thought.png\" width=\"60%\">\n<\/p>","__index_level_0__":1595}
+{"text":"### Future Work","__index_level_0__":1596}
+{"text":"In the next beta release, we are planning to add efficient distributed model\/states checkpointing APIs, meta device support for large model materialization, and mixed-precision support inside FSDP computation and communication. We\u2019re also going to make it easier to switch between [DDP](https:\/\/pytorch.org\/tutorials\/intermediate\/ddp_tutorial.html), [ZeRO1, ZeRO2](https:\/\/arxiv.org\/abs\/1910.02054) and FSDP flavors of data parallelism in the new API. To further improve FSDP performance, memory fragmentation reduction and communication efficiency improvements are also planned.","__index_level_0__":1597}
+{"text":"### A Bit of History of 2 Versions of FSDP","__index_level_0__":1598}
+{"text":"[FairScale FSDP](https:\/\/engineering.fb.com\/2021\/07\/15\/open-source\/fsdp\/) was released in early 2021 as part of the FairScale library. And then we started the effort to upstream FairScale FSDP to PyTorch in PT 1.11, making it production-ready. We have selectively upstreamed and refactored key features from FairScale FSDP, redesigned user interfaces and made performance improvements.","__index_level_0__":1599}
+{"text":"In the near future, FairScale FSDP will stay in the FairScale repository for research projects, while generic and widely adopted features will be upstreamed to PyTorch incrementally and hardened accordingly.","__index_level_0__":1600}
+{"text":"Meanwhile, PyTorch FSDP will focus more on production readiness and long-term support. This includes better integration with ecosystems and improvements on performance, usability, reliability, debuggability and composability.","__index_level_0__":1601}
+{"text":"### Acknowledgments","__index_level_0__":1602}
+{"text":"We would like to thank the authors of FairScale FSDP: Myle Ott, Sam Shleifer, Min Xu, Priya Goyal, Quentin Duval, Vittorio Caggiano, Tingting Markstrum, Anjali Sridhar. Thanks to the Microsoft DeepSpeed ZeRO team for developing and popularizing sharded data parallel techniques. Thanks to Pavel Belevich, Jessica Choi, Sisil Mehta for running experiments using PyTorch FSDP on different clusters. Thanks to Geeta Chauhan, Mahesh Yadav, Pritam Damania, Dmytro Dzhulgakov for supporting this effort and insightful discussions.\n \n source: https:\/\/pytorch.org\/blog\/introducing-pytorch-fully-sharded-data-parallel-api\/ \n category: pytorch blogs","__index_level_0__":1603}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch library updates including new model serving library '\nauthor: Team PyTorch\n---","__index_level_0__":1604}
+{"text":"\nAlong with the PyTorch 1.5 release, we are announcing new libraries for high-performance PyTorch model serving and tight integration with TorchElastic and Kubernetes. Additionally, we are releasing updated packages for torch_xla (Google Cloud TPUs), torchaudio, torchvision, and torchtext. All of these new libraries and enhanced capabilities are available today and accompany all of the core features [released in PyTorch 1.5](https:\/\/pytorch.org\/blog\/pytorch-1-dot-5-released-with-new-and-updated-apis). ","__index_level_0__":1605}
+{"text":"## TorchServe (Experimental)","__index_level_0__":1606}
+{"text":"TorchServe is a flexible and easy to use library for serving PyTorch models in production performantly at scale. It is cloud and environment agnostic and supports features such as multi-model serving, logging, metrics, and the creation of RESTful endpoints for application integration. TorchServe was jointly developed by engineers from Facebook and AWS with feedback and engagement from the broader PyTorch community. The experimental release of TorchServe is available today. Some of the highlights include:","__index_level_0__":1607}
+{"text":"* Support for both Python-based and TorchScript-based models\n* Default handlers for common use cases (e.g., image segmentation, text classification) as well as the ability to write custom handlers for other use cases\n* Model versioning, the ability to run multiple versions of a model at the same time, and the ability to roll back to an earlier version\n* The ability to package a model, learning weights, and supporting files (e.g., class mappings, vocabularies) into a single, persistent artifact (a.k.a. the \u201cmodel archive\u201d)\n* Robust management capability, allowing full configuration of models, versions, and individual worker threads via command line, config file, or run-time API\n* Automatic batching of individual inferences across HTTP requests\n* Logging including common metrics, and the ability to incorporate custom metrics\n* Ready-made Dockerfile for easy deployment\n* HTTPS support for secure deployment","__index_level_0__":1608}
+{"text":"To learn more about the APIs and the design of this feature, see the links below:\n* See <here> for a full multi-node deployment reference architecture.\n* The full documentation can be found [here](https:\/\/pytorch.org\/serve).","__index_level_0__":1609}
+{"text":"## TorchElastic integration with Kubernetes (Experimental)","__index_level_0__":1610}
+{"text":"[TorchElastic](https:\/\/github.com\/pytorch\/elastic) is a proven library for training large scale deep neural networks at scale within companies like Facebook, where having the ability to dynamically adapt to server availability and scale as new compute resources come online is critical. Kubernetes enables customers using machine learning frameworks like PyTorch to run training jobs distributed across fleets of powerful GPU instances like the Amazon EC2 P3. Distributed training jobs, however, are not fault-tolerant, and a job cannot continue if a node failure or reclamation interrupts training. Further, jobs cannot start without acquiring all required resources, or scale up and down without being restarted. This lack of resiliency and flexibility results in increased training time and costs from idle resources. TorchElastic addresses these limitations by enabling distributed training jobs to be executed in a fault-tolerant and elastic manner. Until today, Kubernetes users needed to manage Pods and Services required for TorchElastic training jobs manually.","__index_level_0__":1611}
+{"text":"Through the joint collaboration of engineers at Facebook and AWS, TorchElastic, adding elasticity and fault tolerance, is now supported using vanilla Kubernetes and through the managed EKS service from AWS.","__index_level_0__":1612}
+{"text":"To learn more see the [TorchElastic repo](http:\/\/pytorch.org\/elastic\/0.2.0rc0\/kubernetes.html) for the controller implementation and docs on how to use it.","__index_level_0__":1613}
+{"text":"## torch_xla 1.5 now available","__index_level_0__":1614}
+{"text":"[torch_xla](http:\/\/pytorch.org\/xla\/) is a Python package that uses the [XLA linear algebra compiler](https:\/\/www.tensorflow.org\/xla) to accelerate the [PyTorch deep learning framework](https:\/\/pytorch.org\/) on [Cloud TPUs](https:\/\/cloud.google.com\/tpu\/) and [Cloud TPU Pods](https:\/\/cloud.google.com\/tpu\/docs\/tutorials\/pytorch-pod). torch_xla aims to give PyTorch users the ability to do everything they can do on GPUs on Cloud TPUs as well while minimizing changes to the user experience. The project began with a conversation at NeurIPS 2017 and gathered momentum in 2018 when teams from Facebook and Google came together to create a proof of concept. We announced this collaboration at PTDC 2018 and made the PyTorch\/XLA integration broadly available at PTDC 2019. The project already has 28 contributors, nearly 2k commits, and a repo that has been forked more than 100 times. ","__index_level_0__":1615}
+{"text":"This release of [torch_xla](http:\/\/pytorch.org\/xla\/) is aligned and tested with PyTorch 1.5 to reduce friction for developers and to provide a stable and mature PyTorch\/XLA stack for training models using Cloud TPU hardware. You can [try it for free](https:\/\/medium.com\/pytorch\/get-started-with-pytorch-cloud-tpus-and-colab-a24757b8f7fc) in your browser on an 8-core Cloud TPU device with [Google Colab](https:\/\/colab.research.google.com\/), and you can use it at a much larger scaleon [Google Cloud](https:\/\/cloud.google.com\/gcp).","__index_level_0__":1616}
+{"text":"See the full torch_xla release notes [here](https:\/\/github.com\/pytorch\/xla\/releases). Full docs and tutorials can be found [here](https:\/\/pytorch.org\/xla\/) and [here](https:\/\/cloud.google.com\/tpu\/docs\/tutorials).","__index_level_0__":1617}
+{"text":"## PyTorch Domain Libraries","__index_level_0__":1618}
+{"text":"torchaudio, torchvision, and torchtext complement PyTorch with common datasets, models, and transforms in each domain area. We\u2019re excited to share new releases for all three domain libraries alongside PyTorch 1.5 and the rest of the library updates. For this release, all three domain libraries are removing support for Python2 and will support Python3 only.","__index_level_0__":1619}
+{"text":"### torchaudio 0.5\nThe torchaudio 0.5 release includes new transforms, functionals, and datasets. Highlights for the release include:","__index_level_0__":1620}
+{"text":"* Added the Griffin-Lim functional and transform, `InverseMelScale` and `Vol` transforms, and `DB_to_amplitude`. \n* Added support for `allpass`, `fade`, `bandpass`, `bandreject`, `band`, `treble`, `deemph`, and `riaa` filters and transformations.\n* New datasets added including `LJSpeech` and `SpeechCommands` datasets. ","__index_level_0__":1621}
+{"text":"See the release full notes [here](https:\/\/github.com\/pytorch\/audio\/releases) and full docs can be found [here](https:\/\/pytorch.org\/audio\/).","__index_level_0__":1622}
+{"text":"### torchvision 0.6\nThe torchvision 0.6 release includes updates to datasets, models and a significant number of bug fixes. Highlights include:","__index_level_0__":1623}
+{"text":"* Faster R-CNN now supports negative samples which allows the feeding of images without annotations at training time.\n* Added `aligned` flag to `RoIAlign` to match Detectron2. \n* Refactored abstractions for C++ video decoder","__index_level_0__":1624}
+{"text":"See the release full notes [here](https:\/\/github.com\/pytorch\/vision\/releases) and full docs can be found [here](https:\/\/pytorch.org\/docs\/stable\/torchvision\/index.html).","__index_level_0__":1625}
+{"text":"### torchtext 0.6\nThe torchtext 0.6 release includes a number of bug fixes and improvements to documentation. Based on user's feedback, dataset abstractions are currently being redesigned also. Highlights for the release include:","__index_level_0__":1626}
+{"text":"* Fixed an issue related to the SentencePiece dependency in conda package.\n* Added support for the experimental IMDB dataset to allow a custom vocab.\n* A number of documentation updates including adding a code of conduct and a deduplication of the docs on the torchtext site. ","__index_level_0__":1627}
+{"text":"Your feedback and discussions on the experimental datasets API are welcomed. You can send them to [issue #664](https:\/\/github.com\/pytorch\/text\/issues\/664). We would also like to highlight the pull request [here](https:\/\/github.com\/pytorch\/text\/pull\/701) where the latest dataset abstraction is applied to the text classification datasets. The feedback can be beneficial to finalizing this abstraction. ","__index_level_0__":1628}
+{"text":"See the release full notes [here](https:\/\/github.com\/pytorch\/text\/releases) and full docs can be found [here](https:\/\/pytorch.org\/text\/).","__index_level_0__":1629}
+{"text":"\n*We\u2019d like to thank the entire PyTorch team, the Amazon team and the community for all their contributions to this work.*","__index_level_0__":1630}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-library-updates-new-model-serving-library\/ \n category: pytorch blogs","__index_level_0__":1632}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Understanding LazyTensor System Performance with PyTorch\/XLA on Cloud TPU\"\nauthor: Vaibhav Singh\nfeatured-img: \"\"\n---","__index_level_0__":1633}
+{"text":"## Introduction","__index_level_0__":1634}
+{"text":"Ease of use, expressivity, and debuggability are among the core principles of PyTorch. One of the key drivers for the ease of use is that PyTorch execution is by default \u201ceager, i.e. op by op execution preserves the imperative nature of the program. However, eager execution does not offer the compiler based optimization, for example, the optimizations when the computation can be expressed as a graph.","__index_level_0__":1635}
+{"text":"LazyTensor [[1]], first introduced with PyTorch\/XLA, helps combine these seemingly disparate approaches. While PyTorch eager execution is widely used, intuitive, and well understood, lazy execution is not as prevalent yet.","__index_level_0__":1636}
+{"text":"In this post we will explore some of the basic concepts of the LazyTensor System with the goal of applying these concepts to understand and debug performance of LazyTensor based implementations in PyTorch. Although we will use PyTorch\/XLA on Cloud TPU as the vehicle for exploring these concepts, we hope that these ideas will be useful to understand other system(s) built on LazyTensors.","__index_level_0__":1637}
+{"text":"## LazyTensor","__index_level_0__":1638}
+{"text":"Any operation performed on a PyTorch tensor is by default dispatched as a kernel or a composition of kernels to the underlying hardware. These kernels are executed asynchronously on the underlying hardware. The program execution is not blocked until the value of a tensor is fetched. This approach scales extremely well with massively parallel programmed hardware such as GPUs.","__index_level_0__":1639}
+{"text":"The starting point of a LazyTensor system is a custom tensor type. In PyTorch\/XLA, this type is called XLA tensor. In contrast to PyTorch\u2019s native tensor type, operations performed on XLA tensors are recorded into an IR graph. Let\u2019s examine an example that sums the product of two tensors:","__index_level_0__":1640}
+{"text":"```python\nimport torch\nimport torch_xla\nimport torch_xla.core.xla_model as xm","__index_level_0__":1641}
+{"text":"dev = xm.xla_device()","__index_level_0__":1642}
+{"text":"x1 = torch.rand((3, 3)).to(dev)\nx2 = torch.rand((3, 8)).to(dev)","__index_level_0__":1643}
+{"text":"y1 = torch.einsum('bs,st->bt', x1, x2)\nprint(torch_xla._XLAC._get_xla_tensors_text([y1]))\n```","__index_level_0__":1644}
+{"text":"You can execute [this](https:\/\/github.com\/ultrons\/xla\/blob\/lazy-tensor-post\/contrib\/colab\/LazyTensor_Basics.ipynb) colab notebook to examine the resulting graph for y1. Notice that no computation has been performed yet.","__index_level_0__":1645}
+{"text":"```python\ny1 = y1 + x2\nprint(torch_xla._XLAC._get_xla_tensors_text([y1]))\n```","__index_level_0__":1646}
+{"text":"The operations will continue until PyTorch\/XLA encounters a barrier. This barrier can either be a [mark step()](https:\/\/github.com\/pytorch\/xla\/blob\/ff079bb48744e5aa6696201ccf34057f15fc7cac\/torch_xla\/core\/xla_model.py#L751) api call or any other event which forces the execution of the graph recorded so far.","__index_level_0__":1647}
+{"text":"```python\nxm.mark_step()\nprint(torch_xla._XLAC._get_xla_tensors_text([y1]))\n```","__index_level_0__":1648}
+{"text":"Once the mark_step() is called, the graph is compiled and then executed on TPU, i.e. the tensors have been materialized. Therefore, the graph is now reduced to a single line y1 tensor which holds the result of the computation.","__index_level_0__":1649}
+{"text":"### Compile Once, Execute Often","__index_level_0__":1650}
+{"text":"XLA compilation passes offer optimizations (e.g. op-fusion, which reduces HBM pressure by using scratch-pad memory for multiple ops, [ref](https:\/\/arxiv.org\/pdf\/2004.13336.pdf) ) and leverages lower level XLA infrastructure to optimally use the underlying hardware. However, there is one caveat, compilation passes are expensive, i.e. can add to the training step time. Therefore, this approach scales well if and only if we can **compile once and execute often** (compilation cache helps, such that the same graph is not compiled more than once).","__index_level_0__":1651}
+{"text":"In the following example, we create a small computation graph and time the execution:","__index_level_0__":1652}
+{"text":"```python\ny1 = torch.rand((3, 8)).to(dev)\ndef dummy_step() :\n  y1 = torch.einsum('bs,st->bt', y1, x)\n  xm.mark_step()\n  return y1\n```","__index_level_0__":1653}
+{"text":"```python\n%timeit dummy_step\n```","__index_level_0__":1654}
+{"text":"```python\nThe slowest run took 29.74 times longer than the fastest. This could mean that an intermediate result is being cached.\n10000000 loops, best of 5: 34.2 ns per loop\n```","__index_level_0__":1655}
+{"text":"You notice that the slowest step is quite longer than the fastest. This is because of the graph compilation overhead which is incurred only once for a given shape of graph, input shape, and output shape. Subsequent steps are faster because no graph compilation is necessary.","__index_level_0__":1656}
+{"text":"This also implies that we expect to see performance cliffs when the \u201ccompile once and execute often\u201d assumption breaks. Understanding when this assumption breaks is the key to understanding and optimizing the performance of a LazyTensor system. Let\u2019s examine what triggers the compilation.","__index_level_0__":1657}
+{"text":"### Graph Compilation and Execution and LazyTensor Barrier","__index_level_0__":1658}
+{"text":"We saw that the computation graph is compiled and executed when a LazyTensor barrier is encountered. There are three scenarios when the LazyTensor barrier is automatically or manually introduced. The first is the explicit call of mark_step() api as shown in the preceding example. mark_step() is also called implicitly at every step when you wrap your dataloader with MpDeviceLoader (highly recommended to overlap compute and data upload to TPU device). The [Optimizer step](https:\/\/github.com\/pytorch\/xla\/blob\/master\/torch_xla\/core\/xla_model.py#L804) method of xla_model also allows to implicitly call mark_step (when you set barrier=True).","__index_level_0__":1659}
+{"text":"The second scenario where a barrier is introduced is when PyTorch\/XLA finds an op with no mapping (lowering) to equivalent XLA HLO ops. PyTorch has [2000+](https:\/\/dev-discuss.pytorch.org\/t\/where-do-the-2000-pytorch-operators-come-from-more-than-you-wanted-to-know\/373) operations. Although most of these operations are composite (i.e. can be expressed in terms of other fundamental operations), some of these operations do not have corresponding lowering in XLA.","__index_level_0__":1660}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/unlowered-op.jpg\">\n<\/p>","__index_level_0__":1661}
+{"text":"What happens when an op with no XLA lowering is used? PyTorch XLA stops the operation recording and cuts the graph(s) leading to the input(s) of the unlowered op. This cut graph is then compiled and dispatched for execution. The results (materialized tensor) of execution are sent back from device to host, the unlowered op is then executed on the host (cpu), and then downstream LazyTensor operations creating a new graph(s) until a barrier is encountered again.","__index_level_0__":1662}
+{"text":"The third and final scenario which results in a LazyTensor barrier is when there is a control structure\/statement or another method which requires the value of a tensor. This statement would at the minimum cause the execution of the computation graph leading to the tensor (if the graph has already been seen) or cause compilation and execution of both.","__index_level_0__":1663}
+{"text":"Other examples of such methods include .item(), isEqual(). In general, any operation that maps Tensor -> Scalar will cause this behavior.","__index_level_0__":1664}
+{"text":"### Dynamic Graph","__index_level_0__":1665}
+{"text":"As illustrated in the preceding section, graph compilation cost is amortized if the same shape of the graph is executed many times. It\u2019s because the compiled graph is cached with a hash derived from the graph shape, input shape, and the output shape. If these shapes change it will trigger compilation, and too frequent compilation will result in training time degradation.","__index_level_0__":1666}
+{"text":"Let\u2019s consider the following example:","__index_level_0__":1667}
+{"text":"```python\ndef dummy_step(x, y, loss, acc=False):\n  z = torch.einsum('bs,st->bt', y, x)\n  step_loss = z.sum().view(1,)\n  if acc:\n    loss = torch.cat((loss, step_loss))\n  else:\n    loss = step_loss\n  xm.mark_step()\n  return loss","__index_level_0__":1668}
+{"text":"\nimport time\ndef measure_time(acc=False):\n  exec_times = []\n  iter_count = 100\n  x = torch.rand((512, 8)).to(dev)\n  y = torch.rand((512, 512)).to(dev)\n  loss = torch.zeros(1).to(dev)\n  for i in range(iter_count):\n    tic = time.time()\n    loss = dummy_step(x, y, loss, acc=acc)\n    toc = time.time()\n    exec_times.append(toc - tic)\n  return exec_times","__index_level_0__":1669}
+{"text":"dyn = measure_time(acc=True) # acc= True Results in dynamic graph\nst = measure_time(acc=False) # Static graph, computation shape, inputs and output shapes don't change","__index_level_0__":1670}
+{"text":"import matplotlib.pyplot as plt\nplt.plot(st, label = 'static graph')\nplt.plot(dyn, label = 'dynamic graph')\nplt.legend()\nplt.title('Execution time in seconds')\n```","__index_level_0__":1671}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/executiontimegraph.jpg\" width=\"60%\">\n<\/p>","__index_level_0__":1672}
+{"text":"Note that static and dynamic cases have the same computation but dynamic graph compiles every time, leading to the higher overall run-time. In practice, the training step with recompilation can sometimes be an order of magnitude or slower. In the next section we discuss some of the PyTorch\/XLA tools to debug training degradation.","__index_level_0__":1673}
+{"text":"### Profiling Training Performance with PyTorch\/XLA","__index_level_0__":1674}
+{"text":"PyTorch\/XLA profiling consists of two major components. First is the client side profiling. This feature is turned on by simply setting the environment variable PT_XLA_DEBUG to 1. Client side profiling points to unlowered ops or device-to-host transfer in your source code. Client side profiling also reports if there are too frequent compilations happening during the training. You can explore some metrics and counters provided by PyTorch\/XLA in conjunction with the profiler in [this](https:\/\/github.com\/ultrons\/xla\/blob\/lazy-tensor-post\/contrib\/colab\/Exploring_LazyTensor_with_Debug_Metrics.ipynb) notebook.","__index_level_0__":1675}
+{"text":"The second component offered by PyTorch\/XLA profiler is the inline trace annotation. For example:","__index_level_0__":1676}
+{"text":"```python\nimport torch_xla.debug.profiler as xp","__index_level_0__":1677}
+{"text":"def train_imagenet():\n  print('==> Preparing data..')\n  img_dim = get_model_property('img_dim')\n  ....\n  server = xp.start_server(3294)\n  def train_loop_fn(loader, epoch):\n    ....\n    model.train()\n    for step, (data, target) in enumerate(loader):\n      with xp.StepTrace('Train_Step', step_num=step):\n        ....\n        if FLAGS.amp:\n        ....\n        else:\n          with xp.Trace('build_graph'):\n            output = model(data)\n            loss = loss_fn(output, target)\n            loss.backward()\n          xm.optimizer_step(optimizer)\n```","__index_level_0__":1678}
+{"text":"Notice the start_server api call. The port number that you have used here is the same port number you will use with the tensorboard profiler in order to view the op trace similar to:","__index_level_0__":1679}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/port-numbers.png\" width=\"100%\">\n<\/p>","__index_level_0__":1680}
+{"text":"Op trace along with the client-side debugging function is a powerful set of tools to debug and optimize your training performance with PyTorch\/XLA. For more detailed instructions on the profiler usage, the reader is encouraged to explore blogs [part-1](https:\/\/cloud.google.com\/blog\/topics\/developers-practitioners\/pytorchxla-performance-debugging-tpu-vm-part-1), [part-2](https:\/\/cloud.google.com\/blog\/topics\/developers-practitioners\/pytorchxla-performance-debugging-cloud-tpu-vm-part-ii), and [part-3](https:\/\/cloud.google.com\/blog\/topics\/developers-practitioners\/pytorchxla-performance-debugging-cloud-tpu-vm-part-iii) of the blog series on PyTorch\/XLA performance debugging.","__index_level_0__":1681}
+{"text":"### Summary","__index_level_0__":1682}
+{"text":"In this article we have reviewed the fundamentals of the LazyTensor system. We built on those fundamentals with PyTorch\/XLA to understand the potential causes of training performance degradation. We discussed why \u201ccompile once and execute often\u201d helps to get the best performance on LazyTensor systems, and why training slows down when this assumption breaks.","__index_level_0__":1683}
+{"text":"We hope that PyTorch users will find these insights helpful for their novel works with LazyTensor systems.","__index_level_0__":1684}
+{"text":"### Acknowledgements","__index_level_0__":1685}
+{"text":"A big thank you to my outstanding colleagues Jack Cao, Milad Mohammedi, Karl Weinmeister, Rajesh Thallam, Jordan Tottan (Google) and Geeta Chauhan (Meta) for their meticulous reviews and feedback. And thanks to the extended PyTorch\/XLA development team from Google, Meta, and the open source community to make PyTorch possible on TPUs. And finally, thanks to the authors of the [LazyTensor paper](https:\/\/arxiv.org\/pdf\/2102.13267.pdf) not only for developing LazyTensor but also for writing such an accessible paper.","__index_level_0__":1686}
+{"text":"## Refrences","__index_level_0__":1687}
+{"text":"[[1]] LazyTensor: combining eager execution with domain-specific compilers","__index_level_0__":1688}
+{"text":"[1]: https:\/\/arxiv.org\/pdf\/2102.13267.pdf\n \n source: https:\/\/pytorch.org\/blog\/understanding-lazytensor-system-performance-with-pytorch-xla-on-cloud-tpu\/ \n category: pytorch blogs","__index_level_0__":1689}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Extending TorchVision\u2019s Transforms to Object Detection, Segmentation & Video tasks\"\nauthor: Philip Meier, Victor Fomin, Vasilis Vryniotis, Nicolas Hug\nfeatured-img: \"assets\/images\/Transforms-v2-feature-image.png\"\n---","__index_level_0__":1690}
+{"text":"**Note**: A previous version of this post was published in November 2022. We have updated this post with the most up-to-date info, in view of the upcoming 0.15 release of torchvision in March 2023, jointly with PyTorch 2.0.","__index_level_0__":1691}
+{"text":"TorchVision is extending its Transforms API! Here is what\u2019s new:","__index_level_0__":1692}
+{"text":"- You can use them not only for Image Classification but also for Object Detection, Instance & Semantic Segmentation and Video Classification.\n- You can use new functional transforms for transforming Videos, Bounding Boxes and Segmentation Masks.","__index_level_0__":1693}
+{"text":"\nThe API is completely backward compatible with the previous one, and remains the same to assist the migration and adoption. We are now releasing this new API as Beta in the torchvision.transforms.v2 namespace, and we would love to get early feedback from you to improve its functionality. Please [_reach out to us_](https:\/\/github.com\/pytorch\/vision\/issues\/6753) if you have any questions or suggestions.","__index_level_0__":1694}
+{"text":"## Limitations of current Transforms","__index_level_0__":1695}
+{"text":"The existing Transforms API of TorchVision (aka V1) only supports single images. As a result it can only be used for classification tasks:","__index_level_0__":1696}
+{"text":"```python\nfrom torchvision import transforms\ntrans = transforms.Compose([\n   transforms.ColorJitter(contrast=0.5),\n   transforms.RandomRotation(30),\n   transforms.CenterCrop(480),\n])\nimgs = trans(imgs)\n```","__index_level_0__":1697}
+{"text":"The above approach doesn\u2019t support Object Detection nor Segmentation. This limitation made any non-classification Computer Vision tasks second-class citizens as one couldn\u2019t use the Transforms API to perform the necessary augmentations. Historically this made it difficult to train high-accuracy models using TorchVision\u2019s primitives and thus our Model Zoo lagged by several points from SoTA.","__index_level_0__":1698}
+{"text":"To circumvent this limitation, TorchVision offered [_custom implementations_](https:\/\/github.com\/pytorch\/vision\/blob\/main\/references\/detection\/transforms.py) in its reference scripts that show-cased how one could perform augmentations in each task. Though this practice enabled us to train high accuracy [_classification_](https:\/\/pytorch.org\/blog\/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives\/), [_object detection & segmentation_](https:\/\/pytorch.org\/blog\/pytorch-1.12-new-library-releases\/#beta-object-detection-and-instance-segmentation) models, it was a hacky approach which made those transforms impossible to import from the TorchVision binary.","__index_level_0__":1699}
+{"text":"## The new Transforms API","__index_level_0__":1700}
+{"text":"The Transforms V2 API supports videos, bounding boxes, and segmentation masks meaning that it offers native support for many Computer Vision tasks. The new solution is a drop-in replacement:","__index_level_0__":1701}
+{"text":"```python\nimport torchvision.transforms.v2 as transforms","__index_level_0__":1702}
+{"text":"# Exactly the same interface as V1:\ntrans = transforms.Compose([\n    transforms.ColorJitter(contrast=0.5),\n    transforms.RandomRotation(30),\n    transforms.CenterCrop(480),\n])\nimgs, bboxes, labels = trans(imgs, bboxes, labels)\n```","__index_level_0__":1703}
+{"text":"The new Transform Classes can receive any arbitrary number of inputs without enforcing specific order or structure:","__index_level_0__":1704}
+{"text":"```python\n# Already supported:\ntrans(imgs)  # Image Classification\ntrans(videos)  # Video Tasks\ntrans(imgs, bboxes, labels)  # Object Detection\ntrans(imgs, bboxes, masks, labels)  # Instance Segmentation\ntrans(imgs, masks)  # Semantic Segmentation\ntrans({\"image\": imgs, \"box\": bboxes, \"tag\": labels})  # Arbitrary Structure","__index_level_0__":1705}
+{"text":"# Future support:\ntrans(imgs, bboxes, labels, keypoints)  # Keypoint Detection\ntrans(stereo_images, disparities, masks)  # Depth Perception\ntrans(image1, image2, optical_flows, masks)  # Optical Flow\ntrans(imgs_or_videos, labels)  # MixUp\/CutMix-style Transforms\n```","__index_level_0__":1706}
+{"text":"The Transform Classes make sure that they apply the same random transforms to all the inputs to ensure consistent results.","__index_level_0__":1707}
+{"text":"The functional API has been updated to support all necessary signal processing kernels (resizing, cropping, affine transforms, padding etc) for all inputs:","__index_level_0__":1708}
+{"text":"```python\nfrom torchvision.transforms.v2 import functional as F","__index_level_0__":1709}
+{"text":"\n# High-level dispatcher, accepts any supported input type, fully BC\nF.resize(inpt, size=[224, 224])\n# Image tensor kernel\nF.resize_image_tensor(img_tensor, size=[224, 224], antialias=True) \n# PIL image kernel\nF.resize_image_pil(img_pil, size=[224, 224], interpolation=BILINEAR)\n# Video kernel\nF.resize_video(video, size=[224, 224], antialias=True) \n# Mask kernel\nF.resize_mask(mask, size=[224, 224])\n# Bounding box kernel\nF.resize_bounding_box(bbox, size=[224, 224], spatial_size=[256, 256])\n```","__index_level_0__":1710}
+{"text":"Under the hood, the API uses Tensor subclassing to wrap the input, attach useful meta-data and dispatch to the right kernel. For your data to be compatible with these new transforms, you can either use the provided dataset wrapper which should work with most of torchvision built-in datasets, or your can wrap your data manually into Datapoints:","__index_level_0__":1711}
+{"text":"```python\nfrom torchvision.datasets import wrap_dataset_for_transforms_v2\nds = CocoDetection(..., transforms=v2_transforms)\nds = wrap_dataset_for_transforms_v2(ds) # data is now compatible with transforms v2!","__index_level_0__":1712}
+{"text":"# Or wrap your data manually using the lower-level Datapoint classes:\nfrom torchvision import datapoints","__index_level_0__":1713}
+{"text":"imgs = datapoints.Image(images)\nvids = datapoints.Video(videos)\nmasks = datapoints.Mask(target[\"masks\u201c])\nbboxes = datapoints.BoundingBox(target[\"boxes\u201c], format=\u201dXYXY\u201d, spatial_size=imgs.shape)\n```","__index_level_0__":1714}
+{"text":"\nIn addition to the new API, we now provide importable implementations for several data augmentations that are used in SoTA research such as [_Large Scale Jitter_](https:\/\/github.com\/pytorch\/vision\/blob\/928b05cad36eadb13e169f03028767c8bcd1f21d\/torchvision\/transforms\/v2\/_geometry.py#L1109), [_AutoAugmentation_](https:\/\/github.com\/pytorch\/vision\/blob\/main\/torchvision\/transforms\/v2\/_auto_augment.py) methods and [_several_](https:\/\/github.com\/pytorch\/vision\/blob\/main\/torchvision\/transforms\/v2\/__init__.py) new Geometric, Color and Type Conversion transforms.","__index_level_0__":1715}
+{"text":"The API continues to support both PIL and Tensor backends for Images, single or batched input and maintains JIT-scriptability on both the functional and class APIs.. The new API has been [_verified_](https:\/\/github.com\/pytorch\/vision\/pull\/6433#issuecomment-1256741233) to achieve the same accuracy as the previous implementation.","__index_level_0__":1716}
+{"text":"## An end-to-end example","__index_level_0__":1717}
+{"text":" Here is an example of the new API using the following [_image_](https:\/\/user-images.githubusercontent.com\/5347466\/195350223-8683ef25-1367-4292-9174-c15f85c7358e.jpg). It works both with PIL images and Tensors. For more examples and tutorials, [_take a look at our gallery!_](https:\/\/pytorch.org\/vision\/0.15\/auto_examples\/index.html)","__index_level_0__":1718}
+{"text":"\n```python\nfrom torchvision import io, utils\nfrom torchvision import datapoints\nfrom torchvision.transforms import v2 as T\nfrom torchvision.transforms.v2 import functional as F","__index_level_0__":1719}
+{"text":"# Defining and wrapping input to appropriate Tensor Subclasses\npath = \"COCO_val2014_000000418825.jpg\"\nimg = datapoints.Image(io.read_image(path))\n# img = PIL.Image.open(path)\nbboxes = datapoints.BoundingBox(\n    [[2, 0, 206, 253], [396, 92, 479, 241], [328, 253, 417, 332],\n     [148, 68, 256, 182], [93, 158, 170, 260], [432, 0, 438, 26],\n     [422, 0, 480, 25], [419, 39, 424, 52], [448, 37, 456, 62],\n     [435, 43, 437, 50], [461, 36, 469, 63], [461, 75, 469, 94],\n     [469, 36, 480, 64], [440, 37, 446, 56], [398, 233, 480, 304],\n     [452, 39, 463, 63], [424, 38, 429, 50]],\n    format=datapoints.BoundingBoxFormat.XYXY,\n    spatial_size=F.get_spatial_size(img),\n)\nlabels = [59, 58, 50, 64, 76, 74, 74, 74, 74, 74, 74, 74, 74, 74, 50, 74, 74]\n# Defining and applying Transforms V2\ntrans = T.Compose(\n    [\n        T.ColorJitter(contrast=0.5),\n        T.RandomRotation(30),\n        T.CenterCrop(480),\n    ]\n)\nimg, bboxes, labels = trans(img, bboxes, labels)\n# Visualizing results\nviz = utils.draw_bounding_boxes(F.to_image_tensor(img), boxes=bboxes)\nF.to_pil_image(viz).show()\n```","__index_level_0__":1720}
+{"text":"## Development milestones and future work","__index_level_0__":1721}
+{"text":"Here is where we are in development:","__index_level_0__":1722}
+{"text":"- [x] Design API\n- [x] Write Kernels for transforming Videos, Bounding Boxes, Masks and Labels\n- [x] Rewrite all existing Transform Classes (stable + references) on the new API:\n  - [x] Image Classification\n  - [x] Video Classification\n  - [x] Object Detection\n  - [x] Instance Segmentation\n  - [x] Semantic Segmentation\n- [x] Verify the accuracy of the new API for all supported Tasks and Backends\n- [x] Speed Benchmarks and Performance Optimizations (in progress - planned for Dec)\n- [x] Graduate from Prototype (planned for Q1)\n- [ ] Add support of Depth Perception, Keypoint Detection, Optical Flow and more (future)\n- [ ] Add smooth support for batch-wise transforms like MixUp and CutMix","__index_level_0__":1723}
+{"text":"\nWe would love to get [_feedback_](https:\/\/github.com\/pytorch\/vision\/issues\/6753) from you to improve its functionality. Please reach out to us if you have any questions or suggestions.\n \n source: https:\/\/pytorch.org\/blog\/extending-torchvisions-transforms-to-object-detection-segmentation-and-video-tasks\/ \n category: pytorch blogs","__index_level_0__":1724}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"New Library Updates in PyTorch 1.13\"\nauthor: Team PyTorch\nfeatured-img: \"assets\/images\/new-library-updates-in-pytorch-1.13-2.jpg\"\n---","__index_level_0__":1725}
+{"text":"We are bringing a number of improvements to the current PyTorch libraries, alongside the PyTorch 1.13 [release](https:\/\/github.com\/pytorch\/pytorch\/releases). These updates demonstrate our focus on developing common and extensible APIs across all domains to make it easier for our community to build ecosystem projects on PyTorch.","__index_level_0__":1727}
+{"text":"Along with **1.13**, we are releasing updates to the PyTorch Libraries, please find them below.","__index_level_0__":1728}
+{"text":"### TorchAudio ","__index_level_0__":1729}
+{"text":"#### (Beta) Hybrid Demucs Model and Pipeline","__index_level_0__":1730}
+{"text":"Hybrid Demucs is a music source separation model that uses both spectrogram and time domain features. It has demonstrated state-of-the-art performance in the Sony<sup>\u00ae<\/sup> Music DeMixing Challenge. (citation: [https:\/\/arxiv.org\/abs\/2111.03600](https:\/\/arxiv.org\/abs\/2111.03600))","__index_level_0__":1731}
+{"text":"The TorchAudio v0.13 release includes the following features","__index_level_0__":1732}
+{"text":"- MUSDB_HQ Dataset, which is used in Hybrid Demucs training ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.MUSDB_HQ.html#torchaudio.datasets.MUSDB_HQ))\n- Hybrid Demucs model architecture ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.models.HDemucs.html#torchaudio.models.HDemucs))\n- Three factory functions suitable for different sample rate ranges\n- Pre-trained pipelines ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/pipelines.html#id46))\n- SDR Results of pre-trained pipelines on MUSDB_HQ test set\n- Tutorial that steps through music source separation using the pretrained pipeline ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/tutorials\/hybrid_demucs_tutorial.html))","__index_level_0__":1733}
+{"text":"| Pipeline                               |  All  | Drums |  Bass  | Other | Vocals |\n|----------------------------------------|-------|-------|--------|-------|--------|\n| <em>HDEMUCS_HIGH_MUSDB*<\/em>           |  6.42 |  7.76 |   6.51 |  4.47 |   6.93 |\n| <em>HDEMUCS_HIGH_MUSDB_PLUS**<\/em>     |  9.37 | 11.38 |  10.53 |  7.24 |   8.32 |","__index_level_0__":1734}
+{"text":"<p><small>* Trained on the training data of MUSDB-HQ dataset.<br\/>** Trained on both training and test sets of MUSDB-HQ and 150 extra songs from an internal database that were specifically produced for Meta.<\/small><\/p>","__index_level_0__":1735}
+{"text":"```python\nfrom torchaudio.pipelines import HDEMUCS_HIGH_MUSDB_PLUS","__index_level_0__":1736}
+{"text":"bundle = HDEMUCS_HIGH_MUSDB_PLUS\nmodel = bundle.get_model()\nsources_list = model.sources","__index_level_0__":1737}
+{"text":"mixture, samplerate = torchaudio.load(\"song.wav\")\nsources = model(mixture)\naudios = dict(zip(sources_list, sources)\n```","__index_level_0__":1738}
+{"text":"Special thanks to Alexandre Defossez for the guidance.","__index_level_0__":1739}
+{"text":"#### (Beta) Datasets and Metadata Mode for SUPERB Benchmark","__index_level_0__":1740}
+{"text":"TorchAudio adds support for various audio-related datasets used in downstream tasks for benchmarking self-supervised learning models. With the addition of several new datasets, there is now support for the downstream tasks in version 1 of the [SUPERB benchmark](https:\/\/superbbenchmark.org\/), which can be found in the [s3prl repository](https:\/\/github.com\/s3prl\/s3prl\/blob\/master\/s3prl\/downstream\/docs\/superb.md).","__index_level_0__":1741}
+{"text":"For these datasets, we also add metadata support through a `get_metadata` function, enabling faster dataset iteration or preprocessing without the need to load waveforms. The function returns the same features as `__getitem__`, except it returns the relative waveform path rather than the loaded waveform.","__index_level_0__":1742}
+{"text":"Datasets with metadata functionality","__index_level_0__":1743}
+{"text":"- LIBRISPEECH ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.LIBRISPEECH.html#torchaudio.datasets.LIBRISPEECH))\n- LibriMix ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.LibriMix.html#torchaudio.datasets.LibriMix))\n- QUESST14 ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.QUESST14.html#torchaudio.datasets.QUESST14))\n- SPEECHCOMMANDS ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.SPEECHCOMMANDS.html#torchaudio.datasets.SPEECHCOMMANDS))\n- (new) FluentSpeechCommands ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.FluentSpeechCommands.html#torchaudio.datasets.FluentSpeechCommands))\n- (new) Snips ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.Snips.html#torchaudio.datasets.Snips))\n- (new) IEMOCAP ([docs](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.IEMOCAP.html#torchaudio.datasets.IEMOCAP))\n- (new) VoxCeleb1 ([Identification](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.VoxCeleb1Identification.html#torchaudio.datasets.VoxCeleb1Identification), [Verification](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.datasets.VoxCeleb1Verification.html#torchaudio.datasets.VoxCeleb1Verification))","__index_level_0__":1744}
+{"text":"#### (Beta) Custom Language Model support in CTC Beam Search Decoding","__index_level_0__":1745}
+{"text":"TorchAudio released a CTC beam search decoder in release 0.12, with KenLM language model support. This release, there is added functionality for creating custom Python language models that are compatible with the decoder, using the `torchaudio.models.decoder.CTCDecoderLM` wrapper.","__index_level_0__":1746}
+{"text":"For more information on using a custom language model, please refer to the [documentation](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.models.decoder.CTCDecoder.html#ctcdecoderlm) and [tutorial](https:\/\/pytorch.org\/audio\/0.13.0\/tutorials\/asr_inference_with_ctc_decoder_tutorial.html#custom-language-model).","__index_level_0__":1747}
+{"text":"#### (Beta) StreamWriter","__index_level_0__":1748}
+{"text":"torchaudio.io.StreamWriter is a class for encoding media including audio and video. This can handle a wide variety of codecs, chunk-by-chunk encoding and GPU encoding.","__index_level_0__":1749}
+{"text":"```python\nwriter = StreamWriter(\"example.mp4\")\nwriter.add_audio_stream(\n    sample_rate=16_000,\n    num_channels=2,\n)\nwriter.add_video_stream(\n    frame_rate=30,\n    height=96,\n    width=128,\n    format=\"rgb24\",\n)\nwith writer.open():\n    writer.write_audio_chunk(0, audio)\n    writer.write_video_chunk(1, video)\n```","__index_level_0__":1750}
+{"text":"For more information, refer to [the documentation](https:\/\/pytorch.org\/audio\/0.13.0\/generated\/torchaudio.io.StreamWriter.html) and the following tutorials\n- [StreamWriter Basic Usage](https:\/\/pytorch.org\/audio\/0.13.0\/tutorials\/streamwriter_basic_tutorial.html)\n- [StreamWriter Advanced Usage](https:\/\/pytorch.org\/audio\/0.13.0\/tutorials\/streamwriter_advanced.html)\n- [Hardware-Accelerated Video Decoding and Encoding](https:\/\/pytorch.org\/audio\/0.13.0\/hw_acceleration_tutorial.html)","__index_level_0__":1751}
+{"text":"### TorchData","__index_level_0__":1752}
+{"text":"For a complete list of changes and new features, please visit [our repository\u2019s 0.5.0 release note](https:\/\/github.com\/pytorch\/data\/releases).","__index_level_0__":1753}
+{"text":"#### (Prototype) DataLoader2","__index_level_0__":1754}
+{"text":"`DataLoader2` was introduced in the last release to execute `DataPipe` graph, with support for dynamic sharding for multi-process\/distributed data loading, multiple backend ReadingServices, and `DataPipe` graph in-place modification (e.g. shuffle control).","__index_level_0__":1755}
+{"text":"In this release, we further consolidated the API for `DataLoader2` and a [detailed documentation is now available here](https:\/\/pytorch.org\/data\/0.5\/dataloader2.html). We continue to welcome early adopters and feedback, as well as potential contributors. If you are interested in trying it out, we encourage you to install the nightly version of TorchData.","__index_level_0__":1756}
+{"text":"#### (Beta) Data Loading from Cloud Service Providers","__index_level_0__":1757}
+{"text":"We extended our support to load data from additional cloud storage providers via DataPipes, now covering AWS, Google Cloud Storage, and Azure. A [tutorial is also available](https:\/\/pytorch.org\/data\/0.5\/tutorial.html#working-with-cloud-storage-providers). We are open to feedback and feature requests.","__index_level_0__":1758}
+{"text":"We also performed a simple benchmark, comparing the performance of data loading from AWS S3 and attached volume on an AWS EC2 instance. The results are [visible here](https:\/\/github.com\/pytorch\/data\/blob\/gh\/NivekT\/100\/head\/benchmarks\/cloud\/aws_s3_results.md).","__index_level_0__":1759}
+{"text":"### torch::deploy (Beta)","__index_level_0__":1760}
+{"text":"torch::deploy is now in Beta! torch::deploy is a C++ library for Linux based operating systems that allows you to run multiple Python interpreters in a single process. You can run your existing eager PyTorch models without any changes for production inference use cases. Highlights include: ","__index_level_0__":1761}
+{"text":"- Existing models work out of the box\u2013no need to modify your python code to support tracing.\n- Full support for your existing Python environment including C extensions.\n- No need to cross process boundaries to load balance in multi-GPU serving environments.\n- Model weight can be shared between multiple Python interpreters.\n- A vastly improved installation and setup process.","__index_level_0__":1762}
+{"text":"```Python\ntorch::deploy::InterpreterManager manager(4);","__index_level_0__":1763}
+{"text":"\/\/ access one of the 4 interpreters\nauto I = manager.acquireOne();","__index_level_0__":1764}
+{"text":"\/\/ run infer from your_model.py\nI.global(\"your_model\", \"infer\")({at::randn({10, 240, 320})});\n```","__index_level_0__":1765}
+{"text":"Learn more [here](https:\/\/github.com\/pytorch\/multipy).","__index_level_0__":1766}
+{"text":"#### (Beta) CUDA\/ROCm\/CPU Backends","__index_level_0__":1767}
+{"text":"torch::deploy now links against standard PyTorch Python distributions so all accelerators that PyTorch core supports such as CUDA and AMD\/HIP work out of the box.","__index_level_0__":1768}
+{"text":"- Can install any device variant of PyTorch via pip\/conda like normal.\n- [https:\/\/pytorch.org\/get-started\/locally\/](https:\/\/pytorch.org\/get-started\/locally\/)","__index_level_0__":1769}
+{"text":"#### (Prototype) aarch64\/arm64 support","__index_level_0__":1770}
+{"text":"torch::deploy now has basic support for aarch64 Linux systems.","__index_level_0__":1771}
+{"text":"- We're looking to gather feedback on it and learn more about arm use cases for eager PyTorch models.\n- Learn more \/ share your use case at [https:\/\/github.com\/pytorch\/multipy\/issues\/64](https:\/\/github.com\/pytorch\/multipy\/issues\/64)","__index_level_0__":1772}
+{"text":"### TorchEval","__index_level_0__":1773}
+{"text":"#### (Prototype) Introducing Native Metrics Support for PyTorch","__index_level_0__":1774}
+{"text":"TorchEval is a library built for users who want highly performant implementations of common metrics to evaluate machine learning models. It also provides an easy to use interface for building custom metrics with the same toolkit. Building your metrics with TorchEval makes running distributed training loops with [torch.distributed](https:\/\/pytorch.org\/docs\/stable\/distributed.html) a breeze.","__index_level_0__":1775}
+{"text":"Learn more with our [docs](https:\/\/pytorch.org\/torcheval), see our [examples](https:\/\/pytorch.org\/torcheval\/metric_example.html), or check out our [GitHub repo](http:\/\/github.com\/pytorch\/torcheval).","__index_level_0__":1776}
+{"text":"### TorchMultimodal Release (Beta)","__index_level_0__":1777}
+{"text":"Please watch for upcoming blogs in early November that will introduce TorchMultimodal, a PyTorch domain library for training SoTA multi-task multimodal models at scale, in more details; in the meantime, play around with the library and models through our [tutorial](https:\/\/pytorch.org\/tutorials\/beginner\/flava_finetuning_tutorial.html).","__index_level_0__":1778}
+{"text":"### TorchRec","__index_level_0__":1779}
+{"text":"#### (Prototype) Simplified Optimizer Fusion APIs","__index_level_0__":1780}
+{"text":"We\u2019ve provided a simplified and more intuitive API for setting fused optimizer settings via apply_optimizer_in_backward. This new approach enables the ability to specify optimizer settings on a per-parameter basis and sharded modules will configure [FBGEMM\u2019s TableBatchedEmbedding modules accordingly](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/fbgemm_gpu\/split_table_batched_embeddings_ops.py#L181). Additionally, this now let's TorchRec\u2019s planner account for optimizer memory usage. This should alleviate reports of sharding jobs OOMing after using Adam using a plan generated from planner.","__index_level_0__":1781}
+{"text":"#### (Prototype) Simplified Sharding APIs","__index_level_0__":1782}
+{"text":"We\u2019re introducing the shard API, which now allows you to shard only the embedding modules within a model, and provides an alternative to the current main entry point - DistributedModelParallel. This lets you have a finer grained control over the rest of the model, which can be useful for customized parallelization logic, and inference use cases (which may not require any parallelization on the dense layers). We\u2019re also introducing construct_module_sharding_plan, providing a simpler interface to the TorchRec sharder.","__index_level_0__":1783}
+{"text":"#### (Beta) Quantized Comms","__index_level_0__":1784}
+{"text":"Applying [quantization or mixed precision](https:\/\/dlp-kdd.github.io\/assets\/pdf\/a11-yang.pdf) to tensors in a collective call during model parallel training greatly improves training efficiency, with little to no effect on model quality. TorchRec now integrates with the [quantized comms library provided by FBGEMM GPU](https:\/\/github.com\/pytorch\/FBGEMM\/blob\/main\/fbgemm_gpu\/fbgemm_gpu\/quantize_comm.py) and provides an interface to construct encoders and decoders (codecs) that surround the all_to_all, and reduce_scatter collective calls in the output_dist of a sharded module. We also allow you to construct your own codecs to apply to your sharded module. The codces provided by FBGEMM allow FP16, BF16, FP8, and INT8 compressions, and you may use different quantizations for the forward pass and backward pass.","__index_level_0__":1785}
+{"text":"### TorchSnapshot (Beta)","__index_level_0__":1786}
+{"text":"Along with PyTorch 1.13, we are releasing the beta version of TorchSnapshot, which is a performant, memory-efficient checkpointing library for PyTorch applications, designed with large, complex distributed workloads in mind. Highlights include:","__index_level_0__":1787}
+{"text":"- Performance: TorchSnapshot provides a fast checkpointing implementation employing various optimizations, including zero-copy serialization for most tensor types, overlapped device-to-host copy and storage I\/O, parallelized storage I\/O\n- Memory Use: TorchSnapshot's memory usage adapts to the host's available resources, greatly reducing the chance of out-of-memory issues when saving and loading checkpoints\n- Usability: Simple APIs that are consistent between distributed and non-distributed workloads","__index_level_0__":1788}
+{"text":"Learn more with our [tutorial](https:\/\/pytorch.org\/torchsnapshot\/main\/getting_started.html).","__index_level_0__":1789}
+{"text":"### TorchVision ","__index_level_0__":1790}
+{"text":"We are happy to introduce torchvision v0.14 [(release note)](https:\/\/github.com\/pytorch\/vision\/releases). This version introduces a new [model registration API](https:\/\/pytorch.org\/blog\/easily-list-and-initialize-models-with-new-apis-in-torchvision\/) to help users retrieving and listing models and weights. It also includes new image and video classification models such as MViT, S3D, Swin Transformer V2, and MaxViT. Last but not least, we also have new primitives and augmentation such as PolynomicalLR scheduler and SimpleCopyPaste.","__index_level_0__":1791}
+{"text":"#### (Beta) Model Registration API","__index_level_0__":1792}
+{"text":"Following up on the [multi-weight support API](https:\/\/pytorch.org\/blog\/introducing-torchvision-new-multi-weight-support-api\/) that was released on the previous version, we have added a new [model registration API](https:\/\/pytorch.org\/blog\/easily-list-and-initialize-models-with-new-apis-in-torchvision\/) to help users retrieve models and weights. There are now 4 new methods under the torchvision.models module: get_model, get_model_weights, get_weight, and list_models. Here are examples of how we can use them:","__index_level_0__":1793}
+{"text":"```Python\nimport torchvision\nfrom torchvision.models import get_model, get_model_weights, list_models","__index_level_0__":1794}
+{"text":"\nmax_params = 5000000","__index_level_0__":1795}
+{"text":"tiny_models = []\nfor model_name in list_models(module=torchvision.models):\n    weights_enum = get_model_weights(model_name)\n    if len([w for w in weights_enum if w.meta[\"num_params\"] <= max_params]) > 0:\n        tiny_models.append(model_name)","__index_level_0__":1796}
+{"text":"print(tiny_models)\n# ['mnasnet0_5', 'mnasnet0_75', 'mnasnet1_0', 'mobilenet_v2', ...]","__index_level_0__":1797}
+{"text":"model = get_model(tiny_models[0], weights=\"DEFAULT\")\nprint(sum(x.numel() for x in model.state_dict().values()))\n# 2239188\n```","__index_level_0__":1798}
+{"text":"#### (Beta) New Video Classification Models","__index_level_0__":1799}
+{"text":"We added two new video classification models, MViT and S3D. MViT is a state of the art video classification transformer model which has 80.757% accuracy on the Kinetics400 dataset, while S3D is a relatively small model with good accuracy for its size. These models can be used as follows:","__index_level_0__":1800}
+{"text":"```Python\nimport torch\nfrom torchvision.models.video import *","__index_level_0__":1801}
+{"text":"video = torch.rand(3, 32, 800, 600)\nmodel = mvit_v2_s(weights=\"DEFAULT\")\n# model = s3d(weights=\"DEFAULT\")\nmodel.eval()\nprediction = model(images)\n```","__index_level_0__":1802}
+{"text":"Here is the table showing the accuracy of the new video classification models tested in the Kinetics400 dataset.","__index_level_0__":1803}
+{"text":"| **Model**                      | **Acc@1** | **Acc@5** |\n|--------------------------------|-----------|-----------|\n| mvit_v1_b                      |    81.474 |    95.776 |\n| mvit_v2_s                      |    83.196 |     96.36 |\n| s3d                            |    83.582 |     96.64 |","__index_level_0__":1804}
+{"text":"We would like to thank Haoqi Fan, Yanghao Li, Christoph Feichtenhofer and Wan-Yen Lo for their work on [PyTorchVideo](https:\/\/github.com\/facebookresearch\/pytorchvideo\/) and their support during the development of the MViT model. We would like to thank Sophia Zhi for her contribution implementing the S3D model in torchvision.","__index_level_0__":1805}
+{"text":"#### (Stable) New Architecture and Model Variants","__index_level_0__":1806}
+{"text":"For Classification Models, we\u2019ve added the Swin Transformer V2 architecture along with pre-trained weights for its tiny\/small\/base variants. In addition, we have added support for the MaxViT transformer. Here is an example on how to use the models:","__index_level_0__":1807}
+{"text":"```Python\nimport torch\nfrom torchvision.models import *","__index_level_0__":1808}
+{"text":"image = torch.rand(1, 3, 224, 224)\nmodel = swin_v2_t(weights=\"DEFAULT\").eval()\n# model = maxvit_t(weights=\"DEFAULT\").eval()\nprediction = model(image)\n```","__index_level_0__":1809}
+{"text":"Here is the table showing the accuracy of the models tested on ImageNet1K dataset.","__index_level_0__":1810}
+{"text":"| **Model**     | **Acc@1** | **Acc@1 change over V1** | **Acc@5** | **Acc@5 change over V1** |\n|---------------|-----------|--------------------------|-----------|--------------------------|\n| swin_v2_t     |    82.072 |                  + 0.598 |    96.132 |                  + 0.356 |\n| swin_v2_s     |    83.712 |                  + 0.516 |    96.816 |                  + 0.456 |\n| swin_v2_b     |    84.112 |                  + 0.530 |    96.864 |                  + 0.224 |\n| maxvit_t      |    83.700 |                    -     |    96.722 |                    -     |","__index_level_0__":1811}
+{"text":"We would like to thank [Ren Pang](https:\/\/github.com\/ain-soph) and [Teodor Poncu](https:\/\/github.com\/TeodorPoncu) for contributing the 2 models to torchvision.","__index_level_0__":1812}
+{"text":"### (Stable) New Primitives & Augmentations","__index_level_0__":1813}
+{"text":"In this release we\u2019ve added the [SimpleCopyPaste](https:\/\/arxiv.org\/abs\/2012.07177) augmentation in our reference scripts and we up-streamed the PolynomialLR scheduler to PyTorch Core. We would like to thank [Lezwon Castelino](https:\/\/github.com\/lezwon) and [Federico Pozzi](https:\/\/github.com\/federicopozzi33) for their contributions. We are continuing our efforts to modernize TorchVision by adding more SoTA primitives, Augmentations and architectures with the help of our community. If you are interested in contributing, have a look at the following [issue](https:\/\/github.com\/pytorch\/vision\/issues\/6323).","__index_level_0__":1814}
+{"text":"### Torch-TensorRT","__index_level_0__":1815}
+{"text":"#### (Prototype) TensorRT with FX2TRT frontend","__index_level_0__":1816}
+{"text":"Torch-TensorRT is the PyTorch integration for TensorRT, providing high performance inference on NVIDIA GPUs. Torch-TRT allows for optimizing models directly in PyTorch for deployment providing up to 6x performance improvement. ","__index_level_0__":1817}
+{"text":"Torch-TRT is an AoT compiler which ingests an nn.Module or TorchScript module, optimizes compatible subgraphs in TensorRT & leaves the rest to run in PyTorch. This gives users the performance of TensorRT, but the usability and familiarity of Torch.","__index_level_0__":1818}
+{"text":"Torch-TensorRT is part of the PyTorch ecosystem, and was released as v1.0 in November \u201821. There are currently two distinct front-ends: Torchscript & FX. Each provides the same value proposition and underlying operation with the primary difference being the input & output formats (TS vs FX \/ Python).","__index_level_0__":1819}
+{"text":"The Torchscript front-end was included in v1.0 and should be considered stable. The FX front-end is first released in v1.2 and should be considered a Beta.","__index_level_0__":1820}
+{"text":"Relevant Links:","__index_level_0__":1821}
+{"text":"- [Github](https:\/\/github.com\/pytorch\/TensorRT)\n- [Documentation](https:\/\/pytorch.org\/TensorRT\/)\n- [Generic (TS) getting started guide](https:\/\/pytorch.org\/TensorRT\/getting_started\/getting_started_with_python_api.html)\n- [FX getting started guide](https:\/\/pytorch.org\/TensorRT\/tutorials\/getting_started_with_fx_path.html)","__index_level_0__":1822}
+{"text":"#### (Stable)  Introducing Torch-TensorRT","__index_level_0__":1823}
+{"text":"Torch-TensorRT is an integration for PyTorch that leverages inference optimizations of TensorRT on NVIDIA GPUs. It takes advantage of TensorRT optimizations, such as FP16 and INT8 reduced precision, graph optimization, operation fusion, etc. while offering a fallback to native PyTorch when TensorRT does not support the model subgraphs. Currently, there are two frontend paths existing in the library that help to convert a PyTorch model to tensorRT engine. One path is through Torch Script (TS) and the other is through FX frontend. That being said, the models are traced by either TS or FX into their IR graph and then converted to TensorRT from it.","__index_level_0__":1824}
+{"text":"Learn more with our [tutorial](https:\/\/pytorch.org\/TensorRT\/).","__index_level_0__":1825}
+{"text":"TorchX 0.3 updates include a new list API, experiment tracking, elastic training and improved scheduler support. There\u2019s also a new Multi-Objective NAS [tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/ax_multiobjective_nas_tutorial.html) using TorchX + Ax.","__index_level_0__":1827}
+{"text":"#### (Prototype) List","__index_level_0__":1828}
+{"text":"The newly added list command and API allows you to list recently launched jobs and their statuses for a given scheduler directly from within TorchX.","__index_level_0__":1829}
+{"text":"- This removes the need for using secondary tools to list the jobs.\n- Full programmatic access to recent jobs for integration with custom tools.","__index_level_0__":1830}
+{"text":"```Python\n$ torchx list -s kubernetes\nAPP HANDLE                                                       APP STATUS\n-----------------------------------------------            -----------------\nkubernetes:\/\/torchx\/default:train-f2nx4459p5crr   SUCCEEDED\n```","__index_level_0__":1831}
+{"text":"Learn more with our [documentation](https:\/\/pytorch.org\/torchx\/main\/schedulers.html#torchx.schedulers.Scheduler.list).","__index_level_0__":1832}
+{"text":"#### (Prototype) Tracker","__index_level_0__":1833}
+{"text":"TorchX Tracker is a new prototype library that provides a flexible and customizable experiment and artifact tracking interface. This allows you to track inputs and outputs for jobs across multiple steps to make it easier to use TorchX with pipelines and other external systems.","__index_level_0__":1834}
+{"text":"```Python\nfrom torchx import tracker","__index_level_0__":1835}
+{"text":"app_run = tracker.app_run_from_env()\napp_run.add_metadata(lr=lr, gamma=gamma) # hyper parameters\napp_run.add_artifact(\"model\", \"storage:\/\/path\/mnist_cnn.pt\") # logs \/ checkpoints\napp_run.add_source(parent_run_id, \"model\") # lineage\n```","__index_level_0__":1836}
+{"text":"- [https:\/\/github.com\/pytorch\/torchx\/tree\/main\/torchx\/examples\/apps\/tracker](https:\/\/github.com\/pytorch\/torchx\/tree\/main\/torchx\/examples\/apps\/tracker)\n- [https:\/\/pytorch.org\/torchx\/main\/tracker.html](https:\/\/pytorch.org\/torchx\/main\/tracker.html)","__index_level_0__":1838}
+{"text":"#### (Prototype) Elastic Training and Autoscaling","__index_level_0__":1839}
+{"text":"Elasticity on Ray and Kubernetes \u2013 automatic scale up of distributed training jobs when using a supported scheduler. Learn more with our [documentation](https:\/\/pytorch.org\/torchx\/main\/components\/distributed.html).","__index_level_0__":1840}
+{"text":"#### (Prototype) Scheduler Improvements: IBM\u00ae Spectrum LSF","__index_level_0__":1841}
+{"text":"Added prototype support for the IBM Spectrum LSF scheduler.","__index_level_0__":1842}
+{"text":"#### (Beta) AWS Batch Scheduler","__index_level_0__":1843}
+{"text":"The AWS Batch scheduler integration is now in beta.","__index_level_0__":1844}
+{"text":"- log fetching and listing jobs is now supported.\n- Added configs for job priorities and queue policies\n- Easily access job UI via ui_url\n[https:\/\/pytorch.org\/torchx\/main\/schedulers\/aws_batch.html](https:\/\/pytorch.org\/torchx\/main\/schedulers\/aws_batch.html)","__index_level_0__":1845}
+{"text":"#### (Prototype) AnyPrecision Optimizer ","__index_level_0__":1846}
+{"text":"Drop in replacement for AdamW optimizer that reduces GPU memory, enables two main features:","__index_level_0__":1847}
+{"text":"- Ability to successfully train the entire model pipeline in full BFloat16.\nKahan summation ensures precision.  This can improve training throughput, especially on huge models, by reduced memory and increased computation speed.\n- Ability to change the variance state to BFloat16.  This can reduce overall memory required for model training with additional speed improvements.","__index_level_0__":1848}
+{"text":"Find more information [here](https:\/\/github.com\/pytorch\/torchdistx\/pull\/52).\n \n source: https:\/\/pytorch.org\/blog\/new-library-updates-in-pytorch-1.13\/ \n category: pytorch blogs","__index_level_0__":1849}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch 1.11, TorchData, and functorch are now available\"\nauthor: Team PyTorch\nfeatured-img: \"assets\/images\/pytorch-logo.jpg\"\n---","__index_level_0__":1850}
+{"text":"We are excited to announce the release of PyTorch 1.11 ([release notes](https:\/\/github.com\/pytorch\/pytorch\/releases\/tag\/v1.11.0)). This release is composed of over 3,300 commits since 1.10, made by 434 contributors. Along with 1.11, we are releasing beta versions of TorchData and functorch.","__index_level_0__":1851}
+{"text":"* **TorchData** is a new library for common modular data loading primitives for easily constructing flexible and performant data pipelines. [View it on GitHub](https:\/\/github.com\/pytorch\/data).\n* **functorch**, a library that adds composable function transforms to PyTorch, is now available in beta. [View it on GitHub](https:\/\/github.com\/pytorch\/functorch).\n* Distributed Data Parallel (DDP) static graph optimizations available in stable.","__index_level_0__":1853}
+{"text":"## Introducing TorchData","__index_level_0__":1854}
+{"text":"We are delighted to present the Beta release of [TorchData](https:\/\/github.com\/pytorch\/data). This is a library of common modular data loading primitives for easily constructing flexible and performant data pipelines. Based on community feedback, we have found that the existing DataLoader bundled too many features together and can be difficult to extend. Moreover, different use cases often have to rewrite the same data loading utilities over and over again. The goal here is to enable composable data loading through Iterable-style and Map-style building blocks called \u201c[DataPipes](https:\/\/github.com\/pytorch\/data#what-are-datapipes)\u201d that work well out of the box with the [PyTorch\u2019s DataLoader](https:\/\/pytorch.org\/docs\/stable\/data.html#torch.utils.data.DataLoader).","__index_level_0__":1855}
+{"text":"A `DataPipe` takes in some access function over Python data structures, `__iter__` for `IterDataPipe` and `__getitem__` for `MapDataPipe`, and returns a new access function with a slight transformation applied. You can chain multiple DataPipes together to form a data pipeline that performs all the necessary data transformation.","__index_level_0__":1856}
+{"text":"We have implemented over 50 DataPipes that provide different core functionalities, such as opening files, parsing texts, transforming samples, caching, shuffling, and batching. For users who are interested in connecting to cloud providers (such as Google Drive or AWS S3), the [fsspec](https:\/\/pytorch.org\/data\/0.3.0\/torchdata.datapipes.iter.html#io-datapipes) and iopath DataPipes will allow you to do so. The documentation provides detailed explanations and usage examples of each [IterDataPipe](https:\/\/pytorch.org\/data\/0.3.0\/torchdata.datapipes.iter.html) and [MapDataPipe](https:\/\/pytorch.org\/data\/0.3.0\/torchdata.datapipes.map.html).","__index_level_0__":1857}
+{"text":"In this release, some of the PyTorch domain libraries have migrated their datasets to use DataPipes. In TorchText, the [popular datasets provided by the library](https:\/\/github.com\/pytorch\/text\/tree\/release\/0.12\/torchtext\/datasets) are implemented using DataPipes and a [section of its SST-2 binary text classification tutorial](https:\/\/pytorch.org\/text\/0.12.0\/tutorials\/sst2_classification_non_distributed.html#dataset) demonstrates how you can use DataPipes to preprocess data for your model. There also are other prototype implementations of datasets with DataPipes in [TorchVision (available in nightly releases)](https:\/\/github.com\/pytorch\/vision\/tree\/main\/torchvision\/prototype\/datasets\/_builtin) and in [TorchRec](https:\/\/pytorch.org\/torchrec\/torchrec.datasets.html). You can find more [specific examples here](https:\/\/pytorch.org\/data\/0.3.0\/examples.html).","__index_level_0__":1858}
+{"text":"The [documentation for TorchData](https:\/\/pytorch.org\/data) is now live. It contains a tutorial that covers [how to use DataPipes](https:\/\/pytorch.org\/data\/0.3.0\/tutorial.html#using-datapipes), [use them with DataLoader](https:\/\/pytorch.org\/data\/0.3.0\/tutorial.html#working-with-dataloader), and [implement custom ones](https:\/\/pytorch.org\/data\/0.3.0\/tutorial.html#implementing-a-custom-datapipe). FAQs and future plans related to DataLoader are described in [our project\u2019s README file](https:\/\/github.com\/pytorch\/data#readme).","__index_level_0__":1859}
+{"text":"## Introducing functorch","__index_level_0__":1860}
+{"text":"We\u2019re excited to announce the first beta release of [functorch](https:\/\/github.com\/pytorch\/functorch). Heavily inspired by [Google JAX](https:\/\/github.com\/google\/jax), functorch is a library that adds composable function transforms to PyTorch. It aims to provide composable vmap (vectorization) and autodiff transforms that work with PyTorch modules and PyTorch autograd with good eager-mode performance.","__index_level_0__":1861}
+{"text":"Composable function transforms can help with a number of use cases that are tricky to do in PyTorch today:","__index_level_0__":1862}
+{"text":"* computing per-sample-gradients (or other per-sample quantities)\n* running ensembles of models on a single machine\n* efficiently batching together tasks in the inner-loop of MAML\n* efficiently computing Jacobians and Hessians as well as batched ones","__index_level_0__":1863}
+{"text":"Composing vmap (vectorization), vjp (reverse-mode AD), and jvp (forward-mode AD) transforms allows us to effortlessly express the above without designing a separate library for each.","__index_level_0__":1864}
+{"text":"For more details, please see our [documentation](https:\/\/pytorch.org\/functorch\/), [tutorials](https:\/\/pytorch.org\/functorch), and [installation instructions](https:\/\/pytorch.org\/functorch\/stable\/install.html).","__index_level_0__":1865}
+{"text":"## Distributed Training","__index_level_0__":1866}
+{"text":"### (Stable) DDP static graph","__index_level_0__":1867}
+{"text":"DDP static graph assumes that your model employs the same set of used\/unused parameters in every iteration, so that it can deterministically know states like which hooks will fire, how many times the hooks will fire and gradients computation ready order after the first iteration. Static graph caches these states in the first iteration, and thus it could support features that DDP can not support in previous releases, e.g., support multiple activation checkpoints on the same parameters regardless of whether there are unused parameters or not. The static graph feature also applies performance optimizations when there are unused parameters, e.g., it avoids traversing graphs to search unused parameters every iteration, and enables dynamic bucketing order. These optimizations in the DDP static graph brought 10% QPS gain for some recommendation models.","__index_level_0__":1868}
+{"text":"To enable static graph, just simply set static_graph=True in the DDP API like this:","__index_level_0__":1869}
+{"text":"```\nddp_model = DistributedDataParallel(model, static_graph=True)\n```","__index_level_0__":1870}
+{"text":"For more details, please see our [documentation](https:\/\/pytorch.org\/docs\/master\/generated\/torch.nn.parallel.DistributedDataParallel.html) and [tutorials](https:\/\/pytorch.org\/tutorials\/intermediate\/ddp_tutorial.html).","__index_level_0__":1871}
+{"text":"Thanks for reading, If you\u2019re interested in these updates and want to join the PyTorch community, we encourage you to join the [discussion forums](https:\/\/discuss.pytorch.org\/) and [open GitHub issues](https:\/\/github.com\/pytorch\/pytorch\/issues). To get the latest news from PyTorch, follow us on [Twitter](https:\/\/twitter.com\/PyTorch), [Medium](https:\/\/medium.com\/pytorch), [YouTube](https:\/\/www.youtube.com\/pytorch), and [LinkedIn](https:\/\/www.linkedin.com\/company\/pytorch).","__index_level_0__":1872}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.11-released\/ \n category: pytorch blogs","__index_level_0__":1874}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Torchserve Performance Tuning, Animated Drawings Case-Study\"\nauthor:  Hamid Shojanazeri, Geeta Chauhan, Mark Saroufim, Jesse Smith\nfeatured-img: \"assets\/images\/sketch_animator.png\"\n---","__index_level_0__":1875}
+{"text":"In this post we discuss performance tuning of Torchserve for serving your models in production. One of the biggest challenges in the life cycle of a ML project is deploying models in production.  This requires a reliable serving solution along with solutions that address the MLOps needs. A robust serving solution needs to provide support for multi model serving, model versioning, metric logging, monitoring and scaling to serve the peak traffic. In this post, we will have an overview of Torchserve and how to tune its performance for production use-cases. We discuss the [Animated Drawings app](https:\/\/ai.facebook.com\/blog\/using-ai-to-bring-childrens-drawings-to-life\/) from Meta that can turn your human figure sketches to animations and how it could serve the peak traffic with Torchserve. The Animated Drawing\u2019s workflow is below.","__index_level_0__":1876}
+{"text":"<p>\n<img src=\"\/assets\/images\/sketch_animator.png\" width=\"90%\">\n<\/p>","__index_level_0__":1877}
+{"text":"[https:\/\/ai.facebook.com\/blog\/using-ai-to-bring-childrens-drawings-to-life\/](https:\/\/ai.facebook.com\/blog\/using-ai-to-bring-childrens-drawings-to-life\/)","__index_level_0__":1878}
+{"text":"Many AI systems and tools are designed to handle realistic images of humans, children's drawings add a level of complexity and unpredictability as they are often constructed in abstract, fanciful ways. These types of morphological and stylistic variations can confuse even state-of-the-art AI systems that excel at spotting objects in photorealistic images and drawings.\nMeta AI researchers are working to overcome this challenge so that AI systems will be better able to recognize drawings of human figures in the wildly varied ways that children create them. This great blog post provides more details about the Animated Drawings and the approach taken.","__index_level_0__":1879}
+{"text":"## Torchserve","__index_level_0__":1880}
+{"text":"<p>\n<img src=\"\/assets\/images\/Tuning-flow-chart.png\" width=\"90%\">\n<center><i>Fig1. Overall flow of Torchserve performance tuning<\/i> <\/center>\n<\/p>","__index_level_0__":1881}
+{"text":"Once you have trained your model, it needs to be integrated into a larger system to have a full-fledged application, we use the term \u201cmodel serving\u201d to refer to this integration. Basically model serving is making your trained model available to run inferences and subsequent use of the model. ","__index_level_0__":1882}
+{"text":"Torchserve is the Pytorch preferred solution for serving models in production. It is a performant and scalable tool that wraps your model in a HTTP or HTTPS API. It has a frontend implemented in Java that handles multiple tasks from assigning workers for serving models to handling the connection between client and server. Torchserve has a Python backend that is responsible for handling the inference service.","__index_level_0__":1883}
+{"text":"Torchserve supports multi model serving and versioning for AB test, dynamic batching, logging and metrics. It exposes four APIs for [inference](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/inference_api.md), [explanations](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/inference_api.md#explanations-api), [management](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/management_api.md) and [metrics](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/metrics_api.md). ","__index_level_0__":1884}
+{"text":"[Inference](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/inference_api.md) API is listening on port 8080 and accessible through localhost by default, this can be configured in [Torchserve configuration](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/configuration.md) and enable getting predictions from the model. ","__index_level_0__":1885}
+{"text":"[Explanation](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/inference_api.md#explanations-api) API uses  Captum under the hood to provide explanations of the model that is being served and listens to the port 8080 as well.","__index_level_0__":1886}
+{"text":"[Management](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/management_api.md#management-api) API allows to register or unregister and describe a model. It also enables users to  scale up or down the number of workers that serve the model. ","__index_level_0__":1887}
+{"text":"[Metric](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/metrics_api.md) API by default listens to port 8082 and enables us to monitor the model that is being served. ","__index_level_0__":1888}
+{"text":"Torchserve let you scale your model serving and handle the peak traffic by supporting [batch inference](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/batch_inference_with_ts.md) and multiple  workers that serve your model. Scaling can be done through [management](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/management_api.md)  API and settings through a [configuration](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/configuration.md) file. Also, metric API helps you to monitor your model serving through default and customizable metrics.","__index_level_0__":1889}
+{"text":"Other advanced settings such as the length of the queue for the received requests, maximum wait time for a batch of inputs and many other properties are configurable through a[ config file](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/configuration.md) that can be passed to Torchserve when it is started.","__index_level_0__":1890}
+{"text":"\n**Steps to serve your model with Torchserve**","__index_level_0__":1891}
+{"text":"1. [Install Torchserve, model archiver](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/getting_started.md#install-torchserve-and-torch-model-archiver) and its requirements.\n2. Choose a default handler that fits your task (e.g image classification, etc) or author a [custom handler](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/custom_service.md#custom-handlers).\n3. [Package your model](https:\/\/github.com\/pytorch\/serve\/tree\/master\/examples\/Huggingface_Transformers#create-model-archive-eager-mode) artifacts (trained model checkpoint and all other necessary files for loading and running your model) and the handler into a \u201c.mar\u201d file using [Torcharchive](https:\/\/github.com\/pytorch\/serve\/blob\/master\/model-archiver\/README.md) and place it in the model store.\n4. [Start serving your model](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/getting_started.md).\n5. [Run inference](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/getting_started.md#get-predictions-from-a-model).\nWe will discuss model handlers and metrics in more detail here.","__index_level_0__":1892}
+{"text":"## Model handlers","__index_level_0__":1893}
+{"text":"Torchserve uses a handler in the backend to load the models, preprocess the received data, run inference and post-process the response. Handler in torchserve is a **python script** that all the model initialization, preprocessing, inference and post processing logic goes into.","__index_level_0__":1894}
+{"text":"Torchserve provides an out of the box handler for a number of applications like image classification, segmentation, object detection and text classification. It also supports custom handlers, in case your use case is not supported in default handlers. ","__index_level_0__":1895}
+{"text":"It provides a great flexibility in custom handlers, this potentially make Torchserve as **multi-framework** serving tool. Custom handlers let you define your custom logic to initialize a model that can be used also to load models from other frameworks such as ONNX.","__index_level_0__":1896}
+{"text":"Torchserve **handler** is made of four main **functions**, **initialize**, **preprocess**, **inference** and **postprocess** that each return a list. The code snippet below shows an example of a custom handler.**Custom handlers inherit** from **BaseHandler** in Torchserve and can **overwrite** any of the **main** **functions**.  Here is an example of the handler used for loading the [Detectron2](https:\/\/github.com\/facebookresearch\/detectron2) model for figure detection, this model has been exported to Torchscript and uses model.half() to run the inference with FP16, details are explained in another [section]() in this post.","__index_level_0__":1897}
+{"text":"class MyModelHandler(BaseHandler):\n    def initialize(self, context):\n        self.manifest = ctx.manifest\n        properties = ctx.system_properties\n        model_dir = properties.get(\"model_dir\")\n        serialized_file = self.manifest[\"model\"][\"serializedFile\"]\n        model_pt_path = os.path.join(model_dir, serialized_file)","__index_level_0__":1899}
+{"text":"        self.device = torch.device(\n        \"cuda:\" + str(properties.get(\"gpu_id\"))\n        if torch.cuda.is_available() and properties.get(\"gpu_id\") is not None\n        else \"cpu\"\n        )\n        self.model = torch.jit.load(model_pt_path, map_location=self.device)","__index_level_0__":1900}
+{"text":"        self.model = self.model.half()","__index_level_0__":1901}
+{"text":"    def preprocess(self, data):","__index_level_0__":1902}
+{"text":"        inputs = []\n        for request in batch:","__index_level_0__":1903}
+{"text":"            request_body = request.get(\"body\")","__index_level_0__":1904}
+{"text":"            input_ = io.BytesIO(request_body)\n            image = cv2.imdecode(np.fromstring(input_.read(), np.uint8), 1)\n            input = torch.Tensor(image).permute(2, 0, 1)\n            input = input.to(self.device)\n            input = input.half()\n            inputs.append({\"image\": input})","__index_level_0__":1905}
+{"text":"        return inputs","__index_level_0__":1906}
+{"text":"    def inference(self,inputs):\n        predictions = self.model(**inputs)\n        return predictions","__index_level_0__":1907}
+{"text":"    def postprocess(self, output):\n        responses = []\n        for inference_output in inference_outputs:\n            responses_json = {\n            'classes': inference_output['pred_classes'].tolist(),\n            'scores': inference_output['scores'].tolist(),\n            \"boxes\": inference_output['pred_boxes'].tolist()\n            }\n            responses.append(json.dumps(responses_json))","__index_level_0__":1908}
+{"text":"        return responses\n```","__index_level_0__":1909}
+{"text":"An essential component in serving models in production is the ability to monitor them. **Torchserve** **collects** **system level** [metrics](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/metrics.md) regularly and **allows** adding **custom metrics** as well.","__index_level_0__":1911}
+{"text":"**[System level metrics](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/metrics.md#system-metrics)** consist of CPU utilization, available and used disk space and memory on the host machine along with number of requests with different response codes (e.g 200-300, 400-500 and above 500). **Custom metrics** can be **added** to the metrics as explained [here](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/metrics.md#custom-metrics-api). TorchServe logs these two sets of metrics to different log files. Metrics are collected by default at:","__index_level_0__":1912}
+{"text":"* System metrics - log_directory\/ts_metrics.log\n* Custom metrics - log directory\/model_metrics.log","__index_level_0__":1913}
+{"text":"As mentioned before, Torchserve also exposes [metric API](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/metrics_api.md), that by default listens to port 8082 and enables users to query and monitor the collected metrics.  The default metrics endpoint returns Prometheus formatted metrics. You can query metrics using curl requests or point a [Prometheus Server](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/metrics_api.md#prometheus-server) to the endpoint and use [Grafana](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/metrics_api.md#grafana) for dashboards. ","__index_level_0__":1914}
+{"text":"While serving a model you can query metrics using curl request as follows:","__index_level_0__":1915}
+{"text":"```\ncurl http:\/\/127.0.0.1:8082\/metrics\n```","__index_level_0__":1916}
+{"text":"In case you are looking into exporting the logged metrics, please refer to this [example](https:\/\/github.com\/google\/mtail) that uses mtail to export metrics to Prometheus. Tracking these metrics in a dashboard allows you to monitor performance regressions that may have been sporadic or hard to spot during an offline benchmark run.","__index_level_0__":1917}
+{"text":"## What to consider for tuning performance of a model in production","__index_level_0__":1918}
+{"text":"The workflow suggested in Fig 1, is the general idea on how to approach model deployment in production with Torchserve.","__index_level_0__":1919}
+{"text":"In many cases serving models in production is **optimized** **based** on **throughput** or **latency** service level agreement (**SLA)s**. Usually **real-time** **applications** are more concerned about **latency** whereas **off-line applications** may care more about higher **throughput**.","__index_level_0__":1920}
+{"text":"There are a number of main factors contributing to the performance of a serving model in production. In particular, we are focusing on serving Pytorch models with Torchserve here, however most of these factors generalize to all models from other frameworks as well.","__index_level_0__":1921}
+{"text":"* **Model optimizations**: this is a pre-step for deploying models into production. This is a very broad discussion that we will get into in a series of future blogs. This includes techniques like quantization, pruning to decrease the size of the model, using Intermediate representations (IR graphs) such as Torchscript in Pytorch, fusing kernels and many others. Currently [torchprep](https:\/\/github.com\/msaroufim\/torchprep) provides many of these techniques as a CLI tool. \n* **Batch inference:** it refers to feeding multiple inputs into a model, while it is essential during training, it can be very helpful to manage the cost at inference time as well. Hardware accelerators are optimized for parallelism and batching helps to saturate the compute capacity and often leads to higher throughput. The main difference in inference is you can\u2019t wait too long to get a batch filled from clients, something we call dynamic batching\n* **Number of Workers :** Torchserve uses workers to serve models. Torchserve workers are Python processes that hold a copy of the model weights for running inference. Too few workers means you\u2019re not benefitting from enough parallelism but too many can cause worker contention and degrade end to end performance.","__index_level_0__":1922}
+{"text":"- **Hardware :** choosing the appropriate hardware based on the model, application and latency, throughput budget. This could be one of the **supported** hardwares in Torchserve, **CPU, GPU, AWS Inferentia**. Some hardware configurations are intended for best in class performance and others are better suited for cost effective inference. From our experiments we\u2019ve found that GPUs shine best at larger batch sizes whereas the right CPUs and AWS Inferentia can be far more cost effective for lower batch sizes and low latency.","__index_level_0__":1923}
+{"text":"## Best Practices for Performance tuning on Torchserve","__index_level_0__":1924}
+{"text":"To get the best performance out of your model while serving it with Torchserve, we are sharing some of the best practices here. Torchserve provides a  [benchmark](https:\/\/github.com\/pytorch\/serve\/tree\/c87bfec8916d340de5de5810b14a016049b0e395\/benchmarks#benchmarking-with-apache-bench) suite that provides helpful insight to make informed decisions on different choices as detailed below. ","__index_level_0__":1925}
+{"text":"* **Optimize your model** as the first step, Pytorch model optimization [tutorials](https:\/\/pytorch.org\/tutorials\/). **Model optimization** choices are also closely **tied** to the **hardware** of choice. We will discuss it in more detail in another blog post.\n* **Deciding** the **hardware** for model deployment can be closely related to the latency and throughput budget and cost per inference. Depending on the size of model and application it can vary, for some models like computer vision models it has been historically not affordable to run in production on CPU.  However, by having optimizations such [IPEX](https:\/\/github.com\/pytorch\/serve\/blob\/c87bfec8916d340de5de5810b14a016049b0e395\/examples\/intel_extension_for_pytorch\/README.md) as recently added to Torchserve this has been much more affordable and cost beneficial and you can learn more in this investigative [case study](https:\/\/pytorch.org\/tutorials\/intermediate\/torchserve_with_ipex.html) \n* **Workers** in Torchserve are Python processes that provide parallelism, setting the number of workers should be done carefully. By default Torchserve launch number of workers equal to VCPUs or available GPUs on the host, this can add a considerable amount of time to the Torchserve start. ","__index_level_0__":1926}
+{"text":"    Torchserve exposes a [config property](https:\/\/github.com\/pytorch\/serve\/blob\/c87bfec8916d340de5de5810b14a016049b0e395\/docs\/configuration.md#config-model) to set the number of workers. To provide an **efficient parallelism** through **multiple workers** and avoiding them to compete over resources, as a baseline we **recommend** following setting on CPU and GPU:","__index_level_0__":1927}
+{"text":"\n    **CPU** : In the handler,  `torch.set_num_threads(1) `then set the number of workers to `num physical cores \/ 2. `But the the best threading configurations can be achieved by leveraging the Intel CPU launcher script.","__index_level_0__":1928}
+{"text":"\n    **GPU**: number of available GPUs can be set through[ number_gpus](https:\/\/github.com\/pytorch\/serve\/blob\/c87bfec8916d340de5de5810b14a016049b0e395\/docs\/configuration.md#limit-gpu-usage) in config.properties. Torchserve uses round robin to assign workers to GPUs. We recommend setting the number of workers as follows.  `Number of worker = (Number of available GPUs) \/ (Number of Unique Models). `Note that GPUs that are pre-Ampere do not provide any resource isolation with Multi Instance GPUs.","__index_level_0__":1929}
+{"text":"* **Batch size** can directly affect the latency and the throughput. To better utilize the compute resources batch size needs to be increased. However, there is a tradeoff between latency and throughput. **Larger batch sizes** can **increase** the **throughput but results in a higher latency** as well.  Batch size can be set in Torchserve in two ways, either through[ model config](https:\/\/github.com\/pytorch\/serve\/blob\/c87bfec8916d340de5de5810b14a016049b0e395\/docs\/configuration.md#config-model) in config.properties or while registering the model using [Management API](https:\/\/github.com\/pytorch\/serve\/blob\/c87bfec8916d340de5de5810b14a016049b0e395\/docs\/management_api.md#scale-workers). ","__index_level_0__":1930}
+{"text":"In the next section, we are going to use Torchserve benchmark suite to decide the best combination of model optimization,  hardware, workers, and batch size. ","__index_level_0__":1931}
+{"text":"## Animated Drawings Performance Tuning ","__index_level_0__":1932}
+{"text":"To use the Torchserve benchmark suite, first we need to have an archived file, \u201c.mar\u201d file as discussed above, that contains the model, handler and all other artifacts to load and run inference. Animated Drawings uses Detectron2\u2019s implementation of Mask-RCNN for an object detection model. ","__index_level_0__":1933}
+{"text":"### How to run benchmark suite ","__index_level_0__":1934}
+{"text":"The [Automated benchmark suite](https:\/\/github.com\/pytorch\/serve\/tree\/master\/benchmarks#auto-benchmarking-with-apache-bench) in Torchserve let you benchmark multiple models with different setting including batch size and number of worker and finally generate a report for you. To get started:","__index_level_0__":1935}
+{"text":"```\ngit clone https:\/\/github.com\/pytorch\/serve.git","__index_level_0__":1936}
+{"text":"cd serve\/benchmarks","__index_level_0__":1937}
+{"text":"pip install -r requirements-ab.txt","__index_level_0__":1938}
+{"text":"apt-get install apache2-utils\n```","__index_level_0__":1939}
+{"text":"Model level settings can be configured in a yaml file similar to ","__index_level_0__":1940}
+{"text":"Model_name:\n    eager_mode:\n        benchmark_engine: \"ab\"\n        url: \"Path to .mar file\"\n        workers:\n            - 1\n            - 4\n        batch_delay: 100\n        batch_size:\n            - 1\n            - 2\n            - 4\n            - 8\n        requests: 10000\n        concurrency: 10\n        input: \"Path to model input\"\n        backend_profiling: False\n        exec_env: \"local\"\n        processors:\n            - \"cpu\"\n            - \"gpus\": \"all\"","__index_level_0__":1942}
+{"text":"This yaml file will be referenced in the [benchmark_config_template](https:\/\/github.com\/pytorch\/serve\/blob\/master\/benchmarks\/benchmark_config_template.yaml#L12).yaml file that includes other settings for generating reports, this can optionally work with AWS cloud watch for logs as well.","__index_level_0__":1944}
+{"text":"```\npython benchmarks\/auto_benchmark.py --input benchmark_config_template.yaml\n```","__index_level_0__":1945}
+{"text":"Running the **benchmarks**, results will be written in \u201ccsv\u201d file that can be found in \u201c_ \/tmp\/benchmark\/ab_report.csv_\u201d and full report \u201c\/tmp\/ts_benchmark\/report.md\". It will include items such as Torchserve average latency, model P99 latency, throughput, number of concurrency, number of requests, handler time, and some other metrics. Here we focus on some of the important ones that we track to tune the performance which are, **concurrency**, **model P99** latency, **throughput**. We look at these numbers specifically in **combination** with **batch size**, the used **device, number of workers** and if any **model optimization** has been done.","__index_level_0__":1946}
+{"text":"\nThe **latency SLA** for this model has been set to **100 ms,** this is real-time application and as we discussed earlier, latency is more of a concern and **throughput** ideally should be as high as possible while it does **not violate** the **latency SLA.**","__index_level_0__":1947}
+{"text":"Through searching the space, over different batch sizes (1-32), number of workers (1-16) and devices (CPU,GPU), we have run a set of experiments that summarized the best ones in the table below.","__index_level_0__":1948}
+{"text":"<table>\n  <tr>\n   <td>Device \n   <\/td>\n   <td>Concurrency \n   <\/td>\n   <td># Requests\n   <\/td>\n   <td>#workers\n   <\/td>\n   <td>Batch size\n   <\/td>\n   <td>Payload\/image\n   <\/td>\n   <td>Optimization \n   <\/td>\n   <td>Throughput \n   <\/td>\n   <td>Latency P99\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>CPU\n   <\/td>\n   <td>10\n   <\/td>\n   <td>1000\n   <\/td>\n   <td>1\n   <\/td>\n   <td>1\n   <\/td>\n   <td>small\n   <\/td>\n   <td>N\/A\n   <\/td>\n   <td>3.45\n   <\/td>\n   <td>305.3 ms\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>CPU\n   <\/td>\n   <td>1\n   <\/td>\n   <td>1000\n   <\/td>\n   <td>1\n   <\/td>\n   <td>1\n   <\/td>\n   <td>small\n   <\/td>\n   <td>N\/A\n   <\/td>\n   <td>3.45\n   <\/td>\n   <td>291.8 ms\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>GPU\n   <\/td>\n   <td>10\n   <\/td>\n   <td>1000\n   <\/td>\n   <td>1\n   <\/td>\n   <td>1\n   <\/td>\n   <td>small\n   <\/td>\n   <td>N\/A\n   <\/td>\n   <td>41.05\n   <\/td>\n   <td>25.48  ms\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>GPU\n   <\/td>\n   <td>1\n   <\/td>\n   <td>1000\n   <\/td>\n   <td>1\n   <\/td>\n   <td>1\n   <\/td>\n   <td>small\n   <\/td>\n   <td>N\/A\n   <\/td>\n   <td>42.21\n   <\/td>\n   <td>23.6  ms\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>GPU\n   <\/td>\n   <td>10\n   <\/td>\n   <td>1000\n   <\/td>\n   <td>1\n   <\/td>\n   <td>4\n   <\/td>\n   <td>small\n   <\/td>\n   <td>N\/A\n   <\/td>\n   <td>54.78\n   <\/td>\n   <td>73.62 ms\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>GPU\n   <\/td>\n   <td>10\n   <\/td>\n   <td>1000\n   <\/td>\n   <td>1\n   <\/td>\n   <td>4\n   <\/td>\n   <td>small\n   <\/td>\n   <td>model.half()\n   <\/td>\n   <td>78.62\n   <\/td>\n   <td>50.69 ms\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>GPU\n   <\/td>\n   <td>10\n   <\/td>\n   <td>1000\n   <\/td>\n   <td>1\n   <\/td>\n   <td>8\n   <\/td>\n   <td>small\n   <\/td>\n   <td>model.half()\n   <\/td>\n   <td>85.29\n   <\/td>\n   <td>94.4 ms\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":1949}
+{"text":"The latency of this model on CPU with all of the tried settings in terms of batch size, concurrency and number of workers did not meet the SLA, in fact ~13x higher.","__index_level_0__":1950}
+{"text":"**Moving** the model serving **to GPU**, immediately could **improve** the **latency** ~**13x **from 305 ms down to 23.6 ms. ","__index_level_0__":1951}
+{"text":"One of the **simplest** **optimizations** that we could do for the model was lowering its precision to **fp16**, it is one liner (**model.half()**)  and could reduce the **model P99 latency **by  **32%** and increase the throughput by almost the same amount.","__index_level_0__":1952}
+{"text":"There could be other optimization done by Torchscripting the model and using  [optimize_for_inference](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/jit\/_freeze.py#L168) or other tricks including onnx or tensorrt runtime optimizations which leverage aggressive fusions are out of the scope of this post. We will discuss model optimizations in a separate post.","__index_level_0__":1953}
+{"text":"We found both on CPU and GPU , setting **number of workers=1 **worked the best in this case. ","__index_level_0__":1954}
+{"text":"* Moving the model to GPU, using **number of workers = 1**, and **batch size = 1** increased the **Throughput ~12x compared** to **CPU and latency ~13x.**\n* Moving the model to GPU, using **model.half()**, **number of workers = 1**, and **batch size = 8** yielded **best** results in terms of **Throughput** and tolerable latency. **Throughput** increased **~25x compared** to **CPU with latency still meeting the SLA (94.4ms).**\n \n_Note: if you are running the benchmark suite, make sure you are setting a proper `batch_delay` and set the concurrency of the request to a number proportional to your batch size. Concurrency here means the number of concurrent requests being sent to the server._","__index_level_0__":1955}
+{"text":"## Conclusion","__index_level_0__":1956}
+{"text":"In this post, we have discussed the considerations and knobs that Torchserve expose to tune the performance in production. We have discussed the Torchserve benchmark suite as a means to tune the performance and get insights on possible choices for model optimizations, hardware choice and cost in general. We used Animated Drawings app which uses Detectron2\u2019s Mask-RCNN model as a case-study to showcase the performance tuning with benchmark suite. ","__index_level_0__":1957}
+{"text":"For more details on Performance tuning in Torchserve please refer to our documentation [here](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/performance_guide.md).\nAlso feel free to open a ticket on [Torchserve repo](https:\/\/github.com\/pytorch\/serve\/issues) for any further questions and feedback. ","__index_level_0__":1958}
+{"text":"### Acknowledgement","__index_level_0__":1959}
+{"text":"We would like to thank Somya Jain (Meta), Christopher Gustave (Meta) for their great support and guidance throughout many steps of this blog and providing insights to Sketch Animator workflow. Also, special thanks to[ Li Ning](https:\/\/www.linkedin.com\/in\/li-ning-7274604\/) from AWS for the great efforts to make performance tuning much easier on Torchserve with automated benchmark suite.","__index_level_0__":1960}
+{"text":"    td{\n        border: 1px solid black;\n    }\n    \n    \/* article.pytorch-article table tr td:first-of-type{\n        padding: 0.3125rem;\n    }","__index_level_0__":1962}
+{"text":"    article.pytorch-article table td {\n    padding: 0.3125rem;\n    } *\/","__index_level_0__":1963}
+{"text":"   li a:focus, li a:hover, li a:active{\n    cursor: pointer;\n    text-decoration: underline;\n    }","__index_level_0__":1964}
+{"text":"    ol a:hover, ol a:active{\n    cursor: pointer;\n    text-decoration: underline;\n    }","__index_level_0__":1965}
+{"text":" \n source: https:\/\/pytorch.org\/blog\/torchserve-performance-tuning\/ \n category: pytorch blogs","__index_level_0__":1968}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Scaling Vision Model Training Platforms with PyTorch\"\nauthor: Vaibhav Aggarwal, Mannat Singh, Anjali Sridhar, Yanghao Li, Shoubhik Debnath, Ronghang Hu, Will Feng, Xinlei Chen, Tingting Markstrum, Diana Liskovich, Anupam Bhatnagar, Chay Ryali, Haoqi Fan, Tete Xiao, Min Xu, Rahul Iyer, Christoph Feichtenhofer, Ross Girshick, Piotr Dollar, Aaron Adcock, Wan-Yen Lo, CK Luk\nfeatured-img: \"\/assets\/images\/scaling-vision-figure_1-solutions-to-the-challenges.png\"\n---","__index_level_0__":1969}
+{"text":"*TL;DR: We demonstrate the use of PyTorch with FairScale\u2019s FullyShardedDataParallel (FSDP) API in writing large vision transformer models. We discuss our techniques for scaling and optimizing these models on a GPU cluster. The goal of this platform scaling effort is to enable research at scale. This blog does not discuss model accuracy, new model architectures, or new training recipes.*","__index_level_0__":1970}
+{"text":"## 1. Introduction","__index_level_0__":1971}
+{"text":"Latest vision research [1, 2] demonstrates model scaling as a promising research direction. In this project, we aim to enable our platforms to train massive vision transformer (ViT) [3] models. We present our work on scaling the largest trainable ViT from 1B to 120B parameters in FAIR vision platforms. We wrote ViT in PyTorch and leveraged its support for large-scale, distributed training on a GPU cluster.","__index_level_0__":1972}
+{"text":"In the rest of this blog, we will first discuss the main challenges, namely *scalability*, *optimization*, and *numerical stability*. Then we will discuss how we tackle them with techniques including *data and model parallelism*, *automatic mixed precision*, *kernel fusion*, and *bfloat16*. Finally, we present our results and conclude.","__index_level_0__":1973}
+{"text":"## 2. Main Challenges","__index_level_0__":1974}
+{"text":"### 2.1 Scalability","__index_level_0__":1975}
+{"text":"The key scalability challenge is to efficiently shard a model\u2019s operations and state across multiple GPUs. A 100B parameter model requires ~200GB of RAM just for parameters, assuming fp16 representation. So, it is impossible to fit the model on a single GPU (A100 has at most 80GB RAM). Therefore, we need some way to efficiently shard a model\u2019s data (input, parameters, activations, and optimizer state) across multiple GPUs.","__index_level_0__":1976}
+{"text":"Another aspect of this problem is to scale without significantly changing the training recipe. E.g. Certain representation learning recipes use a global batch size of up to 4096 beyond which we start to see accuracy degradation. We cannot scale to more than 4096 GPUs without using some form of tensor or pipeline parallelism.","__index_level_0__":1977}
+{"text":"### 2.2 Optimization","__index_level_0__":1978}
+{"text":"The key optimization challenge is to maintain high GPU utilization even as we scale the number of model parameters and flops. When we scale models to teraflops and beyond, we start to hit major bottlenecks in our software stack that super-linearly increase training time and reduce accelerator utilization. We require hundreds or thousands of GPUs to run just a single experiment. Improvements in accelerator utilization can lead to significant reductions in cost and improve fleet utilization. It enables us to fund more projects and run more experiments in parallel.","__index_level_0__":1979}
+{"text":"### 2.3 Numerical Stability","__index_level_0__":1980}
+{"text":"The key stability challenge is to avoid numerical instability and divergence at large scale. We empirically observed in our experiments that the training instability gets severe and hard to deal with when we scale up model sizes, data, batch sizes, learning rate, etc. Vision Transformers particularly face training instability even at a lower parameter threshold. E.g., we find it challenging to train even ViT-H (with just 630M parameters) in mixed-precision mode without using strong data augmentation. We need to study the model properties and training recipes to make sure that the models train stably and converge.","__index_level_0__":1981}
+{"text":"## 3. Our Solutions","__index_level_0__":1982}
+{"text":"**Figure 1** depicts our solutions to each of the challenges.","__index_level_0__":1983}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/scaling-vision-figure_1-solutions-to-the-challenges.png\" width=\"100%\">\n<\/p>","__index_level_0__":1984}
+{"text":"### 3.1 Addressing scaling challenges with data parallelism and model parallelism","__index_level_0__":1985}
+{"text":"We apply various forms of data and model parallelism to enable fitting very large models in GPU memory.","__index_level_0__":1986}
+{"text":"We use FairScale\u2019s *FullyShardedDataParallel (FSDP)* API [4], based on PyTorch, to shard parameters, gradients, and optimizer state across multiple GPUs, thereby reducing the memory footprint per GPU. This process consists of the following three steps:","__index_level_0__":1987}
+{"text":"- Step 1: We wrapped the entire model in a single FSDP instance. This shards the model parameters at the end of a forward pass and gathers parameters at the beginning of a forward pass. This enabled us to scale ~3x from 1.5B to 4.5B parameters. ","__index_level_0__":1988}
+{"text":"- Step 2: We experimented with wrapping individual model layers in separate FSDP instances. This nested wrapping further reduced the memory footprint by sharding and gathering parameters of individual model layers instead of an entire model. The peak memory is then determined by an individually wrapped transformer block in GPU memory in this mode instead of the entire model.","__index_level_0__":1989}
+{"text":"- Step 3: We used *activation-checkpoint* to reduce the memory consumption by activations. It saves the input tensors and discards the intermediate activation tensors during the forward pass. These are recomputed during the backward pass.","__index_level_0__":1990}
+{"text":"In addition, we experimented with model-parallelism techniques such as pipeline parallelism [5], which allow us to scale to more GPUs without increasing the batch size.","__index_level_0__":1991}
+{"text":"### 3.2 Addressing optimization challenges with advanced AMP and kernel fusion","__index_level_0__":1992}
+{"text":"#### Advanced AMP","__index_level_0__":1993}
+{"text":"Automatic Mixed Precision (AMP) [6] training refers to training models using a lower precision of bits than FP32 or the default but still maintaining accuracy. We experimented with three levels of AMP as described below:","__index_level_0__":1994}
+{"text":"- AMP O1: This refers to training in mixed precision where weights are in FP32 and some operations are in FP16. With AMP O1, the ops that might impact accuracy remain in FP32 and are not autocasted to FP16.","__index_level_0__":1995}
+{"text":"- AMP O2: This refers to training in mixed precision but with more weights and ops in FP16 than in O1. Weights do not implicitly remain in FP32 and are cast to FP16. A copy of the master weights is maintained in the FP32 precision that is used by the optimizer. If we want the normalization layer weights in FP32 then we need to explicitly use layer wrapping to ensure that.","__index_level_0__":1996}
+{"text":"- Full FP16: This refers to training in full FP16 where weights and operations are in FP16. FP16  is challenging to enable for training due to convergence issues.","__index_level_0__":1997}
+{"text":"We found that AMP O2 with LayerNorm wrapping in FP32 leads to the best performance without sacrificing accuracy.","__index_level_0__":1998}
+{"text":"#### Kernel Fusion","__index_level_0__":1999}
+{"text":"- To reduce GPU kernel launch overhead and increase GPU work granularity, we experimented with kernel fusions, including fused dropout and fused layer-norm, using the [xformers library](https:\/\/github.com\/facebookresearch\/xformers) [7].","__index_level_0__":2000}
+{"text":"### 3.3 Addressing stability challenges by studying ops numerical stability and training recipes","__index_level_0__":2001}
+{"text":"#### BFloat16 in general but with LayerNorm in FP32","__index_level_0__":2002}
+{"text":"The [bfloat16](https:\/\/cloud.google.com\/tpu\/docs\/bfloat16) (BF16) [8] floating-point format provides the same dynamic range as FP32 with a memory footprint identical to FP16. We found that we could train models in the BF16 format using the same set of hyperparameters as in FP32, without special parameter tuning. Nevertheless, we found that we need to keep LayerNorm in FP32 mode in order for the training to converge.","__index_level_0__":2003}
+{"text":"### 3.4 Final training recipe","__index_level_0__":2004}
+{"text":"A summary of the final training recipe.","__index_level_0__":2005}
+{"text":"1. Wrap the outer model in an FSDP instance. Enable parameter sharding after the forward pass.\n2. Wrap individual ViT blocks with activation checkpointing, nested FSDP wrapping, and parameter flattening.\n3. Enable mixed precision mode (AMP O2) with bfloat16 representation. Maintain the optimizer state in FP32 precision to enhance numerical stability.\n4. Wrap normalization layers like LayerNorm in FP32 for better numerical stability.\n5. Maximize the Nvidia TensorCore utilization by keeping matrix dimensions to be multiple of 8. For More details check [Nvidia Tensor Core Performance Guide](https:\/\/developer.download.nvidia.com\/video\/gputechconf\/gtc\/2019\/presentation\/s9926-tensor-core-performance-the-ultimate-guide.pdf).","__index_level_0__":2006}
+{"text":"## 4. Results","__index_level_0__":2007}
+{"text":"In this section, we show the scaling results of ViT on three types of tasks: (1) image classification, (2) object detection (3) video understanding. **Our key result is that we are able to train massive ViT backbones across these vision tasks after applying the discussed scaling and optimization techniques. This enables vision research at a much larger scale.** We trained the models to convergence to verify that we maintain the current baselines even with all the optimizations. A common trend in Figures 2, 3, 4 is that we are able to train up to 25B-param models with an epoch time of less than 4 hours on 128 A100 GPUs. The 60B and 120B models are relatively slower to train.","__index_level_0__":2008}
+{"text":"**Figure 2** shows the *image-classification* scaling result. It plots the epoch time for training ViTs on ImageNet using 128 A100-80GB GPUs with different model sizes.","__index_level_0__":2009}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/scaling-vision-figure_2-image-classification-scaling-result.png\" width=\"100%\">\n<\/p>","__index_level_0__":2010}
+{"text":"<p align=\"center\">\n<b>Figure 2: Image-classification scaling result.<\/b>\n<\/p>","__index_level_0__":2011}
+{"text":"**Figure 3** shows the *object-detection* scaling result. It plots the epoch time for training [ViTDet](https:\/\/arxiv.org\/abs\/2203.16527) [9] with different ViT backbones on COCO using 128 A100-80GB GPUs.","__index_level_0__":2012}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/scaling-vision-figure_3-object-detection-scaling-result.png\" width=\"100%\">\n<\/p>","__index_level_0__":2013}
+{"text":"<p align=\"center\">\n<b>Figure 3: Object-detection scaling result.<\/b>\n<\/p>","__index_level_0__":2014}
+{"text":"**Figure 4** shows the *video-understanding* scaling result. It plots the epoch time for training [MViTv2](https:\/\/arxiv.org\/abs\/2112.01526) [10] models on [Kinetics 400](https:\/\/www.deepmind.com\/open-source\/kinetics) [11] using 128 V100 (32 GB) GPUs in FP32.","__index_level_0__":2015}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/scaling-vision-figure_4-video-understanding-scaling-result.png\" width=\"100%\">\n<\/p>","__index_level_0__":2016}
+{"text":"<p align=\"center\">\n<b>Figure 4: Video-understanding scaling result.<\/b>\n<\/p>","__index_level_0__":2017}
+{"text":"**Figure 5** shows the optimization result with the ViT-H model in Figure 2 on 8 A100-40GB GPUs.\nThree versions are used: (1) the baseline uses PyTorch\u2019s DDP [12] with AMP O1, (2) FSDP + AMP-O2 + other optimizations, and (3) FSDP + FP16 + other optimizations. These optimizations altogether speed up the training by up to 2.2x.","__index_level_0__":2018}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/scaling-vision-figure_5-training-speedups-from-various-optimizations.png\" width=\"100%\">\n<\/p>","__index_level_0__":2019}
+{"text":"<p align=\"center\">\n<b>Figure 5: Training speedups from various optimizations.<\/b>\n<\/p>","__index_level_0__":2020}
+{"text":"## 5. Concluding Remarks","__index_level_0__":2021}
+{"text":"We have demonstrated the use of PyTorch with FairScale\u2019s FullyShardedDataParallel (FSDP) API in writing large vision transformer models. We discuss our techniques for scaling and optimizing these models on a GPU cluster.  We hope that this article can motivate others to develop large-scale ML models with PyTorch and its ecosystem.","__index_level_0__":2022}
+{"text":"## References","__index_level_0__":2023}
+{"text":"[1] [Masked Autoencoders Are Scalable Vision Learners](https:\/\/arxiv.org\/abs\/2111.06377)","__index_level_0__":2024}
+{"text":"[2] [Revisiting Weakly Supervised Pre-Training of Visual Perception Models](https:\/\/arxiv.org\/abs\/2201.08371)","__index_level_0__":2025}
+{"text":"[3] [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale](https:\/\/arxiv.org\/abs\/2010.11929v2)","__index_level_0__":2026}
+{"text":"[4] [fairscale.nn.FullyShardedDataParallel](https:\/\/fairscale.readthedocs.io\/en\/stable\/api\/nn\/fsdp.html)","__index_level_0__":2027}
+{"text":"[5] [Pipeline parallelism in PyTorch](https:\/\/pytorch.org\/docs\/stable\/pipeline.html)","__index_level_0__":2028}
+{"text":"[6] [Automatic Mixed Precision (AMP) in PyTorch](https:\/\/pytorch.org\/docs\/stable\/amp.html#module-torch.amp)","__index_level_0__":2029}
+{"text":"[7] [xformers](https:\/\/github.com\/facebookresearch\/xformers)","__index_level_0__":2030}
+{"text":"[8] [The bfloat16 numerical format](https:\/\/cloud.google.com\/tpu\/docs\/bfloat16)","__index_level_0__":2031}
+{"text":"[9] [Exploring Plain Vision Transformer Backbones for Object Detection](https:\/\/arxiv.org\/abs\/2203.16527)","__index_level_0__":2032}
+{"text":"[10] [MViTv2: Improved Multiscale Vision Transformers for Classification and Detection](https:\/\/arxiv.org\/abs\/2112.01526)","__index_level_0__":2033}
+{"text":"[11] [https:\/\/www.deepmind.com\/open-source\/kinetics](https:\/\/www.deepmind.com\/open-source\/kinetics)","__index_level_0__":2034}
+{"text":"[12] [Getting Started with Distributed Data Parallel (DDP)](https:\/\/pytorch.org\/tutorials\/intermediate\/ddp_tutorial.html) \n source: https:\/\/pytorch.org\/blog\/scaling-vision-model-training-platforms-with-pytorch\/ \n category: pytorch blogs","__index_level_0__":2035}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Announcing PyTorch Ecosystem Day'\nauthor: Team PyTorch\n---","__index_level_0__":2036}
+{"text":"We\u2019re proud to announce our first PyTorch Ecosystem Day. The virtual, one-day event will focus completely on our Ecosystem and Industry PyTorch communities!","__index_level_0__":2037}
+{"text":"\nPyTorch is a deep learning framework of choice for academics and companies, all thanks to its rich ecosystem of tools and strong community. As with our developers, our ecosystem partners play a pivotal role in the development and growth of the community.","__index_level_0__":2038}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/ecosystem_day.png\" width=\"100%\">\n<\/div>","__index_level_0__":2039}
+{"text":"We will be hosting our first PyTorch Ecosystem Day, a virtual event designed for our ecosystem and industry communities to showcase their work and discover new opportunities to collaborate. \n \nPyTorch Ecosystem Day will be held on April 21, with both a morning and evening session, to ensure we reach our global community. Join us virtually for a day filled with discussions on new developments, trends, challenges, and best practices through keynotes, breakout sessions, and a unique networking opportunity hosted through Gather.Town . ","__index_level_0__":2040}
+{"text":"## Event Details\nApril 21, 2021 (Pacific Time)\nFully digital experience \n \n* Morning Session: (EMEA)\nOpening Talks - 8:00 am-9:00 am PT\nPoster Exhibition & Breakout Sessions - 9:00 am-12:00 pm PT  ","__index_level_0__":2041}
+{"text":"* Evening Session (APAC\/US)\nOpening Talks - 3:00 pm-4:00 pm PT\nPoster Exhibition & Breakout Sessions - 3:00 pm-6:00 pm PT  ","__index_level_0__":2042}
+{"text":"* Networking - 9:00 am-7:00 pm PT","__index_level_0__":2043}
+{"text":"### There are two ways to participate in PyTorch Ecosystem Day:\n \n1. **Poster Exhibition** from the PyTorch ecosystem and industry communities covering a variety of topics. Posters are available for viewing throughout the duration of the event. To be part of the poster exhibition, please see below for submission details. If your poster is accepted, we highly recommend tending your poster during one of the morning or evening sessions or both!\n \n2. **Breakout Sessions** are 40-min sessions freely designed by the community. The breakouts can be talks, demos, tutorials or discussions. Note: you must have an accepted poster to apply for the breakout sessions.","__index_level_0__":2044}
+{"text":"Call for posters now open! [Submit your proposal](https:\/\/pytorchecosystemday.fbreg.com\/posters) today! Please send us the **title** and **summary** of your projects, tools, and libraries that could benefit PyTorch researchers in academia and industry, application developers, and ML engineers for consideration. The focus must be on academic papers, machine learning research, or open-source projects. Please no sales pitches. **Deadline for submission is March 18, 2021.** ","__index_level_0__":2045}
+{"text":"Visit [pytorchecosystemday.fbreg.com](http:\/\/pytorchecosystemday.fbreg.com) for more information and we look forward to welcoming you to PyTorch Ecosystem Day on April 21st!","__index_level_0__":2046}
+{"text":"\n \n source: https:\/\/pytorch.org\/blog\/ecosystem_day_2021\/ \n category: pytorch blogs","__index_level_0__":2047}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 1.5 released, new and updated APIs including C++ frontend API parity with Python'\nauthor: Team PyTorch\n---","__index_level_0__":2048}
+{"text":"\nToday, we\u2019re announcing the availability of PyTorch 1.5, along with new and updated libraries. This release includes several major new API additions and improvements. PyTorch now includes a significant update to the C++ frontend, \u2018channels last\u2019 memory format for computer vision models, and a stable release of the distributed RPC framework used for model-parallel training. The release also has new APIs for autograd for hessians and jacobians, and an API that allows the creation of Custom C++ Classes that was inspired by pybind.","__index_level_0__":2049}
+{"text":"You can find the detailed release notes [here](https:\/\/github.com\/pytorch\/pytorch\/releases).","__index_level_0__":2050}
+{"text":"## C++ Frontend API (Stable)","__index_level_0__":2051}
+{"text":"The C++ frontend API is now at parity with Python, and the features overall have been moved to \u2018stable\u2019 (previously tagged as experimental). Some of the major highlights include:","__index_level_0__":2052}
+{"text":"* Now with ~100% coverage and docs for C++ torch::nn module\/functional, users can easily translate their model from Python API to C++ API, making the model authoring experience much smoother.\n* Optimizers in C++ had deviated from the Python equivalent: C++ optimizers can\u2019t take parameter groups as input while the Python ones can. Additionally, step function implementations were not exactly the same. With the 1.5 release, C++ optimizers will always behave the same as the Python equivalent.\n* The lack of tensor multi-dim indexing API in C++ is a well-known issue and had resulted in many posts in PyTorch Github issue tracker and forum. The previous workaround was to use a combination of `narrow` \/ `select` \/ `index_select` \/ `masked_select`, which was clunky and error-prone compared to the Python API\u2019s elegant `tensor[:, 0, ..., mask]` syntax. With the 1.5 release, users can use `tensor.index({Slice(), 0, \"...\", mask})` to achieve the same purpose.","__index_level_0__":2053}
+{"text":"## \u2018Channels last\u2019 memory format for Computer Vision models (Experimental)","__index_level_0__":2054}
+{"text":"\u2018Channels last\u2019 memory layout unlocks ability to use performance efficient convolution algorithms and hardware (NVIDIA\u2019s Tensor Cores, FBGEMM, QNNPACK). Additionally, it is designed to automatically propagate through the operators, which allows easy switching between memory layouts.","__index_level_0__":2055}
+{"text":"Learn more [here](https:\/\/github.com\/pytorch\/pytorch\/wiki\/Writing-memory-format-aware-operators) on how to write memory format aware operators.","__index_level_0__":2056}
+{"text":"## Custom C++ Classes (Experimental)","__index_level_0__":2057}
+{"text":"This release adds a new API, `torch::class_`, for binding custom C++ classes into TorchScript and Python simultaneously. This API is almost identical in syntax to [pybind11](https:\/\/pybind11.readthedocs.io\/en\/stable\/). It allows users to expose their C++ class and its methods to the TorchScript type system and runtime system such that they can instantiate and manipulate arbitrary C++ objects from TorchScript and Python. An example C++ binding:","__index_level_0__":2058}
+{"text":"```python\ntemplate <class T>\nstruct MyStackClass : torch::CustomClassHolder {\n  std::vector<T> stack_;\n  MyStackClass(std::vector<T> init) : stack_(std::move(init)) {}","__index_level_0__":2059}
+{"text":"  void push(T x) {\n    stack_.push_back(x);\n  }\n  T pop() {\n    auto val = stack_.back();\n    stack_.pop_back();\n    return val;\n  }\n};","__index_level_0__":2060}
+{"text":"static auto testStack =\n  torch::class_<MyStackClass<std::string>>(\"myclasses\", \"MyStackClass\")\n      .def(torch::init<std::vector<std::string>>())\n      .def(\"push\", &MyStackClass<std::string>::push)\n      .def(\"pop\", &MyStackClass<std::string>::pop)\n      .def(\"size\", [](const c10::intrusive_ptr<MyStackClass>& self) {\n        return self->stack_.size();\n      });\n```","__index_level_0__":2061}
+{"text":" Which exposes a class you can use in Python and TorchScript like so:","__index_level_0__":2062}
+{"text":"```python\n@torch.jit.script\ndef do_stacks(s : torch.classes.myclasses.MyStackClass):\n    s2 = torch.classes.myclasses.MyStackClass([\"hi\", \"mom\"])\n    print(s2.pop()) # \"mom\"\n    s2.push(\"foobar\")\n    return s2 # [\"hi\", \"foobar\"]\n```","__index_level_0__":2063}
+{"text":"You can try it out in the tutorial [here](https:\/\/pytorch.org\/tutorials\/advanced\/torch_script_custom_classes.html).","__index_level_0__":2064}
+{"text":"\n## Distributed RPC framework APIs (Now Stable)","__index_level_0__":2065}
+{"text":"The Distributed [RPC framework](https:\/\/pytorch.org\/docs\/stable\/rpc.html) was launched as experimental in the 1.4 release and the proposal is to mark Distributed RPC framework as stable and no longer experimental. This work involves a lot of enhancements and bug fixes to make the distributed RPC framework more reliable and robust overall, as well as adding a couple of new features, including profiling support, using TorchScript functions in RPC, and several enhancements for ease of use. Below is an overview of the various APIs within the framework:","__index_level_0__":2066}
+{"text":"### RPC API\nThe RPC API allows users to specify functions to run and objects to be instantiated on remote nodes. These functions are transparently recorded so that gradients can backpropagate through remote nodes using Distributed Autograd.","__index_level_0__":2067}
+{"text":"### Distributed Autograd\nDistributed Autograd connects the autograd graph across several nodes and allows gradients to flow through during the backwards pass. Gradients are accumulated into a context (as opposed to the .grad field as with Autograd) and users must specify their model\u2019s forward pass under a with `dist_autograd.context()` manager in order to ensure that all RPC communication is recorded properly. Currently, only FAST mode is implemented (see [here](https:\/\/pytorch.org\/docs\/stable\/rpc\/distributed_autograd.html#distributed-autograd-design) for the difference between FAST and SMART modes).","__index_level_0__":2068}
+{"text":"### Distributed Optimizer\nThe distributed optimizer creates RRefs to optimizers on each worker with parameters that require gradients, and then uses the RPC API to run the optimizer remotely. The user must collect all remote parameters and wrap them in an `RRef`, as this is required input to the distributed optimizer. The user must also specify the distributed autograd `context_id` so that the optimizer knows in which context to look for gradients.","__index_level_0__":2069}
+{"text":"Learn more about distributed RPC framework APIs [here](https:\/\/pytorch.org\/docs\/stable\/rpc.html).","__index_level_0__":2070}
+{"text":"## New High level autograd API (Experimental)","__index_level_0__":2071}
+{"text":"PyTorch 1.5 brings new functions including jacobian, hessian, jvp, vjp, hvp and vhp to the `torch.autograd.functional` submodule. This feature builds on the current API and allows the user to easily perform these functions.","__index_level_0__":2072}
+{"text":"Detailed design discussion on GitHub can be found [here](https:\/\/github.com\/pytorch\/pytorch\/issues\/30632).","__index_level_0__":2073}
+{"text":"## Python 2 no longer supported","__index_level_0__":2074}
+{"text":"Starting PyTorch 1.5.0, we will no longer support Python 2, specifically version 2.7. Going forward support for Python will be limited to Python 3, specifically Python 3.5, 3.6, 3.7 and 3.8 (first enabled in PyTorch 1.4.0).","__index_level_0__":2075}
+{"text":"\n*We\u2019d like to thank the entire PyTorch team and the community for all their contributions to this work.*","__index_level_0__":2076}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1-dot-5-released-with-new-and-updated-apis\/ \n category: pytorch blogs","__index_level_0__":2078}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'OpenMined and PyTorch partner to launch fellowship funding for privacy-preserving ML community'\nauthor: Andrew Trask (OpenMined\/U.Oxford), Shubho Sengupta, Laurens van der Maaten, Joe Spisak\nexcerpt: Many applications of machine learning (ML) pose a range of security and privacy challenges.\n---","__index_level_0__":2079}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/openmined-pytorch.png\" width=\"100%\">\n<\/div>","__index_level_0__":2080}
+{"text":"Many applications of machine learning (ML) pose a range of security and privacy challenges. In particular, users may not be willing or allowed to share their data, which prevents them from taking full advantage of ML platforms like PyTorch. To take the field of privacy-preserving ML (PPML) forward, OpenMined and PyTorch are announcing plans to jointly develop a combined platform to accelerate PPML research as well as new funding for fellowships.","__index_level_0__":2081}
+{"text":"There are many techniques attempting to solve the problem of privacy in ML, each at various levels of maturity. These include (1) homomorphic encryption, (2) secure multi-party computation, (3) trusted execution environments, (4) on-device computation, (5) federated learning with secure aggregation, and (6) differential privacy. Additionally, a number of open source projects implementing these techniques were created with the goal of enabling research at the intersection of privacy, security, and ML. Among them, PySyft and CrypTen have taken an \u201cML-first\u201d approach by presenting an API that is familiar to the ML community, while masking the complexities of privacy and security protocols. We are excited to announce that these two projects are now collaborating closely to build a mature PPML ecosystem around PyTorch.","__index_level_0__":2082}
+{"text":"Additionally, to bolster this ecosystem and take the field of privacy preserving ML forward, we are also calling for contributions and supporting research efforts on this combined platform by providing funding to support the OpenMined community and the researchers that contribute, build proofs of concepts and desire to be on the cutting edge of how privacy-preserving technology is applied. We will provide funding through the [RAAIS Foundation](https:\/\/www.raais.org\/), a non-profit organization with a mission to advance education and research in artificial intelligence for the common good. We encourage interested parties to apply to one or more of the fellowships listed below.","__index_level_0__":2083}
+{"text":"## Tools Powering the Future of Privacy-Preserving ML","__index_level_0__":2084}
+{"text":"The next generation of privacy-preserving open source tools enable ML researchers to easily experiment with ML models using secure computing techniques without needing to be cryptography experts. By integrating with PyTorch, PySyft and CrypTen offer familiar environments for ML developers to research and apply these techniques as part of their work.","__index_level_0__":2085}
+{"text":"**PySyft** is a Python library for secure and private ML developed by the OpenMined community. It is a flexible, easy-to-use library that makes secure computation techniques like [multi-party computation (MPC)](https:\/\/en.wikipedia.org\/wiki\/Secure_multi-party_computation) and privacy-preserving techniques like [differential privacy](https:\/\/en.wikipedia.org\/wiki\/Differential_privacy) accessible to the ML community. It prioritizes ease of use and focuses on integrating these techniques into end-user use cases like federated learning with mobile phones and other edge devices, encrypted ML as a service, and privacy-preserving data science.","__index_level_0__":2086}
+{"text":"**CrypTen** is a framework built on PyTorch that enables private and secure ML for the PyTorch community. It is the first step along the journey towards a privacy-preserving mode in PyTorch that will make secure computing techniques accessible beyond cryptography researchers. It currently implements [secure multiparty computation](https:\/\/en.wikipedia.org\/wiki\/Secure_multi-party_computation) with the goal of offering other secure computing backends in the near future. Other benefits to ML researchers include:","__index_level_0__":2087}
+{"text":"* It is **ML first** and presents secure computing techniques via a CrypTensor object that looks and feels exactly like a PyTorch Tensor. This allows the user to use automatic differentiation and neural network modules akin to those in PyTorch.\n* The framework focuses on **scalability and performance** and is built with real-world challenges in mind.","__index_level_0__":2088}
+{"text":"The focus areas for CrypTen and PySyft are naturally aligned and complement each other. The former focuses on building support for various secure and privacy preserving techniques on PyTorch through an encrypted tensor abstraction, while the latter focuses on end user use cases like deployment on edge devices and a user friendly data science platform.","__index_level_0__":2089}
+{"text":"Working together will enable PySyft to use CrypTen as a backend for encrypted tensors. This can lead to an increase in performance for PySyft and the adoption of CrypTen as a runtime by PySyft\u2019s userbase. In addition to this, PyTorch is also adding cryptography friendly features such as support for cryptographically secure random number generation. Over the long run, this allows each library to focus exclusively on its core competencies while enjoying the benefits of the synergistic relationship.","__index_level_0__":2090}
+{"text":"## New Funding for OpenMined Contributors","__index_level_0__":2091}
+{"text":"We are especially excited to announce that the PyTorch team has invested $250,000 to support OpenMined in furthering the development and proliferation of privacy-preserving ML. This gift will be facilitated via the [RAAIS Foundation](https:\/\/www.raais.org\/) and will be available immediately to support paid fellowship grants for the OpenMined community.","__index_level_0__":2092}
+{"text":"## How to get involved","__index_level_0__":2093}
+{"text":"Thanks to the support from the PyTorch team, OpenMined is able to offer three different opportunities for you to participate in the project\u2019s development. Each of these fellowships furthers our shared mission to lower the barrier-to-entry for privacy-preserving ML and to create a more privacy-preserving world.","__index_level_0__":2094}
+{"text":"### Core PySyft CrypTen Integration Fellowships","__index_level_0__":2095}
+{"text":"During these fellowships, we will integrate CrypTen as a supported backend for encrypted computation in PySyft. This will allow for the high-performance, secure multi-party computation capabilities of CrypTen to be used alongside other important tools in PySyft such as differential privacy and federated learning. For more information on the roadmap and how to apply for a paid fellowship, check out the project\u2019s [call for contributors](https:\/\/blog.openmined.org\/openmined-pytorch-fellowship-crypten-project).","__index_level_0__":2096}
+{"text":"### Federated Learning on Mobile, Web, and IoT Devices","__index_level_0__":2097}
+{"text":"During these fellowships, we will be extending PyTorch with the ability to perform federated learning across mobile, web, and IoT devices. To this end, a PyTorch front-end will be able to coordinate across federated learning backends that run in Javascript, Kotlin, Swift, and Python. Furthermore, we will also extend PySyft with the ability to coordinate these backends using peer-to-peer connections, providing low latency and the ability to run secure aggregation as a part of the protocol. For more information on the roadmap and how to apply for a paid fellowship, check out the project\u2019s [call for contributors](https:\/\/blog.openmined.org\/announcing-the-pytorch-openmined-federated-learning-fellowships).","__index_level_0__":2098}
+{"text":"### Development Challenges","__index_level_0__":2099}
+{"text":"Over the coming months, we will issue regular open competitions for increasing the performance and security of the PySyft and PyGrid codebases. For performance-related challenges, contestants will compete (for a cash prize) to make a specific PySyft demo (such as federated learning) as fast as possible. For security-related challenges, contestants will compete to hack into a PyGrid server. The first to demonstrate their ability will win the cash bounty! For more information on the challenges and to sign up to receive emails when each challenge is opened, [sign up here](http:\/\/blog.openmined.org\/announcing-the-openmined-pytorch-development-challenges).","__index_level_0__":2100}
+{"text":"To apply, select one of the above projects and identify a role that matches your strengths!","__index_level_0__":2101}
+{"text":"Andrew, Laurens, Joe, and Shubho\n \n source: https:\/\/pytorch.org\/blog\/openmined-and-pytorch-launch-fellowship-funding-for-privacy-preserving-ml\/ \n category: pytorch blogs","__index_level_0__":2103}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'How Computational Graphs are Constructed in PyTorch'\nauthor: Preferred Networks\nfeatured-img: 'assets\/images\/augmented_computational_graph.png'\n---","__index_level_0__":2104}
+{"text":"In the previous [post](https:\/\/pytorch.org\/blog\/overview-of-pytorch-autograd-engine\/) we went over the theoretical foundations of automatic differentiation and reviewed the implementation in PyTorch. In this post, we will be showing the parts of PyTorch involved in creating the graph and executing it. In order to understand the following contents, please read @ezyang\u2019s wonderful [blog post](http:\/\/blog.ezyang.com\/2019\/05\/pytorch-internals\/) about PyTorch internals.","__index_level_0__":2105}
+{"text":"# Autograd components","__index_level_0__":2106}
+{"text":"First of all, let\u2019s look at where the different components of autograd live:","__index_level_0__":2107}
+{"text":"[tools\/autograd](https:\/\/github.com\/pytorch\/pytorch\/tree\/release\/1.9\/tools\/autograd): Here we can find the definition of the derivatives as we saw in the previous post [derivatives.yaml](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.9\/tools\/autograd\/derivatives.yaml), several python scripts and a folder called [templates](https:\/\/github.com\/pytorch\/pytorch\/tree\/release\/1.9\/tools\/autograd\/templates). These scripts and the templates are used at building time to generate the C++ code for the derivatives as specified in the yaml file. Also, the scripts here generate wrappers for the regular ATen functions so that the computational graph can be constructed.","__index_level_0__":2108}
+{"text":"[torch\/autograd](https:\/\/github.com\/pytorch\/pytorch\/tree\/release\/1.9\/torch\/autograd): This folder is where the autograd components that can be used directly from python are located. In [function.py](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.9\/torch\/autograd\/function.py) we find the actual definition of  `torch.autograd.Function`, a class used by users to write their own differentiable functions in python as per the documentation. [functional.py](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.9\/torch\/autograd\/functional.py) holds components for functionally computing the jacobian vector product, hessian, and other gradient related computations of a given function.\nThe rest of the files have additional components such as gradient checkers, anomaly detection, and the autograd profiler.","__index_level_0__":2109}
+{"text":"[torch\/csrc\/autograd](https:\/\/github.com\/pytorch\/pytorch\/tree\/release\/1.9\/torch\/csrc\/autograd): This is where the graph creation and execution-related code lives.\nAll this code is written in C++, since it is a critical part that is required to be extremely performant. Here we have several files that implement the engine, metadata storage, and all the needed components. Alongside this, we have several files whose names start with `python_`, and their main responsibility is to allow python objects to be used in the autograd engine.","__index_level_0__":2110}
+{"text":"# Graph Creation","__index_level_0__":2111}
+{"text":"[Previously](https:\/\/pytorch.org\/blog\/overview-of-pytorch-autograd-engine\/), we described the creation of a computational graph. Now, we will see how PyTorch creates these graphs with references to the actual codebase.","__index_level_0__":2112}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/augmented_computational_graph.png\" width=\"100%\">\n<br>\nFigure 1: Example of an augmented computational graph\n<\/p>","__index_level_0__":2113}
+{"text":"It all starts when in our python code, where we request a tensor to require the gradient.","__index_level_0__":2114}
+{"text":"```py\n>>> x = torch.tensor([0.5, 0.75], requires_grad=True)\n```","__index_level_0__":2115}
+{"text":"When the `required_grad` flag is set in tensor creation, c10 will [allocate](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/c10\/core\/TensorImpl.cpp#L382-L406) an `AutogradMeta` object that is used to hold the graph information.","__index_level_0__":2116}
+{"text":"void TensorImpl::set_requires_grad(bool requires_grad) {\n  ...\n  if (!autograd_meta_)\n    autograd_meta_ = impl::GetAutogradMetaFactory()->make();\n    autograd_meta_->set_requires_grad(requires_grad, this);\n}\n```","__index_level_0__":2118}
+{"text":"\nThe `AutogradMeta` object is defined in [torch\/csrc\/autograd\/variable.h](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.9\/torch\/csrc\/autograd\/variable.h#L190-L286) as follows:","__index_level_0__":2119}
+{"text":"struct TORCH_API AutogradMeta : public c10::AutogradMetaInterface {\n  std::string name_;","__index_level_0__":2121}
+{"text":"  Variable grad_;\n  std::shared_ptr<Node> grad_fn_;\n  std::weak_ptr<Node> grad_accumulator_;\n  \/\/ other fields and methods\n  ...\n};\n```","__index_level_0__":2122}
+{"text":"The most important fields in this structure are the computed gradient in `grad_` and a pointer to the function `grad_fn` that will be called by the engine to produce the actual gradient. Also, there is a gradient accumulator object that is used to add together all the different gradients where this tensor is involved as we will see in the graph execution.","__index_level_0__":2123}
+{"text":"### Graphs, Nodes and Edges.","__index_level_0__":2124}
+{"text":"Now, when we call a differentiable function that takes this tensor as an argument, the associated metadata will be populated. Let\u2019s suppose that we call a regular torch function that is implemented in ATen. Let it be the multiplication as in our previous blog post example. The resulting tensor has a field called `grad_fn` that is essentially a pointer to the function that will be used to compute the gradient of that operation.","__index_level_0__":2125}
+{"text":"```py\n>>> x = torch.tensor([0.5, 0.75], requires_grad=True)\n>>> v = x[0] * x[1]\n>>> v\ntensor(0.3750, grad_fn=<MulBackward0>)\n```","__index_level_0__":2126}
+{"text":"Here we see that the tensors\u2019 `grad_fn` has a `MulBackward0` value. This function is the same that was written in the [derivatives.yaml](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/tools\/autograd\/derivatives.yaml#L840-L843) file, and its C++ code was generated automatically by all the scripts in `tools\/autograd`. It\u2019s auto-generated source code can be seen in `torch\/csrc\/autograd\/generated\/Functions.cpp`.","__index_level_0__":2127}
+{"text":"```c++\nvariable_list MulBackward0::apply(variable_list&& grads) {\n  std::lock_guard<std::mutex> lock(mutex_);","__index_level_0__":2128}
+{"text":"  IndexRangeGenerator gen;\n  auto self_ix = gen.range(1);\n  auto other_ix = gen.range(1);\n  variable_list grad_inputs(gen.size());\n  auto& grad = grads[0];\n  auto self = self_.unpack();\n  auto other = other_.unpack();\n  bool any_grad_defined = any_variable_defined(grads);\n  if (should_compute_output({ other_ix })) {\n    auto grad_result = any_grad_defined ? (mul_tensor_backward(grad, self, other_scalar_type)) : Tensor();\n    copy_range(grad_inputs, other_ix, grad_result);\n  }\n  if (should_compute_output({ self_ix })) {\n    auto grad_result = any_grad_defined ? (mul_tensor_backward(grad, other, self_scalar_type)) : Tensor();\n    copy_range(grad_inputs, self_ix, grad_result);\n  }\n  return grad_inputs;\n}\n```","__index_level_0__":2129}
+{"text":"The `grad_fn` objects inherit from the [`TraceableFunction`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/function.h#L535-L541) class, a descendant of  `Node` with just a property set to enable tracing for debugging and optimization purposes. A graph by definition has nodes and edges, so these functions are indeed the nodes of the computational graph that are linked together by using `Edge` objects to enable the graph traversal later on.","__index_level_0__":2130}
+{"text":"The `Node` definition can be found in the [torch\/csrc\/autograd\/function.h](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/function.h#L50-L533) file.","__index_level_0__":2131}
+{"text":"```c++\nstruct TORCH_API Node : std::enable_shared_from_this<Node> {\n ...\n \/\/\/ Evaluates the function on the given inputs and returns the result of the\n  \/\/\/ function call.\n  variable_list operator()(variable_list&& inputs) {\n  ...\n  }","__index_level_0__":2132}
+{"text":"protected:\n  \/\/\/ Performs the `Node`'s actual operation.\n  virtual variable_list apply(variable_list&& inputs) = 0;\n  \u2026\n  edge_list next_edges_;\n```","__index_level_0__":2133}
+{"text":"Essentially we see that it has an override of the `operator ()` that performs the call to the actual function, and a pure virtual function called `apply`. The automatically generated functions override this `apply` method as we saw in the `MulBackward0` example above. Finally, the node also has a list of edges to enable graph connectivity.","__index_level_0__":2134}
+{"text":"The [Edge](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/edge.h#L14-L39) object is used to link `Node`s together and its implementation is straightforward.","__index_level_0__":2135}
+{"text":"```c++\nstruct Edge {\n  ...\n  \/\/\/ The function this `Edge` points to.\n  std::shared_ptr<Node> function;\n  \/\/\/ The identifier of a particular input to the function.\n  uint32_t input_nr;\n};\n```","__index_level_0__":2136}
+{"text":"It only requires a function pointer (the actual `grad_fn` objects that the edges link together), and an input number that acts as an id for the edge.","__index_level_0__":2137}
+{"text":"### Linking nodes together","__index_level_0__":2138}
+{"text":"When we invoke the product operation of two tensors, we enter into the realm of autogenerated code. All the scripts that we saw in `tools\/autograd` fill a series of templates that wrap the differentiable functions in ATen. These functions have code to construct the backward graph during the forward pass.","__index_level_0__":2139}
+{"text":"The [gen_variable_type.py](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.9\/tools\/autograd\/gen_variable_type.py) script is in charge of writing all this wrapping code. This script is called from the [tools\/autograd\/gen_autograd.py](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.9\/tools\/autograd\/gen_autograd.py) during the pytorch build process and it will output the automatically generated function wrappers to `torch\/csrc\/autograd\/generated\/`.","__index_level_0__":2140}
+{"text":"Let\u2019s take a look at how the tensor multiplication generated function looks like. The code has been simplified, but it can be found in the `torch\/csrc\/autograd\/generated\/VariableType_4.cpp` file when compiling pytorch from source.","__index_level_0__":2142}
+{"text":"```c++\nat::Tensor mul_Tensor(c10::DispatchKeySet ks, const at::Tensor & self, const at::Tensor & other) {\n  ...\n  auto _any_requires_grad = compute_requires_grad( self, other );\n  std::shared_ptr<MulBackward0> grad_fn;\n  if (_any_requires_grad) {\n    \/\/ Creates the link to the actual grad_fn and links the graph for backward traversal\n    grad_fn = std::shared_ptr<MulBackward0>(new MulBackward0(), deleteNode);\n    grad_fn->set_next_edges(collect_next_edges( self, other ));\n    ...\n  }\n  \u2026\n  \/\/ Does the actual function call to ATen\n  auto _tmp = ([&]() {\n    at::AutoDispatchBelowADInplaceOrView guard;\n    return at::redispatch::mul(ks & c10::after_autograd_keyset, self_, other_);\n  })();","__index_level_0__":2143}
+{"text":"  auto result = std::move(_tmp);\n    if (grad_fn) {\n       \/\/ Connects the result to the graph\n      set_history(flatten_tensor_args( result ), grad_fn);\n  }\n  ...\n  return result;\n}\n```","__index_level_0__":2144}
+{"text":"Let\u2019s walk through the most important lines of this code.\nFirst of all, the `grad_fn` object is created with: ` grad_fn = std::shared_ptr<MulBackward0>(new MulBackward0(), deleteNode);`.","__index_level_0__":2145}
+{"text":"After the `grad_fn` object is created, the edges used to link the nodes together are created by using the `grad_fn->set_next_edges(collect_next_edges( self, other ));` calls.","__index_level_0__":2146}
+{"text":"```c++\nstruct MakeNextFunctionList : IterArgs<MakeNextFunctionList> {\n  edge_list next_edges;\n  using IterArgs<MakeNextFunctionList>::operator();\n  void operator()(const Variable& variable) {\n    if (variable.defined()) {\n      next_edges.push_back(impl::gradient_edge(variable));\n    } else {\n      next_edges.emplace_back();\n    }\n  }\n  void operator()(const c10::optional<Variable>& variable) {\n    if (variable.has_value() && variable->defined()) {\n      next_edges.push_back(impl::gradient_edge(*variable));\n    } else {\n      next_edges.emplace_back();\n    }\n  }\n};","__index_level_0__":2147}
+{"text":"template <typename... Variables>\nedge_list collect_next_edges(Variables&&... variables) {\n  detail::MakeNextFunctionList make;\n  make.apply(std::forward<Variables>(variables)...);\n  return std::move(make.next_edges);\n}\n```","__index_level_0__":2148}
+{"text":"Given an input variable (it\u2019s just a regular tensor), [`collect_next_edges`](\nhttps:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/function.h#L597-L603)\n will create an `Edge` object by calling [`impl::gradient_edge`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/variable.cpp#L228-L240.)","__index_level_0__":2149}
+{"text":"```c++\n Edge gradient_edge(const Variable& self) {\n    \/\/ If grad_fn is null (as is the case for a leaf node), we instead\n    \/\/ interpret the gradient function to be a gradient accumulator, which will\n    \/\/ accumulate its inputs into the grad property of the variable. These\n    \/\/ nodes get suppressed in some situations, see \"suppress gradient\n    \/\/ accumulation\" below. Note that only variables which have `requires_grad =\n    \/\/ True` can have gradient accumulators.\n    if (const auto& gradient = self.grad_fn()) {\n      return Edge(gradient, self.output_nr());\n    } else {\n      return Edge(grad_accumulator(self), 0);\n    }\n  }\n```","__index_level_0__":2150}
+{"text":"To understand how edges work, let\u2019s assume that an early executed function produced two output tensors, both with their `grad_fn` set, each tensor also has an `output_nr` property with the order in which they were returned. When creating the edges for the current `grad_fn`, an `Edge` object per input variable will be created. The edges will point to the variable\u2019s grad_fn and will also track the `output_nr` to establish ids used when traversing the graph. In the case that the input variables are \u201cleaf\u201d, i.e. they were not produced by any differentiable function, they don\u2019t have a `grad_fn` attribute set. A special function called a gradient accumulator is set by default as seen in the above code snippet.","__index_level_0__":2151}
+{"text":"After the edges are created, the `grad_fn` graph Node object that is being currently created will hold them using the [`set_next_edges`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/function.h#L258-L263) function. This is what connects `grad_fn`s together, producing the computational graph.","__index_level_0__":2152}
+{"text":"```c++\n void set_next_edges(edge_list&& next_edges) {\n    next_edges_ = std::move(next_edges);\n    for(const auto& next_edge : next_edges_) {\n      update_topological_nr(next_edge);\n    }\n  }\n```","__index_level_0__":2153}
+{"text":"Now, the forward pass of the function will execute, and after the execution  `set_history` will connect the output tensors to the `grad_fn` Node. ","__index_level_0__":2154}
+{"text":"```c++\ninline void set_history(\n    at::Tensor& variable,\n    const std::shared_ptr<Node>& grad_fn) {\n  AT_ASSERT(grad_fn);\n  if (variable.defined()) {\n    \/\/ If the codegen triggers this, you most likely want to add your newly added function\n    \/\/ to the DONT_REQUIRE_DERIVATIVE list in tools\/autograd\/gen_variable_type.py\n    TORCH_INTERNAL_ASSERT(isDifferentiableType(variable.scalar_type()));\n    auto output_nr =\n        grad_fn->add_input_metadata(variable);\n    impl::set_gradient_edge(variable, {grad_fn, output_nr});\n  } else {\n    grad_fn->add_input_metadata(Node::undefined_input());\n  }\n}\n```","__index_level_0__":2155}
+{"text":"[`set_history`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/functions\/utils.h#L58-L72) calls [`set_gradient_edge`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/variable.cpp#L242-L255), which just copies the grad_fn and the `output_nr` to the `AutogradMeta` object that the tensor has.","__index_level_0__":2156}
+{"text":"```c++\n void set_gradient_edge(const Variable& self, Edge edge) {\n    auto* meta = materialize_autograd_meta(self);\n    meta->grad_fn_ = std::move(edge.function);\n    meta->output_nr_ = edge.input_nr;\n    \/\/ For views, make sure this new grad_fn_ is not overwritten unless it is necessary\n    \/\/ in the VariableHooks::grad_fn below.\n    \/\/ This logic is only relevant for custom autograd Functions for which multiple\n    \/\/ operations can happen on a given Tensor before its gradient edge is set when\n    \/\/ exiting the custom Function.\n    auto diff_view_meta = get_view_autograd_meta(self);\n    if (diff_view_meta && diff_view_meta->has_bw_view()) {\n      diff_view_meta->set_attr_version(self._version());\n    }\n  }\n```","__index_level_0__":2157}
+{"text":"This tensor now will be the input to another function and the above steps will be all repeated. Check the animation below to see how the graph is created.","__index_level_0__":2158}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/computational_graph_creation.gif\" width=\"100%\">\n<br>\nFigure 2: Animation that shows the graph creation\n<\/p>","__index_level_0__":2159}
+{"text":"### Registering Python Functions in the graph","__index_level_0__":2160}
+{"text":"We have seen how autograd creates the graph for the functions included in ATen. However, when we define our differentiable functions in Python, they are also included in the graph!","__index_level_0__":2161}
+{"text":"An autograd python defined function looks like the following:","__index_level_0__":2162}
+{"text":"```python\nclass Exp(torch.autograd.Function):\n     @staticmethod\n     def forward(ctx, i):\n         result = i.exp()\n         ctx.save_for_backward(result)\n         return result","__index_level_0__":2163}
+{"text":"     @staticmethod\n     def backward(ctx, grad_output):\n         result, = ctx.saved_tensors\n         return grad_output * result","__index_level_0__":2164}
+{"text":"# Call the function\nExp.apply(torch.tensor(0.5, requires_grad=True))\n# Outputs: tensor(1.6487, grad_fn=<ExpBackward>)\n```","__index_level_0__":2165}
+{"text":"In the above snippet autograd detected our python function when creating the graph. All of this is possible thanks to the [`Function`](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.9\/torch\/autograd\/function.py#L106) class. Let\u2019s take a look at what happens when we call `apply`.","__index_level_0__":2166}
+{"text":"`apply` is defined in the [`torch._C._FunctionBase`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/python_function.cpp#L859-L908) class, but this class is not present in the python source. `_FunctionBase` is defined in C++ by using the python C API to hook C functions together into a single python class. We are looking for a function named [`THPFunction_apply`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/python_function.cpp#L577-L633). ","__index_level_0__":2167}
+{"text":"PyObject *THPFunction_apply(PyObject *cls, PyObject *inputs)\n{\n  \n  \/\/ Generates the graph node\n  THPObjectPtr backward_cls(PyObject_GetAttrString(cls, \"_backward_cls\"));\n  if (!backward_cls) return nullptr;\n  THPObjectPtr ctx_obj(PyObject_CallFunctionObjArgs(backward_cls, nullptr));\n  if (!ctx_obj) return nullptr;\n  THPFunction* ctx = (THPFunction*)ctx_obj.get();","__index_level_0__":2169}
+{"text":"  auto cdata = std::shared_ptr<PyNode>(new PyNode(std::move(ctx_obj)), deleteNode);\n  ctx->cdata = cdata;","__index_level_0__":2170}
+{"text":"  \/\/ Prepare inputs and allocate context (grad fn)\n  \/\/ Unpack inputs will collect the edges\n  auto info_pair = unpack_input<false>(inputs);\n  UnpackedInput& unpacked_input = info_pair.first;\n  InputFlags& input_info = info_pair.second;","__index_level_0__":2171}
+{"text":"   \/\/ Initialize backward function (and ctx)\n  bool is_executable = input_info.is_executable;\n  cdata->set_next_edges(std::move(input_info.next_edges));\n  ctx->needs_input_grad = input_info.needs_input_grad.release();\n  ctx->is_variable_input = std::move(input_info.is_variable_input);","__index_level_0__":2172}
+{"text":"  \/\/ Prepend ctx to input_tuple, in preparation for static method call\n  auto num_args = PyTuple_GET_SIZE(inputs);\n  THPObjectPtr ctx_input_tuple(PyTuple_New(num_args + 1));\n  if (!ctx_input_tuple) return nullptr;\n  Py_INCREF(ctx);\n  PyTuple_SET_ITEM(ctx_input_tuple.get(), 0, (PyObject*)ctx);\n  for (int i = 0; i < num_args; ++i) {\n    PyObject *arg = PyTuple_GET_ITEM(unpacked_input.input_tuple.get(), i);\n    Py_INCREF(arg);\n    PyTuple_SET_ITEM(ctx_input_tuple.get(), i + 1, arg);\n  }","__index_level_0__":2173}
+{"text":"  \/\/ Call forward\n  THPObjectPtr tensor_outputs;\n  {\n    AutoGradMode grad_mode(false);\n    THPObjectPtr forward_fn(PyObject_GetAttrString(cls, \"forward\"));\n    if (!forward_fn) return nullptr;\n    tensor_outputs = PyObject_CallObject(forward_fn, ctx_input_tuple);\n    if (!tensor_outputs) return nullptr;\n  }","__index_level_0__":2174}
+{"text":"  \/\/ Here is where the outputs gets the tensors tracked\n  return process_outputs(cls, cdata, ctx, unpacked_input, inputs, std::move(tensor_outputs),\n                         is_executable, node);\n  END_HANDLE_TH_ERRORS\n}\n```\n \nAlthough this code is hard to read at first due to all the python API calls, it essentially does the same thing as the auto-generated forward functions that we saw for ATen:","__index_level_0__":2175}
+{"text":"Create a `grad_fn` object.\nCollect the edges to link the current `grad_fn` with the input tensors one.\nExecute the function `forward`.\nAssign the created `grad_fn` to the output tensors metadata.","__index_level_0__":2176}
+{"text":"The `grad_fn` object is created in:","__index_level_0__":2177}
+{"text":"```c++\n  \/\/ Generates the graph node\n  THPObjectPtr backward_cls(PyObject_GetAttrString(cls, \"_backward_cls\"));\n  if (!backward_cls) return nullptr;\n  THPObjectPtr ctx_obj(PyObject_CallFunctionObjArgs(backward_cls, nullptr));\n  if (!ctx_obj) return nullptr;\n  THPFunction* ctx = (THPFunction*)ctx_obj.get();","__index_level_0__":2178}
+{"text":"  auto cdata = std::shared_ptr<PyNode>(new PyNode(std::move(ctx_obj)), deleteNode);\n  ctx->cdata = cdata;\n```","__index_level_0__":2179}
+{"text":"Basically, it asks the python API to get a pointer to the Python object that can execute the user-written function. Then it wraps it into a [`PyNode`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/python_function.h#L24-L58) object that is a specialized `Node` object that calls the python interpreter with the provided python function when `apply` is executed during the forward pass. Note that in the code `cdata` is the actual `Node` object that is part of the graph. `ctx` is the object that is passed to the python `forward`\/`backward` functions and it is used to store autograd related information by both, the user\u2019s function and PyTorch.","__index_level_0__":2180}
+{"text":"As in the regular C++ functions we also call `collect_next_edges` to track the inputs `grad_fn` objects, but this is done in [`unpack_input`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/python_function.cpp#L413-L448):","__index_level_0__":2181}
+{"text":"```c++\ntemplate<bool enforce_variables>\nstd::pair<UnpackedInput, InputFlags> unpack_input(PyObject *args) {\n  ...\n  flags.next_edges = (flags.is_executable ? collect_next_edges(unpacked.input_vars) : edge_list());\n  return std::make_pair(std::move(unpacked), std::move(flags));\n}\n```","__index_level_0__":2182}
+{"text":"After this, the edges are assigned to the `grad_fn` by just doing `cdata->set_next_edges(std::move(input_info.next_edges));` and the forward function is called through the python interpreter C API.","__index_level_0__":2183}
+{"text":"Once the output tensors are returned from the forward pass, they are processed and converted to variables inside the [`process_outputs`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/python_function.cpp#L519-L562) function.","__index_level_0__":2184}
+{"text":"```c++\nPyObject* process_outputs(PyObject *op_obj, const std::shared_ptr<PyNode>& cdata,\n                          THPFunction* grad_fn, const UnpackedInput& unpacked,\n                          PyObject *inputs, THPObjectPtr&& raw_output, bool is_executable,\n                          torch::jit::Node* node) {\n  ...\n  _wrap_outputs(cdata, grad_fn, unpacked.input_vars, raw_output, outputs, is_executable);\n  _trace_post_record(node, op_obj, unpacked.input_vars, outputs, is_inplace, unpack_output);\n  if (is_executable) {\n    _save_variables(cdata, grad_fn);\n  } ...\n  return outputs.release();\n}\n```","__index_level_0__":2185}
+{"text":"Here, [`_wrap_outputs`](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/python_function.cpp#L302-L346) is in charge of setting the forward outputs `grad_fn` to the newly created one. For this, it calls another `_wrap_outputs` function defined in a different [file](https:\/\/github.com\/pytorch\/pytorch\/blob\/e7cd59c7a061c78d8d0265e4308b5933e44f9176\/torch\/csrc\/autograd\/custom_function.cpp#L28-L105), so the process here gets a little confusing.","__index_level_0__":2186}
+{"text":"```c++\nstatic void _wrap_outputs(const std::shared_ptr<PyNode>& cdata, THPFunction *self,\n    const variable_list &input_vars, PyObject *raw_output, PyObject *outputs, bool is_executable)\n{\n  auto cdata_if_executable = is_executable ? cdata : nullptr;\n ...","__index_level_0__":2187}
+{"text":"  \/\/ Wrap only the tensor outputs.\n  \/\/ This calls csrc\/autograd\/custom_function.cpp\n  auto wrapped_outputs = _wrap_outputs(input_vars, non_differentiable, dirty_inputs, raw_output_vars, cdata_if_executable);\n...\n}\n```","__index_level_0__":2188}
+{"text":"The called `_wrap_outputs` is the one in charge of setting the autograd metadata in the output tensors:","__index_level_0__":2189}
+{"text":"```c++\nstd::vector<c10::optional<Variable>> _wrap_outputs(const variable_list &input_vars,\n  const std::unordered_set<at::TensorImpl*> &non_differentiable,\n  const std::unordered_set<at::TensorImpl*> &dirty_inputs,\n  const at::ArrayRef<c10::optional<Variable>> raw_outputs,\n  const std::shared_ptr<Node> &cdata) {","__index_level_0__":2190}
+{"text":"\n  std::unordered_set<at::TensorImpl*> inputs;\n  \u2026\n  \/\/ Sets the grad_fn and output_nr of an output Variable.\n  auto set_history = [&](Variable& var, uint32_t output_nr, bool is_input, bool is_modified,\n                         bool is_differentiable) {\n    \/\/ Lots of checks\n    if (!is_differentiable) {\n     ...\n    } else if (is_input) {\n      \/\/ An input has been returned, but it wasn't modified. Return it as a view\n      \/\/ so that we can attach a new grad_fn to the Variable.\n      \/\/ Run in no_grad mode to mimic the behavior of the forward.\n      {\n        AutoGradMode grad_mode(false);\n        var = var.view_as(var);\n      }\n      impl::set_gradient_edge(var, {cdata, output_nr});\n    } else if (cdata) {\n      impl::set_gradient_edge(var, {cdata, output_nr});\n    }\n  };\n```","__index_level_0__":2191}
+{"text":"And this is where `set_gradient_edge` was called and this is how a user-written python function gets included in the computational graph with its associated backward function!","__index_level_0__":2192}
+{"text":"# Closing remarks","__index_level_0__":2193}
+{"text":"This blog post is intended to be a code overview on how PyTorch constructs the actual computational graphs that we discussed in the previous post. The next entry will deal with how the autograd engine executes these graphs.\n \n source: https:\/\/pytorch.org\/blog\/computational-graphs-constructed-in-pytorch\/ \n category: pytorch blogs","__index_level_0__":2194}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Efficient Multi-Objective Neural Architecture Search with Ax\"\nauthor: David Eriksson, Max Balandat\nfeatured-img: \"\/assets\/images\/MOO-NAS-blog-img2-pareto_frontier_plot.png\"\n---","__index_level_0__":2195}
+{"text":"Multi-Objective Optimization in Ax enables efficient exploration of tradeoffs (e.g. between model performance and model size or latency) in Neural Architecture Search. This method has been successfully applied at Meta for a variety of products such as On-Device AI. In this post, we provide an [end-to-end](https:\/\/pytorch.org\/tutorials\/intermediate\/ax_multiobjective_nas_tutorial.html) tutorial that allows you to try it out yourself.","__index_level_0__":2197}
+{"text":"## Introduction","__index_level_0__":2198}
+{"text":"Neural networks continue to grow in both size and complexity. Developing state-of-the-art architectures is often a cumbersome and time-consuming process that requires both domain expertise and large engineering efforts. In an attempt to overcome these challenges, several Neural Architecture Search (NAS) approaches have been proposed to automatically design well-performing architectures without requiring a human in-the-loop.","__index_level_0__":2199}
+{"text":"Despite being very sample-inefficient, na\u00efve approaches like random search and grid search are still popular for both hyperparameter optimization and NAS (a [study](https:\/\/hal.archives-ouvertes.fr\/hal-02447823\/document) conducted at NeurIPS 2019 and ICLR 2020 found that 80% of NeurIPS papers and 88% of ICLR papers tuned their ML model hyperparameters using manual tuning, random search, or grid search). But as models are often time-consuming to train and may require large amounts of computational resources, minimizing the number of configurations that are evaluated is important.","__index_level_0__":2200}
+{"text":"[Ax](https:\/\/ax.dev\/) is a general tool for black-box optimization that allows users to explore large search spaces in a sample-efficient manner using [state-of-the art algorithms such as Bayesian Optimization](http:\/\/proceedings.mlr.press\/v133\/turner21a\/turner21a.pdf). At Meta, Ax is used in a variety of domains, including hyperparameter tuning, NAS, identifying optimal product settings through large-scale A\/B testing, infrastructure optimization, and designing cutting-edge AR\/VR hardware.","__index_level_0__":2201}
+{"text":"In many NAS applications, there is a natural tradeoff between multiple metrics of interest. For instance, when deploying models on-device we may want to maximize model performance (e.g., accuracy), while simultaneously minimizing competing metrics such as power consumption, inference latency, or model size, in order to satisfy deployment constraints. In many cases, we have been able to reduce computational requirements or latency of predictions substantially by accepting a small degradation in model performance (in some cases we were able to both increase accuracy and reduce latency!). Principled methods for exploring such tradeoffs efficiently are key enablers of [Sustainable AI](https:\/\/arxiv.org\/abs\/2111.00364).","__index_level_0__":2202}
+{"text":"At Meta, we have successfully used [multi-objective Bayesian NAS](https:\/\/research.facebook.com\/blog\/2021\/07\/optimizing-model-accuracy-and-latency-using-bayesian-multi-objective-neural-architecture-search\/) in Ax to explore such tradeoffs. Our methodology is being used routinely for optimizing AR\/VR on-device ML models. Beyond NAS applications, we have also developed [MORBO](https:\/\/arxiv.org\/pdf\/2109.10964.pdf) which is a method for high-dimensional multi-objective optimization that can be used to optimize optical systems for augmented reality (AR).","__index_level_0__":2203}
+{"text":"## Fully automated Multi-Objective NAS with Ax","__index_level_0__":2204}
+{"text":"Ax\u2019s Scheduler allows running experiments asynchronously in a closed-loop fashion by continuously deploying trials to an external system, polling for results, leveraging the fetched data to generate more trials, and repeating the process until a stopping condition is met. No human intervention or oversight is required. Features of the Scheduler include:","__index_level_0__":2205}
+{"text":"- Customizability of parallelism, failure tolerance, and many other settings;","__index_level_0__":2206}
+{"text":"- A large selection of state-of-the-art optimization algorithms;","__index_level_0__":2207}
+{"text":"- Saving in-progress experiments (to a SQL DB or json) and resuming an experiment from storage;","__index_level_0__":2208}
+{"text":"- Easy extensibility to new backends for running trial evaluations remotely.","__index_level_0__":2209}
+{"text":"The following illustration from the [Ax scheduler tutorial](https:\/\/ax.dev\/tutorials\/scheduler.html) summarizes how the scheduler interacts with any external system used to run trial evaluations:","__index_level_0__":2210}
+{"text":"<!-- image goes here  -->","__index_level_0__":2211}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/MOO-NAS-blog-img1-ax_scheduler_illustration.png\" width=\"90%\">\n<\/p>","__index_level_0__":2212}
+{"text":"To run automated NAS with the Scheduler, the main things we need to do are:","__index_level_0__":2213}
+{"text":"- Define a [Runner](https:\/\/github.com\/facebook\/Ax\/blob\/main\/ax\/core\/runner.py#L21), which is responsible for sending off a model with a particular architecture to be trained on a platform of our choice (like Kubernetes, or maybe just a Docker image on our local machine). In the tutorial below, we use TorchX for handling deployment of training jobs.","__index_level_0__":2214}
+{"text":"- Define a [Metric](https:\/\/github.com\/facebook\/Ax\/blob\/main\/ax\/core\/metric.py#L21), which is responsible for fetching the objective metrics (such as accuracy, model size, latency) from the training job. In our tutorial, we use Tensorboard to log data, and so can use the Tensorboard metrics that come bundled with Ax.","__index_level_0__":2215}
+{"text":"## Tutorial","__index_level_0__":2216}
+{"text":"In our tutorial we show how to use Ax to run multi-objective NAS for a simple neural network model on the popular MNIST dataset. While the underlying methodology can be used for more complicated models and larger datasets, we opt for a tutorial that is easily runnable end-to-end on a laptop in less than an hour. In our example, we will tune the widths of two hidden layers, the learning rate, the dropout probability, the batch size, and the number of training epochs. The goal is to trade off performance (accuracy on the validation set) and model size (the number of model parameters) using [multi-objective Bayesian optimization](https:\/\/proceedings.neurips.cc\/paper\/2021\/file\/11704817e347269b7254e744b5e22dac-Paper.pdf).","__index_level_0__":2217}
+{"text":"The tutorial makes use of the following PyTorch libraries:","__index_level_0__":2218}
+{"text":"- [PyTorch Lightning](https:\/\/github.com\/PyTorchLightning\/pytorch-lightning) (specifying the model and training loop)","__index_level_0__":2219}
+{"text":"- [TorchX](https:\/\/github.com\/pytorch\/torchx) (for running training jobs remotely \/ asynchronously)","__index_level_0__":2220}
+{"text":"- [BoTorch](https:\/\/github.com\/pytorch\/botorch) (the Bayesian optimization library that powers Ax\u2019s algorithms)","__index_level_0__":2221}
+{"text":"The complete runnable example is available as a **[PyTorch Tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/ax_multiobjective_nas_tutorial.html)**.","__index_level_0__":2222}
+{"text":"### Results","__index_level_0__":2223}
+{"text":"The final results from the NAS optimization performed in the tutorial can be seen in the tradeoff plot below. Here, each point corresponds to the result of a trial, with the color representing its iteration number, and the star indicating the reference point defined by the thresholds we imposed on the objectives. We see that our method was able to successfully explore the trade-offs between validation accuracy and number of parameters and found both large models with high validation accuracy as well as small models with lower validation accuracy. Depending on the performance requirements and model size constraints, the decision maker can now choose which model to use or analyze further.","__index_level_0__":2224}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/MOO-NAS-blog-img2-pareto_frontier_plot.png\" width=\"100%\">\n<\/p>","__index_level_0__":2225}
+{"text":"### Visualizations","__index_level_0__":2226}
+{"text":"Ax provides a number of visualizations that make it possible to analyze and understand the results of an experiment. Here, we will focus on the performance of the Gaussian process models that model the unknown objectives, which are used to help us discover promising configurations faster. Ax makes it easy to better understand how accurate these models are and how they perform on unseen data via leave-one-out cross-validation. In the figures below, we see that the model fits look quite good - predictions are close to the actual outcomes, and predictive 95% confidence intervals cover the actual outcomes well. Additionally, we observe that the model size `(num_params)` metric is much easier to model than the validation accuracy `(val_acc)` metric.","__index_level_0__":2227}
+{"text":"<!-- another image  -->","__index_level_0__":2228}
+{"text":"    .cross-validation-container{\n        display:flex; \n        flex-direction:row; \n    }","__index_level_0__":2230}
+{"text":"<div class=\"cross-validation-container\">\n<p align=\"center\">\n<img src=\"\/assets\/images\/MOO-NAS-blog-img3-cv_plot_val_acc.png\" width=\"100%\">\n<\/p>","__index_level_0__":2232}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/MOO-NAS-blog-img4-cv_plot_num_params.png\" width=\"100%\">\n<\/p>\n<\/div>","__index_level_0__":2233}
+{"text":"## Takeaways","__index_level_0__":2234}
+{"text":"- We showed how to run a fully automated multi-objective Neural Architecture Search using Ax.","__index_level_0__":2235}
+{"text":"- Using the Ax Scheduler, we were able to run the optimization automatically in a fully asynchronous fashion - this can be done locally (as done in the tutorial) or by deploying trials remotely to a cluster (simply by changing the TorchX scheduler configuration).","__index_level_0__":2236}
+{"text":"- The state-of-the-art multi-objective Bayesian optimization algorithms available in Ax allowed us to efficiently explore the tradeoffs between validation accuracy and model size.","__index_level_0__":2237}
+{"text":"## Advanced Functionality","__index_level_0__":2238}
+{"text":"Ax has a number of other advanced capabilities that we did not discuss in our tutorial. Among these are the following:","__index_level_0__":2239}
+{"text":"### Early Stopping","__index_level_0__":2240}
+{"text":"When evaluating a new candidate configuration, partial learning curves are typically available while the NN training job is running. We can use the information contained in the partial curves to identify under-performing trials to stop early in order to free up computational resources for more promising candidates. While not demonstrated in the above tutorial, Ax supports early stopping out-of-the-box - see our [early stopping tutorial](https:\/\/ax.dev\/versions\/latest\/tutorials\/early_stopping\/early_stopping.html) for more details.","__index_level_0__":2241}
+{"text":"### High-dimensional search spaces","__index_level_0__":2242}
+{"text":"In our tutorial, we used Bayesian optimization with a standard Gaussian process in order to keep the runtime low. However, these models typically scale to only about 10-20 tunable parameters. Our new SAASBO method ([paper](https:\/\/proceedings.mlr.press\/v161\/eriksson21a\/eriksson21a.pdf), [Ax tutorial](https:\/\/ax.dev\/tutorials\/saasbo.html), [BoTorch tutorial](https:\/\/botorch.org\/tutorials\/saasbo)) is very sample-efficient and enables tuning hundreds of parameters. SAASBO can easily be enabled by passing `use_saasbo=True` to `choose_generation_strategy`.","__index_level_0__":2243}
+{"text":"## Acknowledgements","__index_level_0__":2244}
+{"text":"We thank the TorchX team (in particular Kiuk Chung and Tristan Rice) for their help with integrating TorchX with Ax, and the Adaptive Experimentation team @ Meta for their contributions to Ax and BoTorch.","__index_level_0__":2245}
+{"text":"## References","__index_level_0__":2246}
+{"text":"[D. Eriksson, P. Chuang, S. Daulton, M. Balandat. Optimizing model accuracy and latency using Bayesian multi-objective neural architecture search. Meta Research blog, July 2021.](https:\/\/research.facebook.com\/blog\/2021\/07\/optimizing-model-accuracy-and-latency-using-bayesian-multi-objective-neural-architecture-search\/)\n \n source: https:\/\/pytorch.org\/blog\/effective-multi-objective-nueral-architecture\/ \n category: pytorch blogs","__index_level_0__":2247}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch Adds New Ecosystem Projects for Encrypted AI and Quantum Computing, Expands PyTorch Hub'\nauthor: Team PyTorch\n---","__index_level_0__":2248}
+{"text":"The PyTorch ecosystem includes projects, tools, models and libraries from a broad community of researchers in academia and industry, application developers, and ML engineers. The goal of this ecosystem is to support, accelerate, and aid in your exploration with PyTorch and help you push the state of the art, no matter what field you are exploring. Similarly, we are expanding the recently launched PyTorch Hub to further help you discover and reproduce the latest research.","__index_level_0__":2249}
+{"text":"In this post, we\u2019ll highlight some of the projects that have been added to the PyTorch ecosystem this year and provide some context on the criteria we use to evaluate community projects. We\u2019ll also provide an update on the fast-growing PyTorch Hub and share details on our upcoming PyTorch Summer Hackathon.","__index_level_0__":2250}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/pytorch-ecosystem.png\" width=\"100%\">\n<\/div>","__index_level_0__":2251}
+{"text":"## Recently added ecosystem projects","__index_level_0__":2252}
+{"text":"From private AI to quantum computing, we\u2019ve seen the community continue to expand into new and interesting areas. The latest projects include:","__index_level_0__":2253}
+{"text":"- [Advertorch](https:\/\/github.com\/BorealisAI\/advertorch): A Python toolbox for adversarial robustness research. The primary functionalities are implemented in PyTorch. Specifically, AdverTorch contains modules for generating adversarial perturbations and defending against adversarial examples, as well as scripts for adversarial training.","__index_level_0__":2254}
+{"text":"- [botorch](https:\/\/botorch.org\/): A modular and easily extensible interface for composing Bayesian optimization primitives, including probabilistic models, acquisition functions, and optimizers.","__index_level_0__":2255}
+{"text":"- [Skorch](https:\/\/github.com\/skorch-dev\/skorch): A high-level library for PyTorch that provides full scikit-learn compatibility.","__index_level_0__":2256}
+{"text":"- [PyTorch Geometric](https:\/\/github.com\/rusty1s\/pytorch_geometric): A library for deep learning on irregular input data such as graphs, point clouds, and manifolds.","__index_level_0__":2257}
+{"text":"- [PySyft](https:\/\/github.com\/OpenMined\/PySyft): A Python library for encrypted, privacy preserving deep learning.","__index_level_0__":2258}
+{"text":"- [PennyLane](https:\/\/pennylane.ai\/): A library for quantum ML, automatic differentiation, and optimization of hybrid quantum-classical computations.","__index_level_0__":2259}
+{"text":"- [Flair](https:\/\/github.com\/zalandoresearch\/flair): A very simple framework for state-of-the-art natural language processing (NLP).","__index_level_0__":2260}
+{"text":"### What makes a great project?","__index_level_0__":2261}
+{"text":"When we review project submissions for the PyTorch ecosystem, we take into account a number of factors that we feel are important and that we would want in the projects we use ourselves. Some of these criteria include:","__index_level_0__":2262}
+{"text":"1. *Well-tested:* Users should be confident that ecosystem projects will work well with PyTorch, and include support for CI to ensure that testing is occurring on a continuous basis and the project can run on the latest version of PyTorch.\n2. *Clear utility:* Users should understand where each project fits within the PyTorch ecosystem and the value it brings.\n3. *Permissive licensing:* Users must be able to utilize ecosystem projects without licensing concerns. e.g. BSD-3, Apache-2 and MIT licenses\n4. *Easy onboarding:* Projects need to have support for binary installation options (pip\/Conda), clear documentation and a rich set of tutorials (ideally built into Jupyter notebooks).\n5. *Ongoing maintenance:* Project authors need to be committed to supporting and maintaining their projects.\n6. *Community:* Projects should have (or be on track to building) an active, broad-based community.","__index_level_0__":2263}
+{"text":"If you would like to have your project included in the PyTorch ecosystem and featured on [pytorch.org\/ecosystem](http:\/\/pytorch.org\/ecosystem), please complete the form [here](https:\/\/pytorch.org\/ecosystem\/join). If you've previously submitted a project for consideration and haven't heard back, we promise to get back to you as soon as we can - we've received a lot of submissions!","__index_level_0__":2264}
+{"text":"## PyTorch Hub for reproducible research | New models","__index_level_0__":2265}
+{"text":"Since [launching](https:\/\/pytorch.org\/blog\/towards-reproducible-research-with-pytorch-hub\/) the PyTorch Hub in beta, we\u2019ve received a lot of interest from the community including the contribution of many new models. Some of the latest include [U-Net for Brain MRI](https:\/\/pytorch.org\/hub\/mateuszbuda_brain-segmentation-pytorch_unet\/) contributed by researchers at Duke University, [Single Shot Detection](https:\/\/pytorch.org\/hub\/nvidia_deeplearningexamples_ssd\/) from NVIDIA and [Transformer-XL](https:\/\/pytorch.org\/hub\/huggingface_pytorch-pretrained-bert_transformerXL\/) from HuggingFace.","__index_level_0__":2266}
+{"text":"We\u2019ve seen organic integration of the PyTorch Hub by folks like [paperswithcode](https:\/\/paperswithcode.com\/), making it even easier for you to try out the state of the art in AI research. In addition, companies like [Seldon](https:\/\/github.com\/axsaucedo\/seldon-core\/tree\/pytorch_hub\/examples\/models\/pytorchhub) provide production-level support for PyTorch Hub models on top of Kubernetes.","__index_level_0__":2267}
+{"text":"### What are the benefits of contributing a model in the PyTorch Hub?","__index_level_0__":2268}
+{"text":"- *Compatibility:* PyTorch Hub models are prioritized first for testing by the TorchScript and Cloud TPU teams, and used as baselines for researchers across a number of fields.","__index_level_0__":2269}
+{"text":"- *Visibility:* Models in the Hub will be promoted on [pytorch.org](http:\/\/pytorch.org\/) as well as on [paperswithcode](https:\/\/paperswithcode.com\/).","__index_level_0__":2270}
+{"text":"- *Ease of testing and reproducibility:* Each model comes with code, clear preprocessing requirements, and methods\/dependencies to run. There is also tight integration with [Google Colab](https:\/\/colab.research.google.com\/github\/pytorch\/pytorch.github.io\/blob\/master\/assets\/hub\/facebookresearch_WSL-Images_resnext.ipynb#scrollTo=LM_l7vXJvnDM), making it a true single click to get started.","__index_level_0__":2271}
+{"text":"### PyTorch Hub contributions welcome!","__index_level_0__":2272}
+{"text":"We are actively looking to grow the PyTorch Hub and welcome contributions. You don\u2019t need to be an original paper author to contribute, and we\u2019d love to see the number of domains and fields broaden. So what types of contributions are we looking for?","__index_level_0__":2273}
+{"text":"- Artifacts of a published or an arXiv paper (or something of a similar nature that serves a different audience \u2014 such as ULMFit) that a large audience would need.","__index_level_0__":2274}
+{"text":"- Reproduces the published results (or better)","__index_level_0__":2276}
+{"text":"Overall these models are aimed at researchers either trying to reproduce a baseline, or trying to build downstream research on top of the model (such as feature-extraction or fine-tuning) as well as researchers looking for a demo of the paper for subjective evaluation. Please keep this audience in mind when contributing.","__index_level_0__":2277}
+{"text":"If you are short on inspiration or would just like to find out what the SOTA is an any given field or domain, checkout the Paperswithcode [state-of-the-art gallery](https:\/\/paperswithcode.com\/sota).","__index_level_0__":2278}
+{"text":"## PyTorch Summer Hackathon","__index_level_0__":2279}
+{"text":"We\u2019ll be hosting the first PyTorch Summer Hackathon next month. We invite you to apply to participate in the in-person hackathon on  August 8th to 9th at Facebook's Menlo Park campus. We'll be bringing the community together to work on innovative ML projects that can solve a broad range of complex challenges.","__index_level_0__":2280}
+{"text":"Applications will be reviewed and accepted on a rolling basis until spaces are filled. For those who cannot join this Hackathon in person, we\u2019ll be following up soon with other ways to participate.","__index_level_0__":2281}
+{"text":"Please visit [this link to apply](https:\/\/www.eventbrite.com\/e\/pytorch-summer-hackathon-in-menlo-park-registration-63756668913).","__index_level_0__":2282}
+{"text":"Thank you for being part of the PyTorch community!","__index_level_0__":2283}
+{"text":"-Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-ecosystem\/ \n category: pytorch blogs","__index_level_0__":2284}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PipeTransformer: Automated Elastic Pipelining for Distributed Training of Large-scale Models'\nauthor: Chaoyang He, Shen Li, Mahdi Soltanolkotabi, and Salman Avestimehr\nfeatured-img: 'assets\/images\/pipetransformer_overview.png'\n---","__index_level_0__":2285}
+{"text":"In this blog post, we describe the first peer-reviewed research paper that explores accelerating the hybrid of PyTorch DDP (`torch.nn.parallel.DistributedDataParallel`) [1] and Pipeline (`torch.distributed.pipeline`) - [PipeTransformer: Automated Elastic Pipelining for Distributed Training of Large-scale Models](http:\/\/proceedings.mlr.press\/v139\/he21a.html) (Transformers such as BERT [2]  and ViT [3]), published at ICML 2021.","__index_level_0__":2286}
+{"text":"PipeTransformer leverages automated elastic pipelining for efficient distributed training of Transformer models. In PipeTransformer, we designed an adaptive on-the-fly freeze algorithm that can identify and freeze some layers gradually during training and an elastic pipelining system that can dynamically allocate resources to train the remaining active layers. More specifically, PipeTransformer automatically excludes frozen layers from the pipeline, packs active layers into fewer GPUs, and forks more replicas to increase data-parallel width. We evaluate PipeTransformer using Vision Transformer (ViT) on ImageNet and BERT on SQuAD and GLUE datasets. Our results show that compared to the state-of-the-art baseline, PipeTransformer attains up to 2.83-fold speedup without losing accuracy. We also provide various performance analyses for a more comprehensive understanding of our algorithmic and system-wise design.","__index_level_0__":2287}
+{"text":"Next, we will introduce the background, motivation, our idea, design, and how we implement the algorithm and system with PyTorch Distributed APIs.","__index_level_0__":2288}
+{"text":"* Paper: [http:\/\/proceedings.mlr.press\/v139\/he21a.html](http:\/\/proceedings.mlr.press\/v139\/he21a.html)\n* Source Code: [https:\/\/DistML.ai](https:\/\/distml.ai).\n* Slides: [https:\/\/docs.google.com\/presentation\/d\/1t6HWL33KIQo2as0nSHeBpXYtTBcy0nXCoLiKd0EashY\/edit?usp=sharing](https:\/\/docs.google.com\/presentation\/d\/1t6HWL33KIQo2as0nSHeBpXYtTBcy0nXCoLiKd0EashY\/edit?usp=sharing)","__index_level_0__":2289}
+{"text":"# Introduction\n<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/model_size.png\" alt=\"Model Size\" width=\"500\">\n<br>\nFigure 1: the Parameter Number of Transformer Models Increases Dramatically.\n<\/p>","__index_level_0__":2290}
+{"text":"\nLarge Transformer models [4][5] have powered accuracy breakthroughs in both natural language processing and computer vision. GPT-3 [4] hit a new record high accuracy for nearly all NLP tasks. Vision Transformer (ViT) [3] also achieved 89\\% top-1 accuracy in ImageNet, outperforming state-of-the-art convolutional networks ResNet-152 and EfficientNet. To tackle the growth in model sizes, researchers have proposed various distributed training techniques, including parameter servers [6][7][8], pipeline parallelism [9][10][11][12], intra-layer parallelism [13][14][15], and zero redundancy data-parallel [16].","__index_level_0__":2291}
+{"text":"\nExisting distributed training solutions, however, only study scenarios where all model weights are required to be optimized throughout the training (i.e., computation and communication overhead remains relatively static over different iterations). Recent works on <em>progressive training<\/em> suggest that parameters in neural networks can be trained dynamically:","__index_level_0__":2292}
+{"text":"* Freeze Training: Singular Vector Canonical Correlation Analysis for Deep Learning Dynamics and Interpretability. NeurIPS 2017\n* Efficient Training of BERT by Progressively Stacking. ICML 2019\n* Accelerating Training of Transformer-Based Language Models with Progressive Layer Dropping. NeurIPS 2020.\n* On the Transformer Growth for Progressive BERT Training. NACCL 2021","__index_level_0__":2293}
+{"text":"\n<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/freeze_training.png\" alt=\"Freeze Training\" width=\"560\">\n<br>\n<\/p>\nFigure 2. Interpretable Freeze Training: DNNs converge bottom-up (Results on CIFAR10 using ResNet). Each pane shows layer-by-layer similarity using SVCCA [17][18]","__index_level_0__":2294}
+{"text":"For example, in freeze training [17][18], neural networks usually converge from the bottom-up (i.e., not all layers need to be trained all the way through training). Figure 2 shows an example of how weights gradually stabilize during training in this approach. This observation motivates us to utilize freeze training for distributed training of Transformer models to accelerate training by dynamically allocating resources to focus on a shrinking set of active layers. Such a layer freezing strategy is especially pertinent to pipeline parallelism, as excluding consecutive bottom layers from the pipeline can reduce computation, memory, and communication overhead.","__index_level_0__":2295}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/PipeTransformer.png\" width=\"100%\">\n<br>\nFigure 3. The process of PipeTransformer\u2019s automated and elastic pipelining to accelerate distributed training of Transformer models\n<\/p>","__index_level_0__":2296}
+{"text":"\nWe propose PipeTransformer, an elastic pipelining training acceleration framework that automatically reacts to frozen layers by dynamically transforming the scope of the pipelined model and the number of pipeline replicas. To the best of our knowledge, this is the first paper that studies layer freezing in the context of both pipeline and data-parallel training. Figure 3 demonstrates the benefits of such a combination. First, by excluding frozen layers from the pipeline, the same model can be packed into fewer GPUs, leading to both fewer cross-GPU communications and smaller pipeline bubbles. Second, after packing the model into fewer GPUs, the same cluster can accommodate more pipeline replicas, increasing the width of data parallelism. More importantly, the speedups acquired from these two benefits are multiplicative rather than additive, further accelerating the training.","__index_level_0__":2297}
+{"text":"The design of PipeTransformer faces four major challenges. First, the freeze algorithm must make on-the-fly and adaptive freezing decisions; however, existing work [17][18] only provides a posterior analysis tool. Second, the efficiency of pipeline re-partitioning results is influenced by multiple factors, including partition granularity, cross-partition activation size, and the chunking (the number of micro-batches) in mini-batches, which require reasoning and searching in a large solution space. Third, to dynamically introduce additional pipeline replicas, PipeTransformer must overcome the static nature of collective communications and avoid potentially complex cross-process messaging protocols when onboarding new processes (one pipeline is handled by one process). Finally, caching can save time for repeated forward propagation of frozen layers, but it must be shared between existing pipelines and newly added ones, as the system cannot afford to create and warm up a dedicated cache for each replica.","__index_level_0__":2298}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/PipeTransformer-Animation.gif\" alt=\"Freeze Training\">\n<br>\nFigure 4: An Animation to Show the Dynamics of PipeTransformer\n<\/p>","__index_level_0__":2299}
+{"text":"As shown in the animation (Figure 4), PipeTransformer is designed with four core building blocks to address the aforementioned challenges. First, we design a tunable and adaptive algorithm to generate signals that guide the selection of layers to freeze over different iterations (Freeze Algorithm). Once triggered by these signals, our elastic pipelining module (AutoPipe), then packs the remaining active layers into fewer GPUs by taking both activation sizes and variances of workloads across heterogeneous partitions (frozen layers and active layers) into account. It then splits a mini-batch into an optimal number of micro-batches based on prior profiling results for different pipeline lengths. Our next module, AutoDP, spawns additional pipeline replicas to occupy freed-up GPUs and maintains hierarchical communication process groups to attain dynamic membership for collective communications. Our final module, AutoCache, efficiently shares activations across existing and new data-parallel processes and automatically replaces stale caches during transitions.","__index_level_0__":2300}
+{"text":"\nOverall, PipeTransformer combines the Freeze Algorithm, AutoPipe, AutoDP, and AutoCache modules to provide a significant training speedup.\nWe evaluate PipeTransformer using Vision Transformer (ViT) on ImageNet and BERT on GLUE and SQuAD datasets. Our results show that PipeTransformer attains up to 2.83-fold speedup without losing accuracy. We also provide various performance analyses for a more comprehensive understanding of our algorithmic and system-wise design.\nFinally, we have also developed open-source flexible APIs for PipeTransformer, which offer a clean separation among the freeze algorithm, model definitions, and training accelerations, allowing for transferability to other algorithms that require similar freezing strategies.","__index_level_0__":2301}
+{"text":"# Overall Design","__index_level_0__":2302}
+{"text":"Suppose we aim to train a massive model in a distributed training system where the hybrid of pipelined model parallelism and data parallelism is used to target scenarios where either the memory of a single GPU device cannot hold the model, or if loaded, the batch size is small enough to avoid running out of memory. More specifically, we define our settings as follows:","__index_level_0__":2303}
+{"text":"<strong>Training task and model definition.<\/strong> We train Transformer models (e.g., Vision Transformer, BERT on large-scale image or text datasets. The Transformer model <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=mathcal{F}\"> has <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=L\"> layers, in which the <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=i\"> th layer is composed of a forward computation function <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=f_i\"> and a corresponding set of parameters.","__index_level_0__":2304}
+{"text":"<strong>Training infrastructure.<\/strong> Assume the training infrastructure contains a GPU cluster that has <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=N\"> GPU servers (i.e. nodes). Each node has <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=I\"> GPUs. Our cluster is homogeneous, meaning that each GPU and server have the same hardware configuration. Each GPU's memory capacity is <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M_\\text{GPU}\">. Servers are connected by a high bandwidth network interface such as InfiniBand interconnect.","__index_level_0__":2305}
+{"text":"<strong>Pipeline parallelism.<\/strong> In each machine, we load a model <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\mathcal{F}\"> into a pipeline <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\mathcal{P}\"> which has <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K\">partitions (<img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K\"> also represents the pipeline length). The <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=k\">th partition <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=p_k\"> consists of consecutive layers. We assume each partition is handled by a single GPU device. <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=1 \\leq K \\leq I\">, meaning that we can build multiple pipelines for multiple model replicas in a single machine. We assume all GPU devices in a pipeline belonging to the same machine. Our pipeline is a synchronous pipeline, which does not involve stale gradients, and the number of micro-batches is <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M\">. In the Linux OS, each pipeline is handled by a single process. We refer the reader to GPipe [10] for more details.","__index_level_0__":2306}
+{"text":"<strong>Data parallelism.<\/strong> DDP is a cross-machine distributed data-parallel process group within <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=R\"> parallel workers. Each worker is a pipeline replica (a single process). The <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=r\">th worker's index (ID) is rank <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=r\">. For any two pipelines in DDP, they can belong to either the same GPU server or different GPU servers, and they can exchange gradients with the AllReduce algorithm.","__index_level_0__":2307}
+{"text":"Under these settings, our goal is to accelerate training by leveraging freeze training, which does not require all layers to be trained throughout the duration of the training. Additionally, it may help save computation, communication, memory cost, and potentially prevent overfitting by consecutively freezing layers. However, these benefits can only be achieved by overcoming the four challenges of designing an adaptive freezing algorithm, dynamical pipeline re-partitioning, efficient resource reallocation, and cross-process caching, as discussed in the introduction.","__index_level_0__":2308}
+{"text":"\n<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/pipetransformer_overview.png\" alt=\"Overview\" width=\"560\">\n<br>\nFigure 5. Overview of PipeTransformer Training System\n<\/p>","__index_level_0__":2309}
+{"text":"PipeTransformer co-designs an on-the-fly freeze algorithm and an automated elastic pipelining training system that can dynamically transform the scope of the pipelined model and the number of pipeline replicas. The overall system architecture is illustrated in Figure 5.  To support PipeTransformer\u2019s elastic pipelining, we maintain a customized version of PyTorch Pipeline. For data parallelism, we use PyTorch DDP as a baseline. Other libraries are standard mechanisms of an operating system (e.g.,multi-processing) and thus avoid specialized software or hardware customization requirements. To ensure the generality of our framework, we have decoupled the training system into four core components: <strong>freeze algorithm<\/strong>, <strong>AutoPipe<\/strong>, <strong>AutoDP<\/strong>, and <strong>AutoCache<\/strong>. The <strong>freeze algorithm<\/strong> (grey) samples indicators from the training loop and makes layer-wise freezing decisions, which will be shared with <strong>AutoPipe<\/strong> (green). AutoPipe is an elastic pipeline module that speeds up training by excluding frozen layers from the pipeline and packing the active layers into fewer GPUs (pink), leading to both fewer cross-GPU communications and smaller pipeline bubbles. Subsequently, <strong>AutoPipe<\/strong> passes pipeline length information to <strong>AutoDP<\/strong> (purple), which then spawns more pipeline replicas to increase data-parallel width, if possible. The illustration also includes an example in which AutoDP introduces a new replica (purple). <strong>AutoCache<\/strong> (orange edges) is a cross-pipeline caching module, as illustrated by connections between pipelines. The source code architecture is aligned with Figure 5 for readability and generality.","__index_level_0__":2310}
+{"text":"\n# Implementation Using PyTorch APIs","__index_level_0__":2311}
+{"text":"As can be seen from Figure 5, PipeTransformers contain four components: Freeze Algorithm, AutoPipe, AutoDP, and AutoCache. Among them, AutoPipe and AutoDP relies on PyTorch DDP (`torch.nn.parallel.DistributedDataParallel`) [1] and Pipeline (`torch.distributed.pipeline`), respectively. In this blog, we only highlight the key implementation details of AutoPipe and AutoDP. For details of Freeze Algorithm and AutoCache, please refer to our paper.","__index_level_0__":2312}
+{"text":"## AutoPipe: Elastic Pipelining","__index_level_0__":2313}
+{"text":"AutoPipe can accelerate training by excluding frozen layers from the pipeline and packing the active layers into fewer GPUs. This section elaborates on the key components of AutoPipe that dynamically 1) partition pipelines, 2) minimize the number of pipeline devices, and 3) optimize mini-batch chunk size accordingly.","__index_level_0__":2314}
+{"text":"### Basic Usage of PyTorch Pipeline","__index_level_0__":2315}
+{"text":"Before diving into details of AutoPipe, let us warm up the basic usage of PyTorch Pipeline (`torch.distributed.pipeline.sync.Pipe`, see [this tutorial](https:\/\/pytorch.org\/docs\/stable\/pipeline.html)). More specially, we present a simple example to understand the design of Pipeline in practice:","__index_level_0__":2316}
+{"text":"```python\n# Step 1: build a model including two linear layers\nfc1 = nn.Linear(16, 8).cuda(0)\nfc2 = nn.Linear(8, 4).cuda(1)","__index_level_0__":2317}
+{"text":"# Step 2: wrap the two layers with nn.Sequential\nmodel = nn.Sequential(fc1, fc2)","__index_level_0__":2318}
+{"text":"# Step 3: build Pipe (torch.distributed.pipeline.sync.Pipe)\nmodel = Pipe(model, chunks=8)","__index_level_0__":2319}
+{"text":"# do training\/inference\ninput = torch.rand(16, 16).cuda(0)\noutput_rref = model(input)\n```","__index_level_0__":2320}
+{"text":"In this basic example, we can see that before initializing `Pipe`, we need to partition the model `nn.Sequential` into multiple GPU devices and set optimal chunk number (`chunks`). Balancing computation time across partitions is critical to pipeline training speed, as skewed workload distributions across stages can lead to stragglers and forcing devices with lighter workloads to wait. The chunk number may also have a non-trivial influence on the throughput of the pipeline.","__index_level_0__":2321}
+{"text":"\n### Balanced Pipeline Partitioning","__index_level_0__":2322}
+{"text":"In dynamic training system such as PipeTransformer, maintaining optimally balanced partitions in terms of parameter numbers does not guarantee the fastest training speed because other factors also play a crucial role:","__index_level_0__":2323}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/balancing_partition.png\" width=\"560\">\n<br>\nFigure 6. The partition boundary is in the middle of a skip connection\n<\/p>","__index_level_0__":2324}
+{"text":"1. <strong>Cross-partition communication overhead.<\/strong> Placing a partition boundary in the middle of a skip connection leads to additional communications since tensors in the skip connection must now be copied to a different GPU. For example, with BERT partitions in Figure 6, partition <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=k\"> must take intermediate outputs from both partition <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=k-2\"> and partition <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=k-1\">. In contrast, if the boundary is placed after the addition layer, the communication overhead between partition <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=k-1\"> and <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=k\"> is visibly smaller. Our measurements show that having cross-device communication is more expensive than having slightly imbalanced partitions (see the Appendix in our paper). Therefore, we do not consider breaking skip connections (highlighted separately as an entire attention layer and MLP layer in green color at line 7 in Algorithm 1.","__index_level_0__":2325}
+{"text":"2. <strong>Frozen layer memory footprint.<\/strong> During training, AutoPipe must recompute partition boundaries several times to balance two distinct types of layers: frozen layers and active layers. The frozen layer's memory cost is a fraction of that inactive layer, given that the frozen layer does not need backward activation maps, optimizer states, and gradients. Instead of launching intrusive profilers to obtain thorough metrics on memory and computational cost, we define a tunable cost factor <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=lambda_{\\text{frozen}}\"> to estimate the memory footprint ratio of a frozen layer over the same active layer. Based on empirical measurements in our experimental hardware, we set it to <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\frac{1}{6}\">.","__index_level_0__":2326}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/AutoPipe_algorithm.png\" width=\"100%\">\n<br>\n<\/p>","__index_level_0__":2328}
+{"text":"Based on the above two considerations, AutoPipe balances pipeline partitions based on parameter sizes. More specifically, AutoPipe uses a greedy algorithm to allocate all frozen and active layers to evenly distribute partitioned sublayers into <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K\"> GPU devices. Pseudocode is described as the `load\\_balance()` function in Algorithm 1. The frozen layers are extracted from the original model and kept in a separate model instance <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\mathcal{F}_{\\text{frozen}}\"> in the first device of a pipeline.","__index_level_0__":2329}
+{"text":"Note that the partition algorithm employed in this paper is not the only option; PipeTransformer is modularized to work with any alternatives.","__index_level_0__":2330}
+{"text":"\n### Pipeline Compression","__index_level_0__":2331}
+{"text":"Pipeline compression helps to free up GPUs to accommodate more pipeline replicas and reduce the number of cross-device communications between partitions. To determine the timing of compression, we can estimate the memory cost of the largest partition after compression, and then compare it with that of the largest partition of a pipeline at timestep <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=T=0\">. To avoid extensive memory profiling, the compression algorithm uses the parameter size as a proxy for the training memory footprint. Based on this simplification, the criterion of pipeline compression is as follows:","__index_level_0__":2332}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/memory_reduction.png\" width=\"320\">\n<br>\n<\/p>","__index_level_0__":2333}
+{"text":"Once the freeze notification is received, AutoPipe will always attempt to divide the pipeline length <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K\"> by 2 (e.g., from 8 to 4, then 2). By using <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\frac{K}{2}\"> as the input, the compression algorithm can verify if the result satisfies the criterion in Equation (1). Pseudocode is shown in lines 25-33 in Algorithm 1. Note that this compression makes the acceleration ratio exponentially increase during training, meaning that if a GPU server has a larger number of GPUs (e.g., more than 8), the acceleration ratio will be further amplified.","__index_level_0__":2334}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/pipe_buble.png\" width=\"560\">\n<br>\nFigure 7. Pipeline Bubble: <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=F_{d,b}\">, and <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=U_d\"> denote forward, backward, and the optimizer update of micro-batch <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=b\"> on device <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=d\">, respectively. The total bubble size in each iteration is <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K-1\"> times per micro-batch forward and backward cost.\n<\/p>","__index_level_0__":2335}
+{"text":"Additionally, such a technique can also speed up training by shrinking the size of pipeline bubbles. To explain bubble sizes in a pipeline, Figure 7 depicts how 4 micro-batches run through a 4-device pipeline <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K = 4\">. In general, the total bubble size is <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=(K-1)\"> times per micro-batch forward and backward cost. Therefore, it is clear that shorter pipelines have smaller bubble sizes.","__index_level_0__":2336}
+{"text":"### Dynamic Number of Micro-Batches","__index_level_0__":2337}
+{"text":"Prior pipeline parallel systems use a fixed number of micro-batches per mini-batch (<img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M\"> ). GPipe suggests <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M \\geq 4 \\times K\">, where <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K\"> is the number of partitions (pipeline length). However, given that PipeTransformer dynamically configures <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K\">, we find it to be sub-optimal to maintain a static <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M\"> during training. Moreover, when integrated with DDP, the value of <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M\"> also has an impact on the efficiency of DDP gradient synchronizations. Since DDP must wait for the last micro-batch to finish its backward computation on a parameter before launching its gradient synchronization, finer micro-batches lead to a smaller overlap between computation and communication. Hence, instead of using a static value, PipeTransformer searches for optimal <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M\"> on the fly in the hybrid of DDP environment by enumerating <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M\"> values ranging from <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K\"> to <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=6K\">. For a specific training environment, the profiling needs only to be done once (see Algorithm 1 line 35).","__index_level_0__":2338}
+{"text":"For the complete source code, please refer to `https:\/\/github.com\/Distributed-AI\/PipeTransformer\/blob\/master\/pipe_transformer\/pipe\/auto_pipe.py`.","__index_level_0__":2339}
+{"text":"## AutoDP: Spawning More Pipeline Replicas\nAs AutoPipe compresses the same pipeline into fewer GPUs, AutoDP can automatically spawn new pipeline replicas to increase data-parallel width.","__index_level_0__":2340}
+{"text":"Despite the conceptual simplicity, subtle dependencies on communications and states require careful design. The challenges are threefold:","__index_level_0__":2341}
+{"text":"1. <strong>DDP Communication<\/strong>: Collective communications in PyTorch DDP requires static membership, which prevents new pipelines from connecting with existing ones;","__index_level_0__":2342}
+{"text":"2. <strong>State Synchronization<\/strong>: newly activated processes must be consistent with existing pipelines in the training progress (e.g., epoch number and learning rate), weights and optimizer states, the boundary of frozen layers, and pipeline GPU range;","__index_level_0__":2343}
+{"text":"3. <strong>Dataset Redistribution<\/strong>: the dataset should be re-balanced to match a dynamic number of pipelines. This not only avoids stragglers but also ensures that gradients from all DDP processes are equally weighted.","__index_level_0__":2344}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/AutoDP.png\" width=\"560\">\n<br>\nFigure 8. AutoDP: handling dynamical data-parallel with messaging between double process groups (Process 0-7 belong to machine 0, while process 8-15 belong to machine 1)\n<\/p>","__index_level_0__":2345}
+{"text":"To tackle these challenges, we create double communication process groups for DDP. As in the example shown in Figure 8, the message process group (purple) is responsible for light-weight control messages and covers all processes, while the active training process group (yellow) only contains active processes and serves as a vehicle for heavy-weight tensor communications during training. The message group remains static, whereas the training group is dismantled and reconstructed to match active processes.\nIn T0, only processes 0 and 8 are active. During the transition to T1, process 0 activates processes 1 and 9 (newly added pipeline replicas) and synchronizes necessary information mentioned above using the message group. The four active processes then form a new training group, allowing static collective communications adaptive to dynamic memberships.\nTo redistribute the dataset, we implement a variant of DistributedSampler that can seamlessly adjust data samples to match the number of active pipeline replicas.","__index_level_0__":2347}
+{"text":"The above design also naturally helps to reduce DDP communication overhead. More specifically, when transitioning from T0 to T1, processes 0 and 1 destroy the existing DDP instances, and active processes construct a new DDP training group using a cached pipelined model (AutoPipe stores frozen model and cached model separately).","__index_level_0__":2348}
+{"text":"We use the following APIs to implement the design above.","__index_level_0__":2349}
+{"text":"```python\nimport torch.distributed as dist\nfrom torch.nn.parallel import DistributedDataParallel as DDP","__index_level_0__":2350}
+{"text":"# initialize the process group (this must be called in the initialization of PyTorch DDP)\ndist.init_process_group(init_method='tcp:\/\/' + str(self.config.master_addr) + ':' +\nstr(self.config.master_port), backend=Backend.GLOO, rank=self.global_rank, world_size=self.world_size)\n...","__index_level_0__":2351}
+{"text":"# create active process group (yellow color)\nself.active_process_group = dist.new_group(ranks=self.active_ranks, backend=Backend.NCCL, timeout=timedelta(days=365))\n...","__index_level_0__":2352}
+{"text":"# create message process group (yellow color)\nself.comm_broadcast_group = dist.new_group(ranks=[i for i in range(self.world_size)], backend=Backend.GLOO, timeout=timedelta(days=365))\n...","__index_level_0__":2353}
+{"text":"# create DDP-enabled model when the number of data-parallel workers is changed. Note:\n# 1. The process group to be used for distributed data all-reduction.\nIf None, the default process group, which is created by torch.distributed.init_process_group, will be used.\nIn our case, we set it as self.active_process_group\n# 2. device_ids should be set when the pipeline length = 1 (the model resides on a single CUDA device).","__index_level_0__":2354}
+{"text":"self.pipe_len = gpu_num_per_process\nif gpu_num_per_process > 1:\n    model = DDP(model, process_group=self.active_process_group, find_unused_parameters=True)\nelse:\n    model = DDP(model, device_ids=[self.local_rank], process_group=self.active_process_group, find_unused_parameters=True)","__index_level_0__":2355}
+{"text":"# to broadcast message among processes, we use dist.broadcast_object_list\ndef dist_broadcast(object_list, src, group):\n    \"\"\"Broadcasts a given object to all parties.\"\"\"\n    dist.broadcast_object_list(object_list, src, group=group)\n    return object_list\n```\nFor the complete source code, please refer to `https:\/\/github.com\/Distributed-AI\/PipeTransformer\/blob\/master\/pipe_transformer\/dp\/auto_dp.py`.","__index_level_0__":2356}
+{"text":"# Experiments","__index_level_0__":2357}
+{"text":"This section first summarizes experiment setups and then evaluates PipeTransformer using computer vision and natural language processing tasks.","__index_level_0__":2358}
+{"text":"<strong>Hardware.<\/strong> Experiments were conducted on 2 identical machines connected by InfiniBand CX353A (<img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=5\">GB\/s), where each machine is equipped with 8 NVIDIA Quadro RTX 5000 (16GB GPU memory). GPU-to-GPU bandwidth within a machine (PCI 3.0, 16 lanes) is <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=15.754\">GB\/s.","__index_level_0__":2359}
+{"text":"<strong>Implementation.<\/strong> We used PyTorch Pipe as a building block. The BERT model definition, configuration, and related tokenizer are from HuggingFace 3.5.0. We implemented Vision Transformer using PyTorch by following its TensorFlow implementation. More details can be found in our source code.","__index_level_0__":2360}
+{"text":"<strong>Models and Datasets.<\/strong> Experiments employ two representative Transformers in CV and NLP: Vision Transformer (ViT) and BERT. ViT was run on an image classification task, initialized with pre-trained weights on ImageNet21K and fine-tuned on ImageNet and CIFAR-100. BERT was run on two tasks, text classification on the SST-2 dataset from the General Language Understanding Evaluation (GLUE) benchmark, and question answering on the SQuAD v1.1 Dataset (Stanford Question Answering), which is a collection of 100k crowdsourced question\/answer pairs.","__index_level_0__":2361}
+{"text":"<strong>Training Schemes.<\/strong> Given that large models normally would require thousands of GPU-days {\\emph{e.g.}, GPT-3) if trained from scratch, fine-tuning downstream tasks using pre-trained models has become a trend in CV and NLP communities. Moreover, PipeTransformer is a complex training system that involves multiple core components. Thus, for the first version of PipeTransformer system development and algorithmic research, it is not cost-efficient to develop and evaluate from scratch using large-scale pre-training. Therefore, the experiments presented in this section focuses on pre-trained models. Note that since the model architectures in pre-training and fine-tuning are the same, PipeTransformer can serve both. We discussed pre-training results in the Appendix.","__index_level_0__":2362}
+{"text":"<strong>Baseline.<\/strong> Experiments in this section compare PipeTransformer to the state-of-the-art framework, a hybrid scheme of PyTorch Pipeline (PyTorch\u2019s implementation of GPipe) and PyTorch DDP. Since this is the first paper that studies accelerating distributed training by freezing layers, there are no perfectly aligned counterpart solutions yet.","__index_level_0__":2363}
+{"text":"<strong>Hyper-parameters.<\/strong> Experiments use ViT-B\/16 (12 transformer layers, <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=16 \\times 16\"> input patch size) for ImageNet and CIFAR-100, BERT-large-uncased (24 layers) for SQuAD 1.1, and BERT-base-uncased (12 layers) for SST-2. With PipeTransformer, ViT and BERT training can set the per-pipeline batch size to around 400 and 64, respectively. Other hyperparameters (e.g., epoch, learning rate) for all experiments are presented in Appendix.","__index_level_0__":2364}
+{"text":"## Overall Training Acceleration\n<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/experiments_table1.png\" width=\"560\">\n<br>\n<\/p>","__index_level_0__":2365}
+{"text":"We summarize the overall experimental results in the table above. Note that the speedup we report is based on a conservative <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\alpha\"> <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\frac{1}{3}\"> value that can obtain comparable or even higher accuracy. A more aggressive <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\alpha\"> (<img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\frac{2}{5}\">, <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\frac{1}{2}\">) can obtain a higher speedup but may lead to a slight loss in accuracy. Note that the model size of BERT (24 layers) is larger than ViT-B\/16 (12 layers), thus it takes more time for communication.","__index_level_0__":2366}
+{"text":"## Performance Analysis","__index_level_0__":2367}
+{"text":"### Speedup Breakdown","__index_level_0__":2368}
+{"text":"This section presents evaluation results and analyzes the performance of different components in \\autopipe. More experimental results can be found in the Appendix.","__index_level_0__":2369}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/experiments_throughput.png\" width=\"560\">\n<br>\nFigure 9. Speedup Breakdown (ViT on ImageNet)\n<\/p>","__index_level_0__":2370}
+{"text":"To understand the efficacy of all four components and their impacts on training speed, we experimented with different combinations and used their training sample throughput (samples\/second) and speedup ratio as metrics. Results are illustrated in Figure 9. Key takeaways from these experimental results are:","__index_level_0__":2371}
+{"text":"1. the main speedup is the result of elastic pipelining which is achieved through the joint use of AutoPipe and AutoDP;\n2. AutoCache's contribution is amplified by AutoDP;\n3. freeze training alone without system-wise adjustment even downgrades the training speed.","__index_level_0__":2372}
+{"text":"### Tuning <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\alpha\"> in Freezing Algorithm","__index_level_0__":2373}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/experiments_tuning_alpha.png\" width=\"460\">\n<br>\nFigure 10. Tuning <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\alpha\"> in Freezing Algorithm\n<\/p>","__index_level_0__":2374}
+{"text":"We ran experiments to show how the <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\alpha\">  in the freeze algorithms influences training speed. The result clearly demonstrates that a larger <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\alpha\"> (excessive freeze) leads to a greater speedup but suffers from a slight performance degradation. In the case shown in Figure 10, where <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=\\alpha=1\/5\">, freeze training outperforms normal training and obtains a <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=2.04\">-fold speedup. We provide more results in the Appendix.","__index_level_0__":2375}
+{"text":"### Optimal Chunks in the elastic pipeline","__index_level_0__":2376}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/experiments_optimal_k.png\" width=\"450\">\n<br>\nFigure 11. Optimal chunk number in the elastic pipeline\n<\/p>","__index_level_0__":2377}
+{"text":"We profiled the optimal number of micro-batches <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M\"> for different pipeline lengths <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K\">. Results are summarized in Figure 11. As we can see, different <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K\"> values lead to different optimal <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=M\">, and the throughput gaps across different M values are large (as shown when <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=K=8\">), which confirms the necessity of an anterior profiler in elastic pipelining.","__index_level_0__":2378}
+{"text":"### Understanding the Timing of Caching","__index_level_0__":2379}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/experiment_autocache.png\" width=\"320\">\n<br>\nFigure 12. the timing of caching\n<\/p>","__index_level_0__":2380}
+{"text":"To evaluate AutoCache, we compared the sample throughput of training that activates AutoCache from epoch <img src=\"https:\/\/render.githubusercontent.com\/render\/math?math=0\"> (blue) with the training job without AutoCache (red). Figure 12 shows that enabling caching too early can slow down training, as caching can be more expensive than the forward propagation on a small number of frozen layers. After more layers are frozen, caching activations clearly outperform the corresponding forward propagation. As a result, AutoCache uses a profiler to determine the proper timing to enable caching. In our system, for ViT (12 layers), caching starts from 3 frozen layers, while for BERT (24 layers), caching starts from 5 frozen layers.","__index_level_0__":2381}
+{"text":"For more detailed experimental analysis, please refer to our paper.","__index_level_0__":2382}
+{"text":"# Summarization\nThis blog introduces PipeTransformer, a holistic solution that combines elastic pipeline-parallel and data-parallel for distributed training using PyTorch Distributed APIs. More specifically, PipeTransformer incrementally freezes layers in the pipeline, packs remaining active layers into fewer GPUs, and forks more pipeline replicas to increase the data-parallel width. Evaluations on ViT and BERT models show that compared to the state-of-the-art baseline, PipeTransformer attains up to 2.83\u00d7 speedups without accuracy loss.","__index_level_0__":2383}
+{"text":"\n# Reference","__index_level_0__":2384}
+{"text":"[1] Li, S., Zhao, Y., Varma, R., Salpekar, O., Noordhuis, P., Li,T., Paszke, A., Smith, J., Vaughan, B., Damania, P., et al. Pytorch Distributed:  Experiences on Accelerating Dataparallel Training. Proceedings of the VLDB Endowment,13(12), 2020","__index_level_0__":2385}
+{"text":"[2] Devlin, J., Chang, M. W., Lee, K., and Toutanova, K. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. In NAACL-HLT, 2019","__index_level_0__":2386}
+{"text":"[3] Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., Dehghani, M., Minderer, M., Heigold, G., Gelly, S., et al. An image is Worth 16x16 words: Transformers for Image Recognition at Scale.","__index_level_0__":2387}
+{"text":"[4] Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., Neelakantan, A., Shyam, P., Sastry, G., Askell, A., et al. Language Models are Few-shot Learners.","__index_level_0__":2388}
+{"text":"[5] Lepikhin, D., Lee, H., Xu, Y., Chen, D., Firat, O., Huang, Y., Krikun, M., Shazeer, N., and Chen, Z. Gshard: Scaling Giant Models with Conditional Computation and Automatic Sharding.","__index_level_0__":2389}
+{"text":"[6] Li, M., Andersen, D. G., Park, J. W., Smola, A. J., Ahmed, A., Josifovski, V., Long, J., Shekita, E. J., and Su, B. Y. Scaling Distributed Machine Learning with the Parameter Server. In 11th {USENIX} Symposium on Operating Systems Design and Implementation ({OSDI} 14), pp. 583\u2013598, 2014.","__index_level_0__":2390}
+{"text":"[7] Jiang, Y., Zhu, Y., Lan, C., Yi, B., Cui, Y., and Guo, C. A Unified Architecture for Accelerating Distributed DNN Training in Heterogeneous GPU\/CPU Clusters. In 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI 20), pp. 463\u2013479. USENIX Association, November 2020. ISBN 978-1-939133-19- 9.","__index_level_0__":2391}
+{"text":"[8] Kim, S., Yu, G. I., Park, H., Cho, S., Jeong, E., Ha, H., Lee, S., Jeong, J. S., and Chun, B. G. Parallax: Sparsity-aware Data Parallel Training of Deep Neural Networks. In Proceedings of the Fourteenth EuroSys Conference 2019, pp. 1\u201315, 2019.","__index_level_0__":2392}
+{"text":"[9] Kim, C., Lee, H., Jeong, M., Baek, W., Yoon, B., Kim, I., Lim, S., and Kim, S. TorchGPipe: On-the-fly Pipeline Parallelism for Training Giant Models.","__index_level_0__":2393}
+{"text":"[10] Huang, Y., Cheng, Y., Bapna, A., Firat, O., Chen, M. X., Chen, D., Lee, H., Ngiam, J., Le, Q. V., Wu, Y., et al. Gpipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism.","__index_level_0__":2394}
+{"text":"[11] Park, J. H., Yun, G., Yi, C. M., Nguyen, N. T., Lee, S., Choi, J., Noh, S. H., and ri Choi, Y. Hetpipe: Enabling Large DNN Training on (whimpy) Heterogeneous GPU Clusters through Integration of Pipelined Model Parallelism and Data Parallelism. In 2020 USENIX Annual Technical Conference (USENIX ATC 20), pp. 307\u2013321. USENIX Association, July 2020. ISBN 978-1-939133- 14-4.","__index_level_0__":2395}
+{"text":"[12] Narayanan, D., Harlap, A., Phanishayee, A., Seshadri, V., Devanur, N. R., Ganger, G. R., Gibbons, P. B., and Zaharia, M. Pipedream: Generalized Pipeline Parallelism for DNN Training. In Proceedings of the 27th ACM Symposium on Operating Systems Principles, SOSP \u201919, pp. 1\u201315, New York, NY, USA, 2019. Association for Computing Machinery. ISBN 9781450368735. doi: 10.1145\/3341301.3359646.","__index_level_0__":2396}
+{"text":"[13] Lepikhin, D., Lee, H., Xu, Y., Chen, D., Firat, O., Huang, Y., Krikun, M., Shazeer, N., and Chen, Z. Gshard: Scaling Giant Models with Conditional Computation and Automatic Sharding.","__index_level_0__":2397}
+{"text":"[14] Shazeer, N., Cheng, Y., Parmar, N., Tran, D., Vaswani, A., Koanantakool, P., Hawkins, P., Lee, H., Hong, M., Young, C., Sepassi, R., and Hechtman, B. Mesh-Tensorflow: Deep Learning for Supercomputers. In Bengio, S., Wallach, H., Larochelle, H., Grauman, K., Cesa-Bianchi, N., and Garnett, R. (eds.), Advances in Neural Information Processing Systems, volume 31, pp. 10414\u201310423. Curran Associates, Inc., 2018.","__index_level_0__":2398}
+{"text":"[15] Shoeybi, M., Patwary, M., Puri, R., LeGresley, P., Casper, J., and Catanzaro, B. Megatron-LM: Training Multi-billion Parameter Language Models using Model Parallelism.","__index_level_0__":2399}
+{"text":"[16] Rajbhandari, S., Rasley, J., Ruwase, O., and He, Y. ZERO: Memory Optimization towards Training a Trillion Parameter Models.","__index_level_0__":2400}
+{"text":"[17] Raghu, M., Gilmer, J., Yosinski, J., and Sohl Dickstein, J. Svcca: Singular Vector Canonical Correlation Analysis for Deep Learning Dynamics and Interpretability. In NIPS, 2017.","__index_level_0__":2401}
+{"text":"[18] Morcos, A., Raghu, M., and Bengio, S. Insights on Representational Similarity in Neural Networks with Canonical Correlation. In Bengio, S., Wallach, H., Larochelle, H., Grauman, K., Cesa-Bianchi, N., and Garnett, R. (eds.), Advances in Neural Information Processing Systems 31, pp. 5732\u20135741. Curran Associates, Inc., 2018.\n \n source: https:\/\/pytorch.org\/blog\/pipetransformer-automated-elastic-pipelining\/ \n category: pytorch blogs","__index_level_0__":2402}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Model Serving in PyTorch'\nauthor: Jeff Smith\nredirect_from: \/2019\/05\/08\/model-serving-in-pyorch.html\n---","__index_level_0__":2403}
+{"text":"PyTorch has seen a lot of adoption in research, but people can get confused about how well PyTorch models can be taken into production. This blog post is meant to clear up any confusion people might have about the road to production in PyTorch.\nUsually when people talk about taking a model \u201cto production,\u201d they usually mean performing **inference**, sometimes called model evaluation or prediction or serving. At the level of a function call, in PyTorch, inference looks something like this:","__index_level_0__":2404}
+{"text":"* In Python\n    * `module(input)`\n* In traced modules\n    * `module(input)`\n* In C++\n    * `at::Tensor output = module->forward(inputs).toTensor();`","__index_level_0__":2405}
+{"text":"Since we at Facebook perform inference operations using PyTorch hundreds of trillions of times per day, we've done a lot to make sure that inference runs as efficiently as possible.","__index_level_0__":2406}
+{"text":"## Serving Strategies","__index_level_0__":2407}
+{"text":"That zoomed-in view of how you use models in inference isn't usually the whole story, though. In a real world machine learning system, you often need to do more than just run a single inference operation in the REPL or Jupyter notebook. Instead, you usually need to integrate your model into a larger application in some way. Depending on what you need to do, you can usually take one of the following approaches.","__index_level_0__":2408}
+{"text":"### Direct embedding","__index_level_0__":2409}
+{"text":"In application settings like mobile, we often just directly call the model as part of a larger program. This isn't just for apps; usually this is how robotics and dedicated devices work as well. At a code-level, the call to the model is exactly the same as what is shown above in the section about inference shown above. A key concern is often that a Python interpreter is not present in such environments, which is why PyTorch allows you to call your models from C++ and ship a model without the need for a Python runtime.","__index_level_0__":2410}
+{"text":"### Model microservices","__index_level_0__":2411}
+{"text":"If you're using your model in a server side context and you're managing multiple models, you might choose to treat each individual model (or each individual model version) as a separate service, usually using some sort of packaging mechanism like a Docker container. Then that service is often made network accessible via some sort of service, either using JSON over HTTP or an RPC technology like gRPC. The key characteristic of this approach is that you're defining a service with a single endpoint that just calls your model. Then you do do all of your model management (promotion, rollback, etc.) via whatever system you already use to manage your services (e.g. kubernetes, ECS).","__index_level_0__":2412}
+{"text":"### Model servers","__index_level_0__":2413}
+{"text":"An additional possible solution is to use a model server. This is an application built to manage and serve models. It allows you to upload multiple models and get distinct prediction endpoints for each of them. Typically such systems include a number of other features to help solve more of the whole problem of managing and serving models. This can include things like metrics, visualization, data pre-processing, and more. Even something as simple as having a system for automatically versioning models can make building important features like model rollbacks much easier.","__index_level_0__":2414}
+{"text":"### Evolving Patterns","__index_level_0__":2415}
+{"text":"The above is a somewhat arbitrary breakdown of different approaches based on a snapshot in time. Design patterns are still evolving. Recently, model server designs have started to adopt more of the technologies of general service infrastructure such as Docker containers and kubernetes, so many model servers have started to share properties of the model microservice design discussed above. For a deeper dive into the general concepts of model server designs, you can check out my [book on machine learning systems](https:\/\/www.manning.com\/books\/machine-learning-systems).","__index_level_0__":2416}
+{"text":"## Serving PyTorch Models","__index_level_0__":2417}
+{"text":"So, if you're a PyTorch user, what should you use if you want to take your models to production?","__index_level_0__":2418}
+{"text":"If you're on mobile or working on an embedded system like a robot, direct embedding in your application is often the right choice. \nFor mobile specifically, your use case might be served by the ONNX export functionality.\nNote that ONNX, by its very nature, has limitations and doesn't support all of the functionality provided by the larger PyTorch project.\nYou can check out [this tutorial](https:\/\/pytorch.org\/tutorials\/advanced\/super_resolution_with_caffe2.html) on deploying PyTorch models to mobile using ONNX to see if this path might suit your use case. \nThat said, we've heard that there's a lot more that PyTorch users want to do on mobile, so look for more mobile-specific functionality in PyTorch in the future.\nFor other embedded systems, like robots, running [inference on a PyTorch model from the C++ API](https:\/\/pytorch.org\/tutorials\/advanced\/cpp_export.html) could be the right solution.","__index_level_0__":2419}
+{"text":"If you can't use the cloud or prefer to manage all services using the same technology, you can follow [this example](https:\/\/medium.com\/datadriveninvestor\/deploy-your-pytorch-model-to-production-f69460192217) to build a simple model microservice using the Flask web framework.","__index_level_0__":2420}
+{"text":"If you want to manage multiple models within a non-cloud service solution, there are teams developing PyTorch support in model servers like [MLFlow](https:\/\/mlflow.org\/), [Kubeflow](https:\/\/www.kubeflow.org\/), and [RedisAI.](https:\/\/oss.redislabs.com\/redisai\/) We're excited to see innovation from multiple teams building OSS model servers, and we'll continue to highlight innovation in the PyTorch ecosystem in the future.","__index_level_0__":2421}
+{"text":"If you can use the cloud for your application, there are several great choices for working with models in the cloud. For AWS Sagemaker, you can start find a guide to [all of the resources from AWS for working with PyTorch](https:\/\/docs.aws.amazon.com\/sagemaker\/latest\/dg\/pytorch.html), including docs on how to use the [Sagemaker Python SDK](https:\/\/sagemaker.readthedocs.io\/en\/stable\/using_pytorch.html). You can also see [some](https:\/\/youtu.be\/5h1Ot2dPi2E) [talks](https:\/\/youtu.be\/qc5ZikKw9_w) we've given on using PyTorch on Sagemaker. Finally, if you happen to be using PyTorch via FastAI, then they've written a [really simple guide](https:\/\/course.fast.ai\/deployment_amzn_sagemaker.html) to getting up and running on Sagemaker. ","__index_level_0__":2422}
+{"text":"The story is similar across other major clouds. On Google Cloud, you can follow [these instructions](https:\/\/cloud.google.com\/deep-learning-vm\/docs\/pytorch_start_instance) to get access to a Deep Learning VM with PyTorch pre-installed. On Microsoft Azure, you have a number of ways to get started from [Azure Machine Learning Service](https:\/\/azure.microsoft.com\/en-us\/services\/machine-learning-service\/) to [Azure Notebooks](https:\/\/notebooks.azure.com\/pytorch\/projects\/tutorials) showing how to use PyTorch.","__index_level_0__":2423}
+{"text":"## Your Models","__index_level_0__":2424}
+{"text":"Whichever approach you take to bringing your PyTorch models to production, we want to support you and enable your success. Do you love one of the options above? Are you having difficulty with that one crucial feature you can't find support for? We'd love to discuss more on the [deployment category](https:\/\/discuss.pytorch.org\/c\/deployment) on the PyTorch Discuss forums. We'd love to help, and where you're seeing success, amplify your story.\n \n source: https:\/\/pytorch.org\/blog\/model-serving-in-pyorch\/ \n category: pytorch blogs","__index_level_0__":2425}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Accelerating PyTorch with CUDA Graphs'\nauthor: Vinh Nguyen, Michael Carilli, Sukru Burc Eryilmaz, Vartika Singh, Michelle Lin, Natalia Gimelshein, Alban Desmaison, Edward Yang\nfeatured-img: 'assets\/images\/cudagraphs-pytorch.png'\n---","__index_level_0__":2426}
+{"text":"Today, we are pleased to announce a new advanced CUDA feature, CUDA Graphs, has been brought to PyTorch. Modern DL frameworks have complicated software stacks that incur significant overheads associated with the submission of each operation to the GPU. When DL workloads are strong-scaled to many GPUs for performance, the time taken by each GPU operation diminishes to just a few microseconds and, in these cases, the high work submission latencies of frameworks often lead to low utilization of the GPU. As GPUs get faster and workloads are scaled to more devices, the likelihood of workloads suffering from these launch-induced stalls increases. To overcome these performance overheads, NVIDIA engineers worked with PyTorch developers to enable CUDA graph execution natively in PyTorch. This design was instrumental in scaling NVIDIA\u2019s MLPerf workloads (implemented in PyTorch) to over 4000 GPUs in order to achieve [record-breaking performance](https:\/\/blogs.nvidia.com\/blog\/2021\/06\/30\/mlperf-ai-training-partners\/). ","__index_level_0__":2427}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/cudagraphs-pytorch.png\" width=\"100%\">\n<\/div>","__index_level_0__":2428}
+{"text":"CUDA graphs support in PyTorch is just one more example of a long collaboration between NVIDIA and Facebook engineers. [torch.cuda.amp](https:\/\/pytorch.org\/docs\/stable\/amp.html), for example, trains with half precision while maintaining the network accuracy achieved with single precision and automatically utilizing tensor cores wherever possible. AMP delivers up to 3X higher performance than FP32 with just a few lines of code change. Similarly, NVIDIA\u2019s [Megatron-LM](https:\/\/github.com\/NVIDIA\/Megatron-LM) was trained using PyTorch on up to 3072 GPUs. In PyTorch, one of the most performant methods to scale-out GPU training is with [torch.nn.parallel.DistributedDataParallel](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel) coupled with the NVIDIA Collective Communications Library ([NCCL](https:\/\/developer.nvidia.com\/nccl)) backend.","__index_level_0__":2429}
+{"text":"\n# CUDA Graphs","__index_level_0__":2430}
+{"text":"\n[CUDA Graphs](https:\/\/developer.nvidia.com\/blog\/cuda-10-features-revealed\/), which made its debut in CUDA 10, let a series of CUDA kernels to be defined and encapsulated as a single unit, i.e., a graph of operations, rather than a sequence of individually-launched operations. It provides a mechanism to launch multiple GPU operations through a single CPU operation, and hence reduces the launching overheads. ","__index_level_0__":2431}
+{"text":"The benefits of CUDA graphs can be demonstrated with the simple example in Figure 1. On the top, a sequence of short kernels is launched one-by-one by the CPU. The CPU launching overhead creates a significant gap in between the kernels. If we replace this sequence of kernels with a CUDA graph, initially we will need to spend a little extra time on building the graph and launching the whole graph in one go on the first occasion, but subsequent executions will be very fast, as there will be very little gap between the kernels. The difference is more pronounced when the same sequence of operations is repeated many times, for example, overy many training steps. In that case, the initial costs of building and launching the graph will be amortized over the entire number of training iterations. For a more comprehensive introduction on the topic, see our blog \n [Getting Started with CUDA Graphs](https:\/\/developer.nvidia.com\/blog\/cuda-graphs) and GTC talk [Effortless CUDA Graphs](https:\/\/www.nvidia.com\/en-us\/on-demand\/session\/gtcspring21-s32082\/).","__index_level_0__":2432}
+{"text":"\n<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/cuda-image-2.png\" alt=\"Cuda graphs reduce launching overhead by bundling multiple GPU operations into a single launchable unit, i.e., a graph. On the top, you can see five individual launches; whereas on the bottom, with CUDA graphs, they are all bundled into a single launch, reducing overhead.\" width=\"100%\">\n<br>\n\tFigure 1. Benefits of using CUDA graphs\n<\/p>","__index_level_0__":2433}
+{"text":"\n## NCCL support for CUDA graphs","__index_level_0__":2434}
+{"text":"\nThe previously mentioned benefits of reducing launch overheads also extend to NCCL kernel launches. NCCL enables GPU-based collective and P2P communications. With [NCCL support for CUDA graphs](https:\/\/docs.nvidia.com\/deeplearning\/nccl\/user-guide\/docs\/usage\/cudagraph.html), we can eliminate the NCCL kernel launch overhead. ","__index_level_0__":2435}
+{"text":"Additionally, kernel launch timing can be unpredictable due to various CPU load and operating system factors. Such time skews can be harmful to the performance of NCCL collective operations. With CUDA graphs, kernels are clustered together so that performance is consistent across ranks in a distributed workload. This is especially useful in large clusters where even a single slow node can bring down overall cluster level performance.","__index_level_0__":2436}
+{"text":"For distributed multi-GPU workloads, NCCL is used for collective communications. If we look at training a neural network that leverages data parallelism, without NCCL support for CUDA graphs, we\u2019ll need a separate launch for each of forward\/back propagation and NCCL AllReduce. By contrast, with NCCL support for CUDA graphs, we can reduce launch overhead by lumping together the forward\/backward propagation and NCCL AllReduce all in a single graph launch.","__index_level_0__":2437}
+{"text":"\n<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/cuda-image-3.png\" alt=\"With NCCL CUDA graph support, all the kernel launches for NCCL AllReduce for  the forward\/backward propagation can be bundled into a graph to reduce overhead launch time.\" width=\"100%\">\n<br>\n    Figure 2. Looking at a typical neural network, all the kernel launches for NCCL AllReduce can be bundled into a graph to reduce overhead launch time.\n<\/p>","__index_level_0__":2438}
+{"text":"\n# PyTorch CUDA Graphs","__index_level_0__":2439}
+{"text":"\nFrom PyTorch v1.10, the CUDA graphs functionality is made available as a set of beta APIs. ","__index_level_0__":2440}
+{"text":"### API overview","__index_level_0__":2441}
+{"text":"PyTorch supports the construction of CUDA graphs using [stream capture](https:\/\/docs.nvidia.com\/cuda\/cuda-c-programming-guide\/index.html#creating-a-graph-using-stream-capture), which puts a CUDA stream in capture mode. CUDA work issued to a capturing stream doesn\u2019t actually run on the GPU. Instead, the work is recorded in a graph. After capture, the graph can be launched to run the GPU work as many times as needed. Each replay runs the same kernels with the same arguments. For pointer arguments this means the same memory addresses are used. By filling input memory with new data (e.g., from a new batch) before each replay, you can rerun the same work on new data.","__index_level_0__":2442}
+{"text":"Replaying a graph sacrifices the dynamic flexibility of typical eager execution in exchange for greatly reduced CPU overhead. A graph\u2019s arguments and kernels are fixed, so a graph replay skips all layers of argument setup and kernel dispatch, including Python, C++, and CUDA driver overheads. Under the hood, a replay submits the entire graph\u2019s work to the GPU with a single call to [cudaGraphLaunch](https:\/\/docs.nvidia.com\/cuda\/cuda-runtime-api\/group__CUDART__GRAPH.html#group__CUDART__GRAPH_1g1accfe1da0c605a577c22d9751a09597). Kernels in a replay also execute slightly faster on the GPU, but eliding CPU overhead is the main benefit.","__index_level_0__":2443}
+{"text":"You should try CUDA graphs if all or part of your network is graph-safe (usually this means static shapes and static control flow, but see the other [constraints](https:\/\/pytorch.org\/docs\/master\/notes\/cuda.html#constraints)) and you suspect its runtime is at least somewhat CPU-limited.","__index_level_0__":2444}
+{"text":"### API example","__index_level_0__":2445}
+{"text":"PyTorch exposes graphs via a raw [`torch.cuda.CUDAGraph`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.graph.html#torch.cuda.graph)class and two convenience wrappers, [`torch.cuda.graph`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.graph.html#torch.cuda.graph) and [`torch.cuda.make_graphed_callables`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables).","__index_level_0__":2446}
+{"text":"[`torch.cuda.graph`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.graph.html#torch.cuda.graph) is a simple, versatile context manager that captures CUDA work in its context. Before capture, warm up the workload to be captured by running a few eager iterations. Warmup must occur on a side stream. Because the graph reads from and writes to the same memory addresses in every replay, you must maintain long-lived references to tensors that hold input and output data during capture. To run the graph on new input data, copy new data to the capture\u2019s input tensor(s), replay the graph, then read the new output from the capture\u2019s output tensor(s).","__index_level_0__":2447}
+{"text":"If the entire network is capture safe, one can capture and replay the whole network as in the following example. ","__index_level_0__":2448}
+{"text":"```python\nN, D_in, H, D_out = 640, 4096, 2048, 1024\nmodel = torch.nn.Sequential(torch.nn.Linear(D_in, H),\n                            torch.nn.Dropout(p=0.2),\n                            torch.nn.Linear(H, D_out),\n                            torch.nn.Dropout(p=0.1)).cuda()\nloss_fn = torch.nn.MSELoss()\noptimizer = torch.optim.SGD(model.parameters(), lr=0.1)","__index_level_0__":2449}
+{"text":"# Placeholders used for capture\nstatic_input = torch.randn(N, D_in, device='cuda')\nstatic_target = torch.randn(N, D_out, device='cuda')","__index_level_0__":2450}
+{"text":"# warmup\n# Uses static_input and static_target here for convenience,\n# but in a real setting, because the warmup includes optimizer.step()\n# you must use a few batches of real data.\ns = torch.cuda.Stream()\ns.wait_stream(torch.cuda.current_stream())\nwith torch.cuda.stream(s):\n    for i in range(3):\n        optimizer.zero_grad(set_to_none=True)\n        y_pred = model(static_input)\n        loss = loss_fn(y_pred, static_target)\n        loss.backward()\n        optimizer.step()\ntorch.cuda.current_stream().wait_stream(s)","__index_level_0__":2451}
+{"text":"# capture\ng = torch.cuda.CUDAGraph()\n# Sets grads to None before capture, so backward() will create\n# .grad attributes with allocations from the graph's private pool\noptimizer.zero_grad(set_to_none=True)\nwith torch.cuda.graph(g):\n    static_y_pred = model(static_input)\n    static_loss = loss_fn(static_y_pred, static_target)\n    static_loss.backward()\n    optimizer.step()","__index_level_0__":2452}
+{"text":"real_inputs = [torch.rand_like(static_input) for _ in range(10)]\nreal_targets = [torch.rand_like(static_target) for _ in range(10)]","__index_level_0__":2453}
+{"text":"for data, target in zip(real_inputs, real_targets):\n    # Fills the graph's input memory with new data to compute on\n    static_input.copy_(data)\n    static_target.copy_(target)\n    # replay() includes forward, backward, and step.\n    # You don't even need to call optimizer.zero_grad() between iterations\n    # because the captured backward refills static .grad tensors in place.\n    g.replay()\n    # Params have been updated. static_y_pred, static_loss, and .grad\n    # attributes hold values from computing on this iteration's data.\n```","__index_level_0__":2454}
+{"text":"If some of your network is unsafe to capture (e.g., due to dynamic control flow, dynamic shapes, CPU syncs, or essential CPU-side logic), you can run the unsafe part(s) eagerly and use [`torch.cuda.make_graphed_callables`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables) to graph only the capture-safe part(s). This is demonstrated next.","__index_level_0__":2455}
+{"text":"[`make_graphed_callables`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables) accepts callables (functions or [`nn.Module`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.nn.Module.html#torch.nn.Module) and returns graphed versions. By default, callables returned by [`make_graphed_callables`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables) are autograd-aware, and can be used in the training loop as direct replacements for the functions or [`nn.Module`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.nn.Module.html#torch.nn.Module) you passed. [`make_graphed_callables`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables) internally creates [`CUDAGraph`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.CUDAGraph.html#torch.cuda.CUDAGraph) objects, runs warm up iterations, and maintains static inputs and outputs as needed. Therefore, (unlike with [`torch.cuda.graph`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.graph.html#torch.cuda.graph)) you don\u2019t need to handle those manually.","__index_level_0__":2456}
+{"text":"In the following example, data-dependent dynamic control flow means the network isn\u2019t capturable end-to-end, but [`make_graphed_callables`](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables)() lets us capture and run graph-safe sections as graphs regardless:","__index_level_0__":2457}
+{"text":"\n```python\nN, D_in, H, D_out = 640, 4096, 2048, 1024","__index_level_0__":2458}
+{"text":"module1 = torch.nn.Linear(D_in, H).cuda()\nmodule2 = torch.nn.Linear(H, D_out).cuda()\nmodule3 = torch.nn.Linear(H, D_out).cuda()","__index_level_0__":2459}
+{"text":"loss_fn = torch.nn.MSELoss()\noptimizer = torch.optim.SGD(chain(module1.parameters(),\n                                  module2.parameters(),\n                                  module3.parameters()),\n                            lr=0.1)","__index_level_0__":2460}
+{"text":"# Sample inputs used for capture\n# requires_grad state of sample inputs must match\n# requires_grad state of real inputs each callable will see.\nx = torch.randn(N, D_in, device='cuda')\nh = torch.randn(N, H, device='cuda', requires_grad=True)","__index_level_0__":2461}
+{"text":"module1 = torch.cuda.make_graphed_callables(module1, (x,))\nmodule2 = torch.cuda.make_graphed_callables(module2, (h,))\nmodule3 = torch.cuda.make_graphed_callables(module3, (h,))","__index_level_0__":2462}
+{"text":"real_inputs = [torch.rand_like(x) for _ in range(10)]\nreal_targets = [torch.randn(N, D_out, device=\"cuda\") for _ in range(10)]","__index_level_0__":2463}
+{"text":"for data, target in zip(real_inputs, real_targets):\n    optimizer.zero_grad(set_to_none=True)","__index_level_0__":2464}
+{"text":"    tmp = module1(data)  # forward ops run as a graph","__index_level_0__":2465}
+{"text":"    if tmp.sum().item() > 0:\n        tmp = module2(tmp)  # forward ops run as a graph\n    else:\n        tmp = module3(tmp)  # forward ops run as a graph","__index_level_0__":2466}
+{"text":"    loss = loss_fn(tmp, target)\n    # module2's or module3's (whichever was chosen) backward ops,\n    # as well as module1's backward ops, run as graphs\n    loss.backward()\n    optimizer.step()\n```","__index_level_0__":2467}
+{"text":"# Example use cases\n## MLPerf v1.0 training workloads","__index_level_0__":2468}
+{"text":"The PyTorch CUDA graphs functionality was instrumental in scaling NVIDIA\u2019s MLPerf training v1.0 workloads (implemented in PyTorch) to over 4000 GPUs, setting new [records across the board](https:\/\/blogs.nvidia.com\/blog\/2021\/06\/30\/mlperf-ai-training-partners\/). We illustrate below two MLPerf workloads where the most significant gains were observed with the use of CUDA graphs, yielding up to ~1.7x speedup.","__index_level_0__":2469}
+{"text":"|                             | Number of GPUs  | Speedup from CUDA-graphs |\n|-----------------------------|----------------:|-------------------------:|\n| Mask R-CNN                  | 272             | 1.70\u00d7                    |\n| BERT                        | 4096            | 1.12\u00d7                    |","__index_level_0__":2470}
+{"text":"Table 1. MLPerf training v1.0 performance improvement with PyTorch CUDA graph.","__index_level_0__":2471}
+{"text":"### Mask R-CNN","__index_level_0__":2472}
+{"text":"Deep learning frameworks use GPUs to accelerate computations, but a significant amount of code still runs on CPU cores. CPU cores process meta-data like tensor shapes in order to prepare arguments needed to launch GPU kernels. Processing meta-data is a fixed cost while the cost of the computational work done by the GPUs is positively correlated with batch size. For large batch sizes, CPU overhead is a negligible percentage of total run time cost, but at small batch sizes CPU overhead can become larger than GPU run time. When that happens, GPUs go idle between kernel calls. This issue can be identified on an NSight timeline plot in Figure 3. The plot below shows the \u201cbackbone\u201d portion of Mask R-CNN with per-gpu batch size of 1 before graphing. The green portion shows CPU load while the blue portion shows GPU load. In this profile we see that the CPU is maxed out at 100% load while GPU is idle most of the time, there is a lot of empty space between GPU kernels.","__index_level_0__":2473}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/cuda-image-4.png\" alt=\"NSight timeline plot of Mask R-CNN shows that the CPU is maxed out at 100% load while GPU is idle most of the time, and a lot of empty space between GPU kernels\" width=\"100%\">\n<br>\n    Figure 3: NSight timeline plot of Mask R-CNN\n<\/p>","__index_level_0__":2474}
+{"text":"CUDA graphs can automatically eliminate CPU overhead when tensor shapes are static. A complete graph of all the kernel calls is captured during the first step, in subsequent steps the entire graph is launched with a single op, eliminating all the CPU overhead, as observed in Figure 4.. ","__index_level_0__":2475}
+{"text":"<p align=\"center\">\n<img src=\"{{ site.url }}\/assets\/images\/cuda-image-5.png\" alt=\"With CUDA graph, the entire graph is launched with a single op, eliminating all the CPU overhead\" width=\"100%\">\n<br>\n    Figure 4: CUDA graphs optimization\n<\/p>","__index_level_0__":2476}
+{"text":"With graphing, we see that the GPU kernels are tightly packed and GPU utilization remains high. The graphed portion now runs in 6 ms instead of 31ms, a speedup of 5x. We did not graph the entire model, mostly just the resnet backbone, which resulted in an overall speedup of ~1.7x.\nIn order to increase the scope of the graph, we made some changes in the software stack to eliminate some of the CPU-GPU synchronization points. In MLPerf v1.0, this work included changing the implementation of torch.randperm function to use CUB instead of Thrust because the latter is a synchronous C++ template library. These improvements are available in the latest NGC container.","__index_level_0__":2477}
+{"text":"Similarly, by graph capturing the model, we eliminate CPU overhead and accompanying synchronization overhead. CUDA graphs implementation results in a 1.12x performance boost for our max-scale BERT configuration. To maximize the benefits from CUDA graphs, it is important to keep the scope of the graph as large as possible. To achieve this, we modified the model script to remove CPU-GPU synchronizations during the execution such that the full model can be graph captured. Furthermore, we also made sure that the tensor sizes during the execution are static within the scope of the graph. For instance, in BERT, only a specific subset of total tokens contribute to loss function, determined by a pre-generated mask tensor. Extracting the indices of valid tokens from this mask, and using these indices to gather the tokens that contribute to the loss, results in a tensor with a dynamic shape, i.e. with shape that is not constant across iterations. In order to make sure tensor sizes are static, instead of using the dynamic-shape tensors in the loss computation, we used static shape tensors where a mask is used to indicate which elements are valid. As a result, all tensor shapes are static. Dynamic shapes also require CPU-GPU synchronization since it has to involve the framework\u2019s memory management on the CPU side. With static-only shapes, no CPU-GPU synchronizations are necessary. This is shown in Figure 5.","__index_level_0__":2479}
+{"text":"\n<p align=\"center\">\n\t<img src=\"{{ site.url }}\/assets\/images\/cuda-image-6.png\" width=\"100%\" alt=\"Synchronization free training eliminates CPU synchronization\">\n\t<br>\n\tFigure 5. By using a fixed size tensor and a boolean mask as described in the text, we are able to eliminate CPU synchronizations needed for dynamic sized tensors  \n<\/p>","__index_level_0__":2480}
+{"text":"\n## CUDA graphs in NVIDIA DL examples collection","__index_level_0__":2481}
+{"text":"Single GPU use cases can also benefit from using CUDA Graphs. This is particularly true for workloads launching many short kernels with small batches. A good example is training and inference for recommender systems. Below we present preliminary benchmark results for NVIDIA's implementation of the Deep Learning Recommendation Model (DLRM) from our Deep Learning Examples collection. Using CUDA graphs for this workload provides significant speedups for both training and inference. The effect is particularly visible when using very small batch sizes, where CPU overheads are more pronounced.","__index_level_0__":2482}
+{"text":"CUDA graphs are being actively integrated into other PyTorch NGC model scripts and the NVIDIA Github deep learning examples. Stay tuned for more examples on how to use it.","__index_level_0__":2483}
+{"text":"\n<p align=\"center\">\n\t<img src=\"{{ site.url }}\/assets\/images\/cuda-image-7.png\" alt=\"CUDA graphs optimization for the DLRM model. The impact is larger for smaller batch sizes where CPU overheads are more pronounced.\" width=\"100%\">\n<\/p>\n<p align=\"center\">\n\t<img src=\"{{ site.url }}\/assets\/images\/cuda-image-8.png\" alt=\"CUDA graphs optimization for the DLRM model. The impact is larger for smaller batch sizes where CPU overheads are more pronounced.\" width=\"100%\">\n<br>\n\tFigure 6: CUDA graphs optimization for the DLRM model.\n<\/p>","__index_level_0__":2484}
+{"text":"\n# Call to action: CUDA Graphs in PyTorch v1.10","__index_level_0__":2485}
+{"text":"CUDA graphs can provide substantial benefits for workloads that comprise many small GPU kernels and hence bogged down by CPU launch overheads. This has been demonstrated in our MLPerf efforts, optimizing PyTorch models. Many of these optimizations, including CUDA graphs, have or will eventually be integrated into our PyTorch NGC model scripts [collection](https:\/\/ngc.nvidia.com\/catalog\/collections?orderBy=scoreDESC&pageNumber=0&query=pytorch&quickFilter=&filters=) and the NVIDIA [Github deep learning examples](https:\/\/github.com\/NVIDIA\/DeepLearningExamples\/tree\/master\/PyTorch\/). For now, check out our open-source MLPerf training v1.0 [implementation](https:\/\/github.com\/mlcommons\/training_results_v1.0\/tree\/master\/NVIDIA) which could serve as a good starting point to see CUDA graph in action. Alternatively, try the PyTorch CUDA graphs API on your own workloads.","__index_level_0__":2486}
+{"text":"We thank many NVIDIAN\u2019s and Facebook engineers for their discussions and suggestions: \n[Karthik Mandakolathur US](mailto:karthik@nvidia.com),\n[Tomasz Grel](mailto:tgrel@nvidia.com), \n[PLJoey Conway](mailto:jconway@nvidia.com), \n[Arslan Zulfiqar US](mailto:azulfiqar@nvidia.com)","__index_level_0__":2487}
+{"text":"## Authors bios","__index_level_0__":2488}
+{"text":"[**Vinh Nguyen**](mailto:vinhn@nvidia.com)\n*DL Engineer, NVIDIA*","__index_level_0__":2489}
+{"text":"Vinh is a Deep learning engineer and data scientist, having published more than 50 scientific articles attracting more than 2500 citations. At NVIDIA, his work spans a wide range of deep learning and AI applications, including speech, language and vision processing, and recommender systems.","__index_level_0__":2490}
+{"text":"[**Michael Carilli**](mailto:mcarilli@nvidia.com)\n*Senior Developer Technology Engineer, NVIDIA*","__index_level_0__":2491}
+{"text":"Michael worked at the Air Force Research Laboratory optimizing CFD code for modern parallel architectures. He holds a PhD in computational physics from the University of California, Santa Barbara. A member of the PyTorch team, he focuses on making GPU training fast, numerically stable, and easy(er) for internal teams, external customers, and Pytorch community users.","__index_level_0__":2492}
+{"text":"[**Sukru Burc Eryilmaz**](mailto:seryilmaz@nvidia.com)\n*Senior Architect in Dev Arch, NVIDIA*","__index_level_0__":2493}
+{"text":"Sukru received his PhD from Stanford University, and B.S from Bilkent University. He currently works on improving the end-to-end performance of neural network training both at single-node scale and supercomputer scale. ","__index_level_0__":2494}
+{"text":"[**Vartika Singh**](mailto:vartikas@nvidia.com)\n*Tech Partner Lead for DL Frameworks and Libraries, NVIDIA*","__index_level_0__":2495}
+{"text":"Vartika has led teams working in confluence of cloud and distributed computing, scaling and AI, influencing the design and strategy of major corporations. She currently works with the major frameworks and compiler organizations and developers within and outside NVIDIA, to help the design to work efficiently and optimally on NVIDIA hardware.","__index_level_0__":2496}
+{"text":"[**Michelle Lin**](mailto:miclin@nvidia.com)\n*Product Intern, NVIDIA*","__index_level_0__":2497}
+{"text":"Michelle is currently pursuing an undergraduate degree in Computer Science and Business Administration at UC Berkeley. She is currently managing execution of projects such as conducting market research and creating marketing assets for Magnum IO.","__index_level_0__":2498}
+{"text":"[**Natalia Gimelshein**](mailto:ngimel@fb.com)\n*Applied Research Scientist, Facebook*","__index_level_0__":2499}
+{"text":"Natalia Gimelshein worked on GPU performance optimization for deep learning workloads at NVIDIA and Facebook. She is currently a member of the PyTorch core team, working with partners to seamlessly support new software and hardware features.","__index_level_0__":2500}
+{"text":"[**Alban Desmaison**](mailto:albandes@fb.com)\n*Research Engineer, Facebook*","__index_level_0__":2501}
+{"text":"Alban studied engineering and did a PhD in Machine Learning and Optimization, during which he was an OSS contributor to PyTorch prior to joining Facebook. His main responsibilities are maintaining some core library and features (autograd, optim, nn) and working on making PyTorch better in general.","__index_level_0__":2502}
+{"text":"[**Edward Yang**](mailto:ezyang@fb.com)\n*Research Engineer, Facebook*","__index_level_0__":2503}
+{"text":"Edward studied CS at MIT and then Stanford before starting at Facebook. He is a part of the PyTorch core team and is one of the leading contributors to PyTorch. \n \n source: https:\/\/pytorch.org\/blog\/accelerating-pytorch-with-cuda-graphs\/ \n category: pytorch blogs","__index_level_0__":2504}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 1.10 Release, including CUDA Graphs APIs, Frontend and Compiler Improvements'\nauthor: Team PyTorch\n---","__index_level_0__":2505}
+{"text":"We are excited to announce the release of PyTorch 1.10. This release is composed of over 3,400 commits since 1.9, made by 426 contributors. We want to sincerely thank our community for continuously improving PyTorch. ","__index_level_0__":2506}
+{"text":"PyTorch 1.10 updates are focused on improving training and performance of PyTorch, and developer usability. The full release notes are available [here](https:\/\/github.com\/pytorch\/pytorch\/releases\/tag\/v1.10.0). Highlights include:\n1. CUDA Graphs APIs are integrated to reduce CPU overheads for CUDA workloads.\n2. Several frontend APIs such as FX, torch.special, and nn.Module Parametrization, have moved from beta to stable.  \n3. Support for automatic fusion in JIT Compiler expands to CPUs in addition to GPUs.\n4. Android NNAPI support is now available in beta.","__index_level_0__":2507}
+{"text":"Along with 1.10, we are also releasing major updates to the PyTorch libraries, which you can read about in [this blog post](https:\/\/pytorch.org\/blog\/pytorch-1.10-new-library-releases\/).","__index_level_0__":2508}
+{"text":"# Frontend APIs","__index_level_0__":2510}
+{"text":"### (Stable) Python code transformations with FX","__index_level_0__":2511}
+{"text":"FX provides a Pythonic platform for transforming and lowering PyTorch programs. It is a toolkit for pass writers to facilitate Python-to-Python transformation of functions and nn.Module instances. This toolkit aims to support a subset of Python language semantics\u2014rather than the whole Python language\u2014to facilitate ease of implementation of transforms. With 1.10, FX is moving to stable. ","__index_level_0__":2512}
+{"text":"You can learn more about FX in the [official documentation](https:\/\/pytorch.org\/docs\/master\/fx.html) and [GitHub examples](https:\/\/github.com\/pytorch\/examples\/tree\/master\/fx) of program transformations implemented using ```torch.fx```.","__index_level_0__":2513}
+{"text":"### (Stable) *torch.special* \nA ```torch.special module```, analogous to [SciPy\u2019s special module](https:\/\/docs.scipy.org\/doc\/scipy\/reference\/special.html), is now available in stable. The module has 30 operations, including gamma, Bessel, and (Gauss) error functions. ","__index_level_0__":2514}
+{"text":"Refer to this [documentation](https:\/\/pytorch.org\/docs\/master\/special.html) for more details.","__index_level_0__":2515}
+{"text":"### (Stable) nn.Module Parametrization \n```nn.Module``` parametrizaton, a feature that allows users to parametrize any parameter or buffer of an ```nn.Module``` without modifying the ```nn.Module``` itself, is available in stable. This release adds weight normalization (```weight_norm```), orthogonal parametrization (matrix constraints and part of pruning) and more flexibility when creating your own parametrization.","__index_level_0__":2516}
+{"text":"Refer to this [tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/parametrizations.html) and the general [documentation](https:\/\/pytorch.org\/docs\/master\/generated\/torch.nn.utils.parametrizations.spectral_norm.html?highlight=parametrize) for more details.","__index_level_0__":2517}
+{"text":"### (Beta) CUDA Graphs APIs Integration\nPyTorch now integrates CUDA Graphs APIs to reduce CPU overheads for CUDA workloads.","__index_level_0__":2518}
+{"text":"CUDA Graphs greatly reduce the CPU overhead for CPU-bound cuda workloads and thus improve performance by increasing GPU utilization. For distributed workloads, CUDA Graphs also reduce jitter, and since parallel workloads have to wait for the slowest worker, reducing jitter improves overall parallel efficiency.","__index_level_0__":2519}
+{"text":"Integration allows seamless interop between the parts of the network captured by cuda graphs, and parts of the network that cannot be captured due to graph limitations. \n \nRead the [note](https:\/\/pytorch.org\/docs\/master\/notes\/cuda.html#cuda-graphs) for more details and examples, and refer to the general [documentation](https:\/\/pytorch.org\/docs\/master\/generated\/torch.cuda.CUDAGraph.html#torch.cuda.CUDAGraph) for additional information. ","__index_level_0__":2520}
+{"text":"### [Beta] Conjugate View\nPyTorch\u2019s conjugation for complex tensors ([torch.conj()](https:\/\/pytorch.org\/docs\/1.10.0\/generated\/torch.conj.html?highlight=conj#torch.conj)) is now a constant time operation, and returns a view of the input tensor with a conjugate bit set as can be seen by calling [torch.is_conj()](https:\/\/pytorch.org\/docs\/1.10.0\/generated\/torch.is_conj.html?highlight=is_conj#torch.is_conj) . This has already been leveraged in various other PyTorch operations like matrix multiplication, dot product etc., to fuse conjugation with the operation leading to significant performance gain and memory savings on both CPU and CUDA.","__index_level_0__":2521}
+{"text":"# Distributed Training","__index_level_0__":2522}
+{"text":"### Distributed Training Releases Now in Stable \nIn 1.10, there are a number of features that are moving from beta to stable in the distributed package:\n* **(Stable) Remote Module**: This feature allows users to operate a module on a remote worker like using a local module, where the RPCs are transparent to the user. Refer to this [documentation](https:\/\/pytorch.org\/docs\/master\/rpc.html#remotemodule) for more details.\n* **(Stable) DDP Communication Hook**: This feature allows users to override how DDP synchronizes gradients across processes. Refer to this [documentation](https:\/\/pytorch.org\/docs\/master\/rpc.html#remotemodule) for more details. \n* **(Stable) ZeroRedundancyOptimizer**: This feature can be used in conjunction with DistributedDataParallel to reduce the size of per-process optimizer states. With this stable release, it now can handle uneven inputs to different data-parallel workers. Check out this [tutorial](https:\/\/pytorch.org\/tutorials\/advanced\/generic_join.html). We also improved the parameter partition algorithm to better balance memory and computation overhead across processes. Refer to this [documentation](https:\/\/pytorch.org\/docs\/master\/distributed.optim.html) and this [tutorial](https:\/\/pytorch.org\/tutorials\/recipes\/zero_redundancy_optimizer.html) to learn more. ","__index_level_0__":2523}
+{"text":"# Performance Optimization and Tooling","__index_level_0__":2524}
+{"text":"### [Beta] Profile-directed typing in TorchScript \nTorchScript has a hard requirement for source code to have type annotations in order for compilation to be successful. For a long time, it was only possible to add missing or incorrect type annotations through trial and error (i.e., by fixing the type-checking errors generated by torch.jit.script one by one), which was inefficient and time consuming. ","__index_level_0__":2525}
+{"text":"Now, we have enabled profile directed typing for torch.jit.script by leveraging existing tools like MonkeyType, which makes the process much easier, faster, and more efficient. For more details, refer to the [documentation](https:\/\/pytorch.org\/docs\/1.9.0\/jit.html).","__index_level_0__":2526}
+{"text":"### (Beta) CPU Fusion \nIn PyTorch 1.10, we've added an LLVM-based JIT compiler for CPUs that can fuse together sequences of `torch` library calls to improve performance. While we've had this capability for some time on GPUs, this release is the first time we've brought compilation to the CPU.  \nYou can check out a few performance results for yourself in this [Colab notebook](https:\/\/colab.research.google.com\/drive\/1xaH-L0XjsxUcS15GG220mtyrvIgDoZl6?usp=sharing).","__index_level_0__":2527}
+{"text":"### (Beta) PyTorch Profiler \nThe objective of PyTorch Profiler is to target the execution steps that are the most costly in time and\/or memory, and visualize the workload distribution between GPUs and CPUs. PyTorch 1.10 includes the following key features:","__index_level_0__":2528}
+{"text":"* **Enhanced Memory View**: This helps you understand your memory usage better. This tool will help you avoid Out of Memory errors by showing active memory allocations at various points of your program run.\n* **Enhanced Automated Recommendations**: This helps provide automated performance recommendations to help optimize your model. The tools recommend changes to batch size, TensorCore, memory reduction technologies, etc.\n* **Enhanced Kernel View**: Additional columns show grid and block sizes as well as shared memory usage and registers per thread.\n* **Distributed Training**: Gloo is now supported for distributed training jobs.\n* **Correlate Operators in the Forward & Backward Pass**: This helps map the operators found in the forward pass to the backward pass, and vice versa, in a trace view.\n* **TensorCore**: This tool shows the Tensor Core (TC) usage and provides recommendations for data scientists and framework developers.\n* **NVTX**: Support for NVTX markers was ported from the legacy autograd profiler.\n* **Support for profiling on mobile devices**: The PyTorch profiler now has better integration with TorchScript and mobile backends, enabling trace collection for mobile workloads.","__index_level_0__":2529}
+{"text":"Refer to this [documentation](https:\/\/pytorch.org\/docs\/stable\/profiler.html) for details. Check out this [tutorial](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/profiler_recipe.html) to learn how to get started with this feature. ","__index_level_0__":2530}
+{"text":"# PyTorch Mobile","__index_level_0__":2531}
+{"text":"### (Beta) Android NNAPI Support in Beta \nLast year we [released prototype support](https:\/\/medium.com\/pytorch\/pytorch-mobile-now-supports-android-nnapi-e2a2aeb74534) for Android\u2019s Neural Networks API (NNAPI). NNAPI allows Android apps to run computationally intensive neural networks on the most powerful and efficient parts of the chips that power mobile phones, including GPUs (Graphics Processing Units) and NPUs (specialized Neural Processing Units). ","__index_level_0__":2532}
+{"text":"Since the prototype we\u2019ve added more op coverage, added support for load-time flexible shapes and ability to run the model on the host for testing. Try out this feature using the [tutorial](https:\/\/pytorch.org\/tutorials\/prototype\/nnapi_mobilenetv2.html).","__index_level_0__":2533}
+{"text":"Additionally, Transfer Learning steps have been added to Object Detection examples. Check out this [GitHub page](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/ObjectDetection#transfer-learning) to learn more. Please provide your feedback or ask questions on the [forum](https:\/\/discuss.pytorch.org\/c\/mobile\/18). You can also check out [this presentation](https:\/\/www.youtube.com\/watch?v=B-2spa3UCTU) to get an overview. ","__index_level_0__":2534}
+{"text":"Thanks for reading. If you\u2019re interested in these updates and want to join the PyTorch community, we encourage you to join the [discussion forums](https:\/\/discuss.pytorch.org\/) and [open GitHub issues](https:\/\/github.com\/pytorch\/pytorch\/issues). To get the latest news from PyTorch, follow us on [Twitter](https:\/\/twitter.com\/PyTorch), [Medium](https:\/\/medium.com\/pytorch), [YouTube](https:\/\/www.youtube.com\/pytorch), and [LinkedIn](https:\/\/www.linkedin.com\/company\/pytorch). ","__index_level_0__":2535}
+{"text":"Cheers!\nTeam PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.10-released\/ \n category: pytorch blogs","__index_level_0__":2536}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Ambient Clinical Intelligence: Generating Medical Reports with PyTorch\"\nauthor: Miguel Del-Agua, Principal Research Scientist, Nuance and Jeremy Jancsary, Senior Principal Research Scientist, Nuance\nfeatured-img: \"\"\n---","__index_level_0__":2537}
+{"text":"## Introduction","__index_level_0__":2538}
+{"text":"Complete and accurate clinical documentation is an essential tool for tracking patient care. It allows for treatment plans to be shared among care teams to aid in continuity of care and ensures a transparent and effective process for reimbursement.","__index_level_0__":2539}
+{"text":"Physicians are responsible for documenting patient care. Traditional clinical documentation methods have resulted in a sub-par patient-provider experience, less time interacting with patients, and decreased work-life balance.  A significant amount of physicians\u2019 time is spent in front of the computer doing administrative tasks. As a result, patients are less satisfied with the overall experience, and physicians, who prepare for years studying medicine, cannot practice at the top of their license and are burned out. Every hour physicians provide direct clinical face time to patients results in nearly two additional hours spent on EHR and desk work within the clinic day. Outside office hours, physicians [spend another 1 to 2 hours of personal](https:\/\/www.acpjournals.org\/doi\/10.7326\/m16-0961) time each night doing additional computer and other clerical work.","__index_level_0__":2540}
+{"text":"* [42% of all physicians reported having burnout. \u2013 Medscape](https:\/\/www.medscape.com\/slideshow\/2020-lifestyle-burnout-6012460)\n* [The problem has grown worse due to the pandemic with 64% of U.S. physicians now reporting burnout. - AAFP](https:\/\/www.aafp.org\/journals\/fpm\/blogs\/inpractice\/entry\/covid_burnout_survey.html#:~:text=Physician%20burnout%20was%20already%20a,5%2C000%20%E2%80%94%20practice%20in%20the%20U.S.)\n* [\"Too many bureaucratic tasks e.g., charting and paperwork\" is the leading contribution to burnout, increased computerization ranks 4th.](https:\/\/login.medscape.com\/login\/sso\/getlogin?urlCache=aHR0cHM6Ly93d3cubWVkc2NhcGUuY29tL3NsaWRlc2hvdy8yMDIwLWxpZmVzdHlsZS1idXJub3V0LTYwMTI0NjA%3D&ac=401) - Medscape\n* [75% of U.S. Consumers Wish Their Healthcare Experiences Were More Personalized,](https:\/\/www.businesswire.com\/news\/home\/20200218005006\/en\/75-of-U.S.-Consumers-Wish-Their-Healthcare-Experiences-Were-More-Personalized-Redpoint-Global-Survey-Reveals)- Business Wire\n* [61% of patients would visit their healthcare provider more often if the communication experience felt more personalized.](https:\/\/www.businesswire.com\/news\/home\/20200218005006\/en\/75-of-U.S.-Consumers-Wish-Their-Healthcare-Experiences-Were-More-Personalized-Redpoint-Global-Survey-Reveals)  \u2013 Business Wire","__index_level_0__":2541}
+{"text":"Physician burnout is one of the primary causes for increased [medical errors](https:\/\/www.ncbi.nlm.nih.gov\/pmc\/articles\/PMC6175626\/), malpractice suits, turnover, and decreased access to care. Burnout leads to an increase in healthcare costs and a decrease in overall patient satisfaction. [Burnout costs the United States $4.6 billion a year.](https:\/\/www.nejm.org\/doi\/full\/10.1056\/NEJMp2003149)","__index_level_0__":2542}
+{"text":"What can we do to bring back trust, joy, and humanity to the delivery of healthcare? A significant portion of the administrative work consists of entering patient data into Electronic Health Records (EHRs) and creating clinical documentation. Clinical documentation is created from information already in the EHR as well as from the patient-provider encounter conversation. ","__index_level_0__":2543}
+{"text":"This article will showcase how the Nuance Dragon Ambient eXperience (DAX), an AI-powered, voice-enabled, ambient clinical intelligence solution, automatically documents patient encounters accurately and efficiently at the point of care and the technologies that enable it.","__index_level_0__":2544}
+{"text":"Nuance DAX enhances the quality of care and patient experience, increases provider efficiency and satisfaction, and improves financial outcomes. It can be used in office and telehealth settings in all ambulatory specialties, including primary and urgent care.","__index_level_0__":2545}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/nuance-dragon-ambient-experience.png\" width=\"60%\">\n<\/p>","__index_level_0__":2546}
+{"text":"## Natural Language Processing","__index_level_0__":2547}
+{"text":"Natural Language Processing (NLP) is one of the most challenging fields in Artificial Intelligence (AI). It comprehends a set of algorithms that allow computers to understand or generate the language used by humans. These algorithms can process and analyze vast amounts of natural language data from different sources (either sound or text) to build models that can understand, classify, or even generate natural language as humans would. Like other fields in AI, NLP has significantly progressed thanks to the advent of Deep Learning (DL), which has resulted in models that can obtain results on par with humans in some tasks.","__index_level_0__":2548}
+{"text":"These advanced NLP techniques are being applied in healthcare. During a typical patient-provider encounter, a conversation ensues where the doctor constructs, through questions and answers, a chronological description of the development of the patient's presenting illness or symptoms. A physician examines the patient and makes clinical decisions to establish a diagnosis and determine a treatment plan. This conversation, and data in the EHR, provide the required information for physicians to generate the clinical documentation, referred to as medical reports.","__index_level_0__":2549}
+{"text":"Two main NLP components play a role in automating the creation of clinical documentation. The first component, Automatic Speech Recognition (ASR), is used to translate speech into text. It takes the audio recording of the encounter and generates a conversation transcription (cf. Figure 2). The second component, Automatic Text Summarization, helps generate summaries from large text documents. This component is responsible for understanding and capturing the nuances and most essential aspects from the transcribed conversation into a final report in narrative form (cf. Figure 3), structured form, or a combination of both.","__index_level_0__":2550}
+{"text":"We will focus on this second component, Automatic Text Summarization, which is a difficult task with many challenges:","__index_level_0__":2551}
+{"text":"* Its performance is tied to the ASR quality from multiple speakers (noisy input).\n* The input is conversational in nature and contains layman's terms.\n* Protected Health Information (PHI) regulations limit medical data access.\n* The information for one output sentence is potentially spread across multiple conversation turns.\n* There is no explicit sentence alignment between input and output.\n* Various medical specialties, encounter types, and EHR systems constitute a broad and complex output space. \n* Physicians have different styles of conducting encounters and have their preferences for medical reports; there is no standard. \n* Standard summarization metrics might differ from human judgment of quality.","__index_level_0__":2552}
+{"text":"<p align=\"center\">\n <img src=\"\/assets\/images\/ambient_clinical_intel_fig2.png\" width=\"60%\">\n<\/p>","__index_level_0__":2553}
+{"text":"<p align = \"center\">\nFigure 2: Transcript of a patient-doctor conversation\n<\/p>","__index_level_0__":2554}
+{"text":"<p align=\"center\">\n <img src=\"\/assets\/images\/ambient_clinical_intel_fig3.png\" width=\"60%\">\n<\/p>","__index_level_0__":2555}
+{"text":"<p align = \"center\">\nFigure 3: Excerpt of an AI-generated medical report. HPI stands for History of present illness.\n<\/p>","__index_level_0__":2556}
+{"text":"## Text Summarization with PyTorch and Fairseq","__index_level_0__":2557}
+{"text":"[PyTorch](https:\/\/pytorch.org\/) is an open-source machine learning framework developed by Facebook that helps researchers prototype Deep Learning models. The [Fairseq](https:\/\/github.com\/pytorch\/fairseq) toolkit is built on top of PyTorch and focuses on sequence generation tasks, such as Neural Machine Translation (NMT) or Text Summarization. Fairseq features an active community that is continuously providing reference implementations of state-of-the-art models. It contains many built-in components (model architectures, modules, loss functions, and optimizers) and is easily extendable with plugins.","__index_level_0__":2558}
+{"text":"Text summarization constitutes a significant challenge in NLP. We need models capable of generating a short version of a document while retaining the key points and avoiding uninformative content. These  challenges can be addressed with  different approaches. 1). Abstractive text summarization aimed at training models that can generate a summary in narrative form. 2). Extractive methods where the models are trained to select the most important parts from the input text. 3). A combination of the two, where the essential parts from the input are selected and then summarized in an abstractive fashion. Hence, summarization can be accomplished via a single end-to-end network or as a pipeline of extractive and abstractive components. To that end, Fairseq provides all the necessary tools to be successful in our endeavor. It features either end-to-end models such as the classical Transformer, different types of Language Models and pre-trained versions that enable researchers to focus on what matters most\u2014to build state-of-the-art models that generate valuable reports.","__index_level_0__":2559}
+{"text":"However, we are not just summarizing the transcribed conversation; we generate high-quality medical reports, which have many considerations.","__index_level_0__":2560}
+{"text":"* Every section of a medical report is different in terms of content, structure, fluency, etc.\n* All medical facts mentioned in the conversation should be present in the report, for example, a particular treatment or dosage.\n* In the healthcare domain, the vocabulary is extensive, and models need to deal with medical terminology.\n* Patient-doctor conversations are usually much longer than the final report.","__index_level_0__":2561}
+{"text":"All these challenges require our researchers to run a battery of extensive experiments. Thanks to the flexibility of PyTorch and Fairseq, their productivity has greatly increased. Further, the ecosystem offers an easy path from ideation, implementation, experimentation, and final roll-out to production. Using multiple GPUs or CPUs is as simple as providing an additional argument to the tools, and because of the tight Python integration, PyTorch code can be easily debugged.","__index_level_0__":2562}
+{"text":"In our continuous effort to contribute to the open-source community, features have been developed at Nuance and pushed to the Fairseq GitHub repository.  These try to overcome some of the challenges mentioned such as, facilitating copying of, especially rare or unseen, words from the input to summary, training speedups by improving Tensor Core utilization, and ensuring TorchScript compatibility of different Transformer configurations. Following, we will show an example of how to train a Transformer model with a Pointer Generator mechanism (Transformer-PG), which can copy words from the input.","__index_level_0__":2563}
+{"text":"## How to build a Transformer model with a Pointer Generator mechanism","__index_level_0__":2564}
+{"text":"In this step-by-step guide, it is assumed the user has already installed PyTorch and Fairseq.","__index_level_0__":2565}
+{"text":"### 1. Create a vocabulary and extend it with source position markers:","__index_level_0__":2566}
+{"text":"These markers will allow the model to point to any word in the input sequence.","__index_level_0__":2567}
+{"text":"```python\nvocab_size=<vocab_size>\nposition_markers=512\nexport LC_ALL=C\ncat train.src train.tgt |\n  tr -s '[:space:]' '\\n' |\n  sort |\n  uniq -c |\n  sort -k1,1bnr -k2 |\n  head -n \"$((vocab_size - 4))\" |\n  awk '{ print $2 \" \" $1 }' > dict.pg.txt\npython3 -c \"[print('<unk-{}> 0'.format(n)) for n in range($position_markers)]\" >> dict.pg.txt\n```","__index_level_0__":2568}
+{"text":"This will create a file \"dict.pg.txt\" that contains the \\<vocab_size> most frequent words followed by 512 position markers named from \"\\<unk-0>\" to \"\\<unk-511>\".","__index_level_0__":2569}
+{"text":"In case we have an input like","__index_level_0__":2570}
+{"text":"```python\nsrc = \"Hello, I'm The Dogtor\"\n```","__index_level_0__":2571}
+{"text":"it could happen that our model has been trained without the word \"Dogtor\" in its vocabulary. Therefore, when we feed this sequence into the model, it should be converted to:","__index_level_0__":2572}
+{"text":"```python\nsrc = \"Hello, I'm The <unk-3>\"\n```","__index_level_0__":2573}
+{"text":"Now, \"\\<unk-3>\" is part of our vocabulary and could be predicted by the model (this is where the pointer-generator comes in). In such a case, we will only need to post-process the output to replace \"\\<unk-3>\" by the word at input position 3.","__index_level_0__":2574}
+{"text":"### 2. Preprocess the text data to replace unknown words by its positional markers:","__index_level_0__":2575}
+{"text":"We can use the scripts from [https:\/\/github.com\/pytorch\/fairseq\/tree\/master\/examples\/pointer_generator](https:\/\/github.com\/pytorch\/fairseq\/tree\/master\/examples\/pointer_generator).","__index_level_0__":2576}
+{"text":"```python\n# Considering we have our data in:\n# train_src = \/path\/to\/train.src\n# train_tgt = \/path\/to\/train.tgt\n# valid_src = \/path\/to\/valid.src\n# valid_tgt = \/path\/to\/valid.tgt\n.\/preprocess.py --source \/path\/to\/train.src \\\n                --target \/path\/to\/train.tgt \\\n                --vocab <(cut -d' ' -f1 dict.pg.txt) \\\n                --source-out \/path\/to\/train.pg.src \\\n                --target-out \/path\/to\/train.pg.tgt","__index_level_0__":2577}
+{"text":".\/preprocess.py --source \/path\/to\/valid.src \\\n                --target \/path\/to\/valid.tgt \\\n                --vocab <(cut -d' ' -f1 dict.pg.txt) \\\n                --source-out \/path\/to\/valid.pg.src \\\n                --target-out \/path\/to\/valid.pg.tgt","__index_level_0__":2578}
+{"text":".\/preprocess.py --source \/path\/to\/test.src \\\n                --vocab <(cut -d' ' -f1 dict.pg.txt) \\\n                --source-out \/path\/to\/test.pg.src\n```","__index_level_0__":2579}
+{"text":"### 3. Now let's binarize the data, so that it can be processed faster:","__index_level_0__":2580}
+{"text":"```python\nfairseq-preprocess --task \"translation\" \\\n                   --source-lang \"pg.src\" \\\n                   --target-lang \"pg.tgt\" \\\n                   --trainpref \/path\/to\/train \\\n                   --validpref \/path\/to\/valid \\\n                   --srcdict dict.pg.txt \\\n                   --cpu \\\n                   --joined-dictionary \\\n                   --destdir <data_dir>\n```\t\t   \n\t\t\t\t   \nYou might notice the type of task is \"translation\". This is because there is no \"summarization\" task available; we could understand it as a kind of NMT task where the input and output languages are shared and the output (summary) is shorter than the input.","__index_level_0__":2581}
+{"text":"### 4. Now we can train the model:","__index_level_0__":2582}
+{"text":"```python\nfairseq-train <data_dir> \\\n              --save-dir <model_dir> \\\n              --task \"translation\" \\\n              --source-lang \"src\" \\\n              --target-lang \"tgt\" \\\n              --arch \"transformer_pointer_generator\" \\\n              --max-source-positions 512 \\\n              --max-target-positions 128 \\\n              --truncate-source \\\n              --max-tokens 2048 \\\n              --required-batch-size-multiple 1 \\\n              --required-seq-len-multiple 8 \\\n              --share-all-embeddings \\\n              --dropout 0.1 \\\n              --criterion \"cross_entropy\" \\\n              --optimizer adam \\\n              --adam-betas '(0.9, 0.98)' \\\n              --adam-eps 1e-9 \\\n              --update-freq 4 \\\n              --lr 0.004 \\\n              # Pointer Generator\n              --alignment-layer -1 \\\n              --alignment-heads 1 \\\n              --source-position-markers 512\n```","__index_level_0__":2583}
+{"text":"This configuration makes use of features Nuance has contributed back to Fairseq:","__index_level_0__":2584}
+{"text":"* Transformer with a Pointer Generator mechanism to facilitate copying of words from the input.\n* Sequence length padded to a multiple of 8 to better use tensor cores and reduce training time.","__index_level_0__":2585}
+{"text":"### 5. Now let's take a look at how to generate a summary with our new medical report generation system:","__index_level_0__":2586}
+{"text":"```python\nimport torch\nfrom examples.pointer_generator.pointer_generator_src.transformer_pg import TransformerPointerGeneratorModel","__index_level_0__":2587}
+{"text":"# Patient-Doctor conversation\ninput = \"[doctor] Lisa Simpson, thirty six year old female, presents to the clinic today because \" \\\n        \"she has severe right wrist pain\"","__index_level_0__":2588}
+{"text":"# Load the model\nmodel = TransformerPointerGeneratorModel.from_pretrained(data_name_or_path=<data_dir>,\n                                                         model_name_or_path=<model_dir>,\n                                                         checkpoint_file=\"checkpoint_best.pt\")","__index_level_0__":2589}
+{"text":"result = model.translate([input], beam=2)","__index_level_0__":2590}
+{"text":"print(result[0])\nMs. <unk-2> is a 36-year-old female who presents to the clinic today for evaluation of her right wrist.\n```","__index_level_0__":2591}
+{"text":"### 6. Alternatively, we can use fairseq-interactive and a postprocessing tool to substitute positional unknown tokens by its words from the input:","__index_level_0__":2592}
+{"text":"```python\nfairseq-interactive <data_dir> \\\n              --batch-size <batch_size> \\\n              --task translation \\\n              --source-lang src \\\n              --target-lang tgt \\\n              --path <model_dir>\/checkpoint_last.pt \\\n              --input \/path\/to\/test.pg.src \\\n              --buffer-size 20 \\\n              --max-len-a 0 \\\n              --max-len-b 128 \\\n              --beam 2 \\\n              --skip-invalid-size-inputs-valid-test | tee generate.out","__index_level_0__":2593}
+{"text":"grep \"^H-\" generate.out | cut -f 3- > generate.hyp","__index_level_0__":2594}
+{"text":".\/postprocess.py \\\n\t--source <(awk 'NF<512' \/path\/to\/test.pg.src) \\\n\t--target generate.hyp \\\n\t--target-out generate.hyp.processed\n```","__index_level_0__":2595}
+{"text":"Now we have the final set of reports in \"generate.hyp.processed\", with \"\\<unk-N>\" replaced by the original word from the input sequence.","__index_level_0__":2596}
+{"text":"## Model Deployment","__index_level_0__":2597}
+{"text":"PyTorch offers great flexibility in modeling and a rich surrounding ecosystem. However, while several recent articles have suggested that the use of PyTorch in research and academia may be close to surpassing TensorFlow, there seems to be an overall sense of TensorFlow being the preferred platform for deployment to production. Is this still the case in 2021? Teams looking to serve their PyTorch models in production have a few options.","__index_level_0__":2598}
+{"text":"Before describing our journey, let's take a brief detour and define the term model.","__index_level_0__":2599}
+{"text":"### Models as computation graphs","__index_level_0__":2600}
+{"text":"A few years back, it was still common for machine learning toolkits to support only particular classes of models of a rather fixed and rigid structure, with only a few degrees of freedom (like the kernel of a support vector machine or the number of hidden layers of a neural network). Inspired by foundational work in Theano, toolkits like Microsoft's CNTK or Google's TensorFlow were among the first to popularize a more flexible view on models, as computation graphs with associated parameters that can be estimated from data. This view blurred the boundaries between popular types of models (such as DNNs or SVMs), as it became easy to blend the characteristics of each into your type of graph. Still, such a graph had to be defined upfront before estimating its parameters, and it was pretty static. This made it easy to save models to a self-contained bundle, like a TensorFlow SavedModel (such a bundle simply contains the structure of the graph, as well as the concrete values of the estimated parameters). However, debugging such models can be difficult because the statements in the Python code that build the graph are logically separate from the lines that execute it. Researchers also long for easier ways of expressing dynamic behavior, such as the computation steps of the forward pass of a model being conditionally dependent on its input data (or its previous output).","__index_level_0__":2601}
+{"text":"Most recently, the above limitations have led to a second revolution spearheaded by PyTorch and TensorFlow 2. The computation graph is no longer defined explicitly. Instead, it will be populated implicitly as the Python code executes operations on tensor arguments. An essential technique that powers this development is automatic differentiation. As the computation graph is being built implicitly while executing the steps of the forward pass, all the necessary data will be tracked for later computation of the gradient concerning the model parameters. This allows for great flexibility in training a model, but it raises an important question. If the computation happening inside a model is only implicitly defined through our Python code's steps as it executes concrete data, what is it that we want to save as a model? The answer \u2013 at least initially \u2013 was the Python code with all its dependencies, along with the estimated parameters. This is undesirable for practical reasons. For instance, there is a danger that the team working on model deployment does not exactly reproduce the Python code dependencies used during training, leading to subtly divergent behavior. The solution typically consists of combining two techniques, scripting and tracing, that is, extra annotations in your Python code and execution of your code on exemplary input data, allowing PyTorch to define and save the graph that should be executed during later inference on new, unseen data. This requires some discipline by whoever creates the model code (arguably voiding some of the original flexibility of eager execution), but it results in a self-contained model bundle in TorchScript format. The solution in TensorFlow 2 is remarkably similar.","__index_level_0__":2602}
+{"text":"### Serving our report generation models","__index_level_0__":2603}
+{"text":"Our journey in deploying the report generation models reflects the above discussion. We started out serving our models by deploying the model code and its dependencies along with the parameter checkpoints in a custom Docker image exposing a gRPC service interface. However, we soon noticed that it became error-prone to replicate the exact code and environment used by the modeling team while estimating the parameters. Moreover, this approach prevented us from leveraging high-performance model serving frameworks like NVIDIA's Triton, which is written in C++ and requires self-contained models that can be used without a Python interpreter. At this stage, we were facing a choice between attempting to export our PyTorch models to ONNX or TorchScript format. ONNX is an open specification for representing machine learning models that increasingly finds adoption. It is powered by a high-performance runtime developed by Microsoft (ONNX Runtime). While we were able to achieve performance acceleration for our TensorFlow BERT-based model using ONNX Runtime, at the time one of our PyTorch model required some operators that weren\u2019t yet supported in ONNX. Rather than implement these using custom operators, we decided to look into TorchScript for the time being.","__index_level_0__":2604}
+{"text":"### A maturing ecosystem","__index_level_0__":2605}
+{"text":"Is it all roses? No, it has been a rockier journey than we expected. We encountered what seems to be a memory leak in the MKL libraries used by PyTorch while serving the PyTorch code directly. We encountered deadlocks in trying to load multiple models from multiple threads. We had difficulties exporting our models to ONNX and TorchScript formats. Models would not work out-of-the-box on hardware with multiple GPUs, they always accessed the particular GPU device on which they were exported. We encountered excessive memory usage in the Triton inference server while serving TorchScript models, which we found out was due to automatic differentiation accidentally being enabled during the forward pass. However, the ecosystem keeps improving, and there is a helpful and vibrant open-source community eager to work with us to mitigate such issues.","__index_level_0__":2606}
+{"text":"Where to go from here? For those that require the flexibility of serving PyTorch code directly, without going through the extra step of exporting self-contained models, it is worth pointing out that the TorchServe project now provides a way of bundling the code together with parameter checkpoints into a single servable archive, greatly reducing the risk of code and parameters running apart. To us, however, exporting models to TorchScript has proven beneficial. It provides a clear interface between modeling and deployment teams, and TorchScript further reduces the latency when serving models on GPU via its just-in-time compilation engine.","__index_level_0__":2607}
+{"text":"### Scaling at large and the future","__index_level_0__":2608}
+{"text":"Finally, efficient deployment to the cloud is about more than just computing the response of a single model instance efficiently. Flexibility is needed in managing, versioning and updating models. High-level scalability must be achieved via techniques such as load-balancing, horizontal scaling and vertical scaling. If many models are involved, scale-to-zero quickly becomes a topic as it is unacceptable to pay for serving models that do not answer any requests. Providing such extra functionality on top of a low-level inference server like Triton is the job of an orchestration framework. After gaining some first experience with KubeFlow, to that end, we decided to turn our attention to Azure ML, which provides similar functionality but integrates more deeply with the Azure platform, on which we crucially rely for large parts of our technology stack already. This part of our journey has just begun.","__index_level_0__":2609}
+{"text":"## Conclusion","__index_level_0__":2610}
+{"text":"Academia has long recognized that we are \"standing on the shoulders of giants.\" As Artificial Intelligence is maturing from a scientific discipline into technology, the same spirit of collaboration that originally fueled its scientific foundation has carried over into the world of software engineering. Open-source enthusiasts join technology companies worldwide to build open software ecosystems that allow for new angles at solving some of the most pressing challenges of modern society. In this article, we've taken a look at Nuance's [Dragon Ambient eXperience](http:\/\/www.nuance.com\/ambient), an AI-powered, voice-enabled solution that automatically documents patient care, reducing healthcare providers' administrative burdens. Nuance DAX improves the patient-provider experience, reduces physician burnout, and improves financial outcomes. It brings back trust, joy, and humanity to the delivery of healthcare. Fairseq and PyTorch have proven to be an incredible platform for powering this AI technology, and in turn, Nuance has contributed back some of its innovations in this space. For further reading, we invite you to take a look at our recent [ACL publication](https:\/\/www.aclweb.org\/anthology\/2020.nlpmc-1.4\/) and the [Nuance \"What's Next\" blog](https:\/\/whatsnext.nuance.com\/rd\/using-deep-learning-to-generate-medical-reports\/).\n \n source: https:\/\/pytorch.org\/blog\/ambient-clinical-intelligence-generating-medical-reports-with-pytorch\/ \n category: pytorch blogs","__index_level_0__":2611}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Microsoft becomes maintainer of the Windows version of PyTorch'\nauthor: Maxim Lukiyanov - Principal PM at Microsoft, Emad Barsoum - Group EM at Microsoft, Guoliang Hua - Principal EM at Microsoft, Nikita Shulga - Tech Lead at Facebook, Geeta Chauhan - PE Lead at Facebook, Chris Gottbrath - Technical PM at Facebook, Jiachen Pu - Engineer at Facebook","__index_level_0__":2612}
+{"text":"Along with the PyTorch 1.6 release, we are excited to announce that Microsoft has expanded its participation in the PyTorch community and will be responsible for the development and maintenance of the PyTorch build for Windows.","__index_level_0__":2614}
+{"text":"According to the latest [Stack Overflow developer survey](https:\/\/insights.stackoverflow.com\/survey\/2020#technology-developers-primary-operating-systems), Windows remains the primary operating system for the developer community (46% Windows vs 28% MacOS). [Jiachen Pu](https:\/\/github.com\/peterjc123) initially made a heroic effort to add support for PyTorch on Windows, but due to limited resources, Windows support for PyTorch has lagged behind other platforms. Lack of test coverage resulted in unexpected issues popping up every now and then. Some of the core tutorials, meant for new users to learn and adopt PyTorch, would fail to run. The installation experience was also not as smooth, with the lack of official PyPI support for PyTorch on Windows. Lastly, some of the PyTorch functionality was simply not available on the Windows platform, such as the TorchAudio domain library and distributed training support. To help alleviate this pain, Microsoft is happy to bring its Windows expertise to the table and bring PyTorch on Windows to its best possible self.","__index_level_0__":2615}
+{"text":"In the PyTorch 1.6 release, we have improved the core quality of the Windows build by bringing test coverage up to par with Linux for core PyTorch and its domain libraries and by automating tutorial testing. Thanks to the broader PyTorch community, which contributed TorchAudio support to Windows, we were able to add test coverage to all three domain libraries: TorchVision, TorchText and TorchAudio. In subsequent releases of PyTorch, we will continue improving the Windows experience based on community feedback and requests. So far, the feedback we received from the community points to distributed training support and a better installation experience using pip as the next areas of improvement. ","__index_level_0__":2616}
+{"text":"In addition to the native Windows experience, Microsoft released a preview adding [GPU compute support to Windows Subsystem for Linux (WSL) 2](https:\/\/blogs.windows.com\/windowsdeveloper\/2020\/06\/17\/gpu-accelerated-ml-training-inside-the-windows-subsystem-for-linux\/) distros, with a focus on enabling AI and ML developer workflows. WSL is designed for developers that want to run any Linux based tools directly on Windows. This preview enables valuable scenarios for a variety of frameworks and Python packages that utilize [NVIDIA CUDA](https:\/\/developer.nvidia.com\/cuda\/wsl) for acceleration and only support Linux. This means WSL customers using the preview can run native Linux based PyTorch applications on Windows unmodified without the need for a traditional virtual machine or a dual boot setup.","__index_level_0__":2617}
+{"text":"## Getting started with PyTorch on Windows\nIt's easy to get started with PyTorch on Windows. To install PyTorch using Anaconda with the latest GPU support, run the command below. To install different supported configurations of PyTorch, refer to the installation instructions on [pytorch.org](https:\/\/pytorch.org).","__index_level_0__":2618}
+{"text":"`conda install pytorch torchvision cudatoolkit=10.2 -c pytorch`","__index_level_0__":2619}
+{"text":"Once you install PyTorch, learn more by visiting the [PyTorch Tutorials](https:\/\/pytorch.org\/tutorials\/beginner\/deep_learning_60min_blitz.html) and [documentation](https:\/\/pytorch.org\/docs\/stable\/index.html).","__index_level_0__":2620}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/pytorch1.6.png\" width=\"100%\">\n<\/div>","__index_level_0__":2621}
+{"text":"## Getting started with PyTorch on Windows Subsystem for Linux\nThe [preview of NVIDIA CUDA support in WSL](https:\/\/docs.microsoft.com\/en-us\/windows\/win32\/direct3d12\/gpu-cuda-in-wsl) is now available to Windows Insiders running Build 20150 or higher. In WSL, the command to install PyTorch using Anaconda is the same as the above command for native Windows. If you prefer pip, use the command below.","__index_level_0__":2622}
+{"text":"`pip install torch torchvision`","__index_level_0__":2623}
+{"text":"You can use the same tutorials and documentation inside your WSL environment as on native Windows. This functionality is still in preview so if you run into issues with WSL please share feedback via the [WSL GitHub repo](https:\/\/github.com\/microsoft\/WSL) or with NVIDIA CUDA support share via NVIDIA\u2019s [Community Forum for CUDA on WSL](https:\/\/forums.developer.nvidia.com\/c\/accelerated-computing\/cuda\/cuda-on-windows-subsystem-for-linux\/303).","__index_level_0__":2624}
+{"text":"## Feedback\nIf you find gaps in the PyTorch experience on Windows, please let us know on the [PyTorch discussion forum](https:\/\/discuss.pytorch.org\/c\/windows\/26) or file an issue on [GitHub](https:\/\/github.com\/pytorch\/pytorch) using the #module: windows label.\n \n source: https:\/\/pytorch.org\/blog\/microsoft-becomes-maintainer-of-the-windows-version-of-pytorch\/ \n category: pytorch blogs","__index_level_0__":2625}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Accelerated PyTorch 2 Transformers\"\nauthor: Michael Gschwind, Driss Guessous, Christian Puhrsch\n---","__index_level_0__":2626}
+{"text":"The PyTorch 2.0 release includes a new high-performance implementation of the PyTorch Transformer API with the goal of making training and deployment of state-of-the-art Transformer models affordable.  Following the successful release of \u201cfastpath\u201d inference execution (\u201cBetter Transformer\u201d), this release introduces high-performance support for training and inference using a custom kernel architecture for scaled dot product attention (SPDA).  ","__index_level_0__":2627}
+{"text":"You can take advantage of the new fused SDPA kernels either by calling the new SDPA operator directly (as described in the [SDPA tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/scaled_dot_product_attention_tutorial.html#beta-implementing-high-performance-transformers-with-scaled-dot-product-attention-sdpa)), or transparently via integration into the pre-existing PyTorch Transformer API.  All features of the PyTorch Transformer API will continue to work compatibly, with many features mapped to high-performance SDPA kernels, while other features are impossible to support with higher performance (e.g., need_weights, as per below) while expanded high-performance support for other features may still be under active development.  \\\n \\\nSimilar to the \u201cfastpath\u201d architecture, custom kernels are fully integrated into the PyTorch Transformer API \u2013 thus, using the native Transformer and MultiHeadAttention API will enable users to transparently see significant speed improvements.  Unlike the \u201cfastpath\u201d architecture, the newly introduced \u201ccustom kernels\u201d support many more use cases including models using Cross-Attention, Transformer Decoders, and for training models, in addition to the existing fastpath inference for fixed and variable sequence length Transformer Encoder and Self Attention use cases.","__index_level_0__":2628}
+{"text":"To take full advantage of different hardware models and Transformer use cases, multiple SDPA custom kernels are supported, with custom kernel selection logic that will pick the highest-performance kernel for a given model and hardware type.  In particular, the first custom kernels included with the PyTorch 2.0 release are the [Flash Attention](https:\/\/arxiv.org\/abs\/2205.14135) kernel (sdpa_flash, for 16-bit floating point training and inference on Nvidia GPUs with SM80+ architecture level) and the [xFormers memory-efficient attention](https:\/\/github.com\/facebookresearch\/xformers) kernel (sdpa_mem_eff, for 16-bit and 32-bit floating point training and inference on a broad range of Nvidia GPUs).  A general-purpose kernel sdpa_math provides an implementation when the custom kernels are not applicable. ","__index_level_0__":2629}
+{"text":"As mentioned, custom kernels provide a wider range of support for execution scenarios To ensure efficient execution (e,g., to use GPU tensor cores), model configurations need to meet a small number of requirements.  This list of requirements will evolve over time, prospectively relaxing constraints limiting the usage of currently supported custom kernels, or providing additional kernels in the future.","__index_level_0__":2630}
+{"text":"For the most up to date list of custom kernels and dispatch constraints, you can refer to [sdp_utils.h](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/aten\/src\/ATen\/native\/transformers\/cuda\/sdp_utils.h).  As of PyTorch 2.0, the existing fused SDPA kernels have the following constraints:","__index_level_0__":2631}
+{"text":"* Flash Attention only supports 16 bit floating point data types (float16 and bfloat16).\n* The head dimension must be a multiple of 8 for 16-bit floating point numbers and a multiple of 4 for 32-bit floating point numbers. At present, the maximum head_dim support for the Flash Attention custom kernel is 128.\n* The CUDA architecture level must be sm5x or better for the mem_efficient kernel, and sm80 for Flash Attention.\n* Flash Attention supports arbitrary dropout, in PyTorch 2.0 the mem_efficient kernel does not support dropout (i.e., dropout must be set to zero for this kernel to be selected in PyTorch 2.0). \n* To support variable-sequence length batches, all SDPA kernels support Nested Tensor inputs that combine input data and padding information using variable sequence length tensors for forward. (You can find more information about Nested Tensors in the [Nested Tensor tutorial](https:\/\/pytorch.org\/tutorials\/prototype\/nestedtensor.html).)\n* You can specify both a _key_padding_mask_ and an _attn_mask_ by combining them before passing them to the SDPA operator. In particular, you can use the per-batch-element key padding mask of the nn.Transformer API to implement training for variable-sequence length inputs in a batch.\n* At present, the only attention mask supported by fused kernel implementation is the causal mask commonly used for training. To specify the causal mask in custom kernels, it must be specified with the _is_causal_ boolean and _attn_mask_ must be None. \n* Support for Nested Tensors is still under development.  Specifically, in PyTorch 2.0, only the sdpa_math kernel supports training with Nested Tensors. Also, PyTorch 2.0 does not support Nested Tensors as part of code being compiled with torch.compile(). \n* The SDPA operator does not support returning averaged attention weights because computing them defeats the optimizations that enabled fused kernels to execute more efficiently.  The argument _need_weights_ for torch.nn.MultiheadAttention's forward function defaults to True. In order to use the fused kernels, _need_weights_ needs to be set to _need_weights=False_.","__index_level_0__":2633}
+{"text":"We find that an attention mask is rarely used in real-world applications, except for the causal mask during training.  Consequently, we reduce kernel complexity and compute cost by building in the option to use a causal mask as attention mask, and select this new capability with the _is_causal_ parameter introduced in conjunction with the new SDPA operator.  ","__index_level_0__":2634}
+{"text":"Providing the _is_causal_ Boolean flag for the frequently used causal mask also obviates the expensive and memory-intensive allocation of a causal mask, increasing training memory efficiency by allowing more memory to be used for large batch sizes, and reduce memory bandwidth and cache contention \u2013 which are both at a premium in GPU accelerators \u2013 by not needing to load an attention mask tensor.","__index_level_0__":2635}
+{"text":"If the constraints of none of the available custom kernels are met, then training falls back to using the default sdpa_math kernel, implementing the mathematical equations for scaled dot product attention using a sequence of PyTorch operator to implement SDPA.  This is the most general \u201ccatch-all\u201d fallback kernel to ensure successful training for all models.","__index_level_0__":2636}
+{"text":"In addition to the existing Transformer API, model developers may also use the scaled dot product attention kernels directly by calling the new `scaled_dot_product_attention()` operator.  This operator may be used to efficiently implement multi-head attention by combining it with in-projection and outprojection, as described in the [SDPA tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/scaled_dot_product_attention_tutorial.html). ","__index_level_0__":2637}
+{"text":"In addition to adding custom kernels, Accelerated PyTorch 2 Transformers are integrated with PyTorch 2.0 compilation.  To use your model while benefiting from the additional acceleration of PT2-compilation (for inference or training), pre-process the model with","__index_level_0__":2638}
+{"text":"\n```\nmodel = torch.compile(model)\n```","__index_level_0__":2639}
+{"text":"\nWe have achieved major speedups for training transformer models and in particular large language models with Accelerated PyTorch 2 Transformers using a combination of custom kernels and torch.compile(). ","__index_level_0__":2640}
+{"text":"\n![Better Transformer chart](\/assets\/images\/pytorch_better_transformer_chart1.png){:width=\"100%\"}\n<small style=\"line-height: 1.1\"><em>Figure: Using scaled dot product attention with custom kernels and torch.compile delivers significant speedups for training large language models, such as for [nanoGPT](https:\/\/github.com\/karpathy\/nanoGPT) shown here.<\/em><\/small>","__index_level_0__":2641}
+{"text":"Finally, because the custom kernels are much more memory efficient, try to increase the size of training batches to achieve faster training with increased batch size.","__index_level_0__":2642}
+{"text":"In addition to automatic kernel selection, a context manager enables developers to override the kernel selection algorithm \u2013 this is not required for day to day operation, but enables developers to debug their code as well as enable performance engineers to override kernel selection. The SDPA tutorial provides additional information on using the SDPA context manager.","__index_level_0__":2643}
+{"text":"In addition to availability as part of the nn.Transformer API, Accelerated PyTorch 2 Transformer custom kernels are also available in conjunction with the torchtext, torchvision, and fairseq domain libraries with the launch of PyTorch 2.0. \n source: https:\/\/pytorch.org\/blog\/accelerated-pytorch-2\/ \n category: pytorch blogs","__index_level_0__":2644}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Mapillary Research: Seamless Scene Segmentation and In-Place Activated BatchNorm'\nauthor: Lorenzo Porzi, Mapillary\nredirect_from: \/2019\/07\/23\/mapillary-research.html\n---","__index_level_0__":2645}
+{"text":"With roads in developed countries like the US changing up to 15% annually, Mapillary addresses a growing demand for keeping maps updated by combining images from any camera into a 3D visualization of the world. Mapillary's independent and collaborative approach enables anyone to collect, share, and use street-level images for improving maps, developing cities, and advancing the automotive industry.","__index_level_0__":2646}
+{"text":"Today, people and organizations all over the world have contributed more than 600 million images toward Mapillary's mission of helping people understand the world's places through images and making this data available, with clients and partners including the World Bank, HERE, and Toyota Research Institute.","__index_level_0__":2647}
+{"text":"Mapillary\u2019s computer vision technology brings intelligence to maps in an unprecedented way, increasing our overall understanding of the world. [Mapillary](https:\/\/www.mapillary.com\/) runs state-of-the-art semantic image analysis and image-based 3d modeling at scale and on all its images. In this post we discuss two recent works from Mapillary Research and their implementations in PyTorch - Seamless Scene Segmentation [1] and In-Place Activated BatchNorm [2] - generating Panoptic segmentation results and saving up to 50% of GPU memory during training, respectively.","__index_level_0__":2648}
+{"text":"## Seamless Scene Segmentation","__index_level_0__":2649}
+{"text":"_Github project page: [https:\/\/github.com\/mapillary\/seamseg\/](https:\/\/github.com\/mapillary\/seamseg\/)_","__index_level_0__":2650}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/seamless.png\" width=\"100%\">\n<\/div>","__index_level_0__":2651}
+{"text":"The objective of Seamless Scene Segmentation is to predict a \u201cpanoptic\u201d segmentation [3] from an image, that is a complete labeling where each pixel is assigned with a class id and, where possible, an instance id. Like many modern CNNs dealing with instance detection and segmentation, we adopt the Mask R-CNN framework [4], using ResNet50 + FPN [5] as a backbone. This architecture works in two stages: first, the \u201cProposal Head\u201d selects a set of candidate bounding boxes on the image (i.e. the proposals) that could contain an object; then, the \u201cMask Head\u201d focuses on each proposal, predicting its class and segmentation mask. The output of this process is a \u201csparse\u201d instance segmentation, covering only the parts of the image that contain countable objects (e.g. cars and pedestrians).","__index_level_0__":2652}
+{"text":"To complete our panoptic approach coined Seamless Scene Segmentation, we add a third stage to Mask R-CNN. Stemming from the same backbone, the \u201cSemantic Head\u201d predicts a dense semantic segmentation over the whole image, also accounting for the uncountable or amorphous classes (e.g. road and sky). The outputs of the Mask and Semantic heads are finally fused using a simple non-maximum suppression algorithm to generate the final panoptic prediction. All details about the actual network architecture, used losses and underlying math can be found at the [project website](https:\/\/research.mapillary.com\/publication\/cvpr19a) for our CVPR 2019 paper [1].","__index_level_0__":2653}
+{"text":"While several versions of Mask R-CNN are publicly available, including an [official implementation](https:\/\/github.com\/facebookresearch\/Detectron) written in Caffe2, at Mapillary we decided to build Seamless Scene Segmentation from scratch using PyTorch, in order to have full control and understanding of the whole pipeline. While doing so we encountered a couple of main stumbling blocks, and had to come up with some creative workarounds we are going to describe next.","__index_level_0__":2654}
+{"text":"## Dealing with variable-sized tensors","__index_level_0__":2655}
+{"text":"Something that sets aside panoptic segmentation networks from traditional CNNs is the prevalence of variable-sized data. In fact, many of the quantities we are dealing with cannot be easily represented with fixed sized tensors: each image contains a different number of objects, the Proposal head can produce a different number of proposals for each image, and the images themselves can have different sizes. While this is not a problem per-se -- one could just process images one at a time -- we would still like to exploit batch-level parallelism as much as possible. Furthermore, when performing distributed training with multiple GPUs, `DistributedDataParallel` expects its inputs to be batched, uniformly-sized tensors.","__index_level_0__":2656}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/packed_sequence.png\" width=\"100%\">\n<\/div>","__index_level_0__":2657}
+{"text":"Our solution to these issues is to wrap each batch of variable-sized tensors in a `PackedSequence`. `PackedSequence` is little more than a glorified list class for tensors, tagging its contents as \u201crelated\u201d, ensuring that they all share the same type, and providing useful methods like moving all the tensors to a particular device, etc. When performing light-weight operations that wouldn\u2019t be much faster with batch-level parallelism, we simply iterate over the contents of the `PackedSequence` in a for loop. When performance is crucial, e.g. in the body of the network, we simply concatenate the contents of the PackedSequence, adding zero padding as required (like in RNNs with variable-length inputs), and keeping track of the original dimensions of each tensor.","__index_level_0__":2658}
+{"text":"`PackedSequence`s also help us deal with the second problem highlighted above. We slightly modify `DistributedDataParallel` to recognize `PackedSequence` inputs, splitting them in equally sized chunks and distributing their contents across the GPUs.","__index_level_0__":2659}
+{"text":"## Asymmetric computational graphs with Distributed Data Parallel","__index_level_0__":2660}
+{"text":"Another, perhaps more subtle, peculiarity of our network is that it can generate asymmetric computational graphs across GPUs. In fact, some of the modules that compose the network are \u201coptional\u201d, in the sense that they are not always computed for all images. As an example, when the Proposal head doesn\u2019t output any proposal, the Mask head is not traversed at all. If we are training on multiple GPUs with `DistributedDataParallel`, this results in one of the replicas not computing gradients for the Mask head parameters.","__index_level_0__":2661}
+{"text":"Prior to PyTorch 1.1, this resulted in a crash, so we had to develop a workaround. Our simple but effective solution was to compute a \u201cfake forward pass\u201d when no actual forward is required, i.e. something like this:","__index_level_0__":2662}
+{"text":"```python\ndef fake_forward():\n    fake_input = get_correctly_shaped_fake_input()\n    fake_output = mask_head(fake_input)\n    fake_loss = fake_output.sum() * 0\n    return fake_loss\n```","__index_level_0__":2663}
+{"text":"Here, we generate a batch of bogus data, pass it through the Mask head, and return a loss that always back-progates zeros to all parameters.","__index_level_0__":2664}
+{"text":"Starting from PyTorch 1.1 this workaround is no longer required: by setting `find_unused_parameters=True` in the constructor, `DistributedDataParallel` is told to identify parameters whose gradients have not been computed by all replicas and correctly handle them. This leads to some substantial simplifications in our code base!","__index_level_0__":2665}
+{"text":"## In-place Activated BatchNorm","__index_level_0__":2666}
+{"text":"_Github project page: [https:\/\/github.com\/mapillary\/inplace_abn\/](https:\/\/github.com\/mapillary\/inplace_abn\/)_","__index_level_0__":2667}
+{"text":"Most researchers would probably agree that there are always constraints in terms of available GPU resources, regardless if their research lab has access to only a few or multiple thousands of GPUs. In a time where at Mapillary we still worked at rather few and mostly 12GB Titan X - style prosumer GPUs, we were searching for a solution that virtually enhances the usable memory during training, so we would be able to obtain and push state-of-the-art results on dense labeling tasks like semantic segmentation. In-place activated BatchNorm is enabling us to use up to 50% more memory (at little computational overhead) and is therefore deeply integrated in all our current projects (including Seamless Scene Segmentation described above).","__index_level_0__":2668}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/inplace_abn.png\" width=\"100%\">\n<\/div>","__index_level_0__":2669}
+{"text":"When processing a BN-Activation-Convolution sequence in the forward pass, most deep learning frameworks (including PyTorch) need to store two big buffers, i.e. the input x of BN and the input z of Conv. This is necessary because the standard implementations of the backward passes of BN and Conv depend on their inputs to calculate the gradients. Using InPlace-ABN to replace the BN-Activation sequence, we can safely discard x, thus saving up to 50% GPU memory at training time. To achieve this, we rewrite the backward pass of BN in terms of its output y, which is in turn reconstructed from z by inverting the activation function.","__index_level_0__":2670}
+{"text":"The only limitation of InPlace-ABN is that it requires using an invertible activation function, such as leaky relu or elu. Except for this, it can be used as a direct, drop-in replacement for BN+activation modules in any network. Our native CUDA implementation offers minimal computational overhead compared to PyTorch\u2019s standard BN, and is available for anyone to use from here: [https:\/\/github.com\/mapillary\/inplace_abn\/](https:\/\/github.com\/mapillary\/inplace_abn\/).","__index_level_0__":2671}
+{"text":"## Synchronized BN with asymmetric graphs and unbalanced batches","__index_level_0__":2672}
+{"text":"When training networks with synchronized SGD over multiple GPUs and\/or multiple nodes, it\u2019s common practice to compute BatchNorm statistics separately on each device. However, in our experience working with semantic and panoptic segmentation networks, we found that accumulating mean and variance across all workers can bring a substantial boost in accuracy. This is particularly true when dealing with small batches, like in Seamless Scene Segmentation where we train with a single, super-high resolution image per GPU.","__index_level_0__":2673}
+{"text":"InPlace-ABN supports synchronized operation over multiple GPUs and multiple nodes, and, since version 1.1, this can also be achieved in the standard PyTorch library using [SyncBatchNorm](https:\/\/pytorch.org\/docs\/stable\/nn.html#syncbatchnorm). Compared to SyncBatchNorm, however, we support some additional functionality which is particularly important for Seamless Scene Segmentation: unbalanced batches and asymmetric graphs.","__index_level_0__":2674}
+{"text":"As mentioned before, Mask R-CNN-like networks naturally give rise to variable-sized tensors. Thus, in InPlace-ABN we calculate synchronized statistics using a variant of the parallel algorithm described [here](https:\/\/en.wikipedia.org\/wiki\/Algorithms_for_calculating_variance#Parallel_algorithm), which properly takes into account the fact that each GPU can hold a different number of samples. PyTorch\u2019s SyncBatchNorm is currently being revised to support this, and the improved functionality will be available in a future release.","__index_level_0__":2675}
+{"text":"Asymmetric graphs (in the sense mentioned above) are another complicating factor one has to deal with when creating a synchronized BatchNorm implementation. Luckily, PyTorch\u2019s distributed group functionality allows us to restrict distributed communication to a subset of workers, easily excluding those that are currently inactive. The only missing piece is that, in order to create a distributed group, each process needs to know the ids of all processes that will participate in the group, and even processes that are not part of the group need to call the `new_group()` function. In InPlace-ABN we handle it with a function like this:","__index_level_0__":2676}
+{"text":"```python\nimport torch\nimport torch.distributed as distributed","__index_level_0__":2677}
+{"text":"def active_group(active):\n    \"\"\"Initialize a distributed group where each process can independently decide whether to participate or not\"\"\"\n    world_size = distributed.get_world_size()\n    rank = distributed.get_rank()","__index_level_0__":2678}
+{"text":"    # Gather active status from all workers\n    active = torch.tensor(rank if active else -1, dtype=torch.long, device=torch.cuda.current_device())\n    active_workers = torch.empty(world_size, dtype=torch.long, device=torch.cuda.current_device())\n    distributed.all_gather(list(active_workers.unbind(0)), active)","__index_level_0__":2679}
+{"text":"    # Create group\n    active_workers = [int(i) for i in active_workers.tolist() if i != -1]\n    group = distributed.new_group(active_workers)\n    return group\n```","__index_level_0__":2680}
+{"text":"First each process, including inactive ones, communicates its status to all others through an `all_gather` call, then it creates the distributed group with the shared information. In the actual implementation we also include a caching mechanism for groups, since `new_group()` is usually too expensive to call at each batch.","__index_level_0__":2681}
+{"text":"## References","__index_level_0__":2682}
+{"text":"[1] Seamless Scene Segmentation; Lorenzo Porzi, Samuel Rota Bul\u00f2, Aleksander Colovic, Peter Kontschieder; Computer Vision and Pattern Recognition (CVPR), 2019","__index_level_0__":2683}
+{"text":"[2] In-place Activated BatchNorm for Memory-Optimized Training of DNNs; Samuel Rota Bul\u00f2, Lorenzo Porzi, Peter Kontschieder; Computer Vision and Pattern Recognition (CVPR), 2018","__index_level_0__":2684}
+{"text":"[3] Panoptic Segmentation; Alexander Kirillov, Kaiming He, Ross Girshick, Carsten Rother, Piotr Dollar; Computer Vision and Pattern Recognition (CVPR), 2019","__index_level_0__":2685}
+{"text":"[4] Mask R-CNN; Kaiming He, Georgia Gkioxari, Piotr Dollar, Ross Girshick; International Conference on Computer Vision (ICCV), 2017","__index_level_0__":2686}
+{"text":"[5] Feature Pyramid Networks for Object Detection; Tsung-Yi Lin, Piotr Dollar, Ross Girshick, Kaiming He, Bharath Hariharan, Serge Belongie; Computer Vision and Pattern Recognition (CVPR), 2017\n \n source: https:\/\/pytorch.org\/blog\/mapillary-research\/ \n category: pytorch blogs","__index_level_0__":2687}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Introduction to Quantization on PyTorch'\nauthor: Raghuraman Krishnamoorthi, James Reed, Min Ni, Chris Gottbrath, and Seth Weidman\n---","__index_level_0__":2688}
+{"text":"It\u2019s important to make efficient use of both server-side and on-device compute resources when developing machine learning applications. To support more efficient deployment on servers and edge devices, PyTorch added a support for model quantization using the familiar eager mode Python API.","__index_level_0__":2689}
+{"text":"Quantization leverages 8bit integer (int8) instructions to reduce the model size and run the inference faster (reduced latency) and can be the difference between a model achieving quality of service goals or even fitting into the resources available on a mobile device. Even when resources aren\u2019t quite so constrained it may enable you to deploy a larger and more accurate model. Quantization is available in PyTorch starting in version 1.3 and with the release of PyTorch 1.4 we published quantized models for ResNet, ResNext, MobileNetV2, GoogleNet, InceptionV3 and ShuffleNetV2 in the PyTorch torchvision 0.5 library.","__index_level_0__":2690}
+{"text":"This blog post provides an overview of the quantization support on PyTorch and its incorporation with the TorchVision domain library.","__index_level_0__":2691}
+{"text":"## **What is Quantization?**","__index_level_0__":2692}
+{"text":"Quantization refers to techniques for doing both computations and memory accesses with lower precision data, usually int8 compared to floating point implementations. This enables performance gains in several important areas:\n* 4x reduction in model size;\n* 2-4x reduction in memory bandwidth;\n* 2-4x faster inference due to savings in memory bandwidth and faster compute with int8 arithmetic (the exact speed up varies depending on the hardware, the runtime, and the model).","__index_level_0__":2693}
+{"text":"Quantization does not however come without additional cost. Fundamentally quantization means introducing approximations and the resulting networks have slightly less accuracy. These techniques attempt to minimize the gap between the full floating point accuracy and the quantized accuracy.","__index_level_0__":2694}
+{"text":"We designed quantization to fit into the PyTorch framework. The means that:\n1. PyTorch has data types corresponding to [quantized tensors](https:\/\/github.com\/pytorch\/pytorch\/wiki\/Introducing-Quantized-Tensor), which share many of the features of tensors.\n2. One can write kernels with quantized tensors, much like kernels for floating point tensors to customize their implementation. PyTorch supports quantized modules for common operations as part of the `torch.nn.quantized` and `torch.nn.quantized.dynamic` name-space.\n3. Quantization is compatible with the rest of PyTorch: quantized models are traceable and scriptable. The quantization method is virtually identical for both server and mobile backends. One can easily mix quantized and floating point operations in a model.\n4. Mapping of floating point tensors to quantized tensors is customizable with user defined observer\/fake-quantization blocks. PyTorch provides default implementations that should work for most use cases.","__index_level_0__":2695}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/torch_stack1.png\" width=\"100%\">\n<\/div>","__index_level_0__":2696}
+{"text":"We developed three techniques for quantizing neural networks in PyTorch as part of quantization tooling in the `torch.quantization` name-space.","__index_level_0__":2697}
+{"text":"## **The Three Modes of Quantization Supported in PyTorch starting version 1.3**","__index_level_0__":2698}
+{"text":"1. ### **Dynamic Quantization**\n   The easiest method of quantization PyTorch supports is called **dynamic quantization**. This involves not just converting the weights to int8 - as happens in all quantization variants - but also converting the activations to int8 on the fly, just before doing the computation (hence \u201cdynamic\u201d). The computations will thus be performed using efficient int8 matrix multiplication and convolution implementations, resulting in faster compute. However, the activations are read and written to memory in floating point format.\n   * **PyTorch API**: we have a simple API for dynamic quantization in PyTorch. `torch.quantization.quantize_dynamic` takes in a model, as well as a couple other arguments, and produces a quantized model! Our [end-to-end tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/dynamic_quantization_bert_tutorial.html) illustrates this for a BERT model; while the tutorial is long and contains sections on loading pre-trained models and other concepts unrelated to quantization, the part the quantizes the BERT model is simply:","__index_level_0__":2699}
+{"text":"   ```python\n   import torch.quantization\n   quantized_model = torch.quantization.quantize_dynamic(model, {torch.nn.Linear}, dtype=torch.qint8)\n   ```\n     * See the documentation for the function [here](https:\/\/pytorch.org\/docs\/stable\/quantization.html#torch.quantization.quantize_dynamic) an end-to-end example in our tutorials [here](https:\/\/pytorch.org\/tutorials\/advanced\/dynamic_quantization_tutorial.html) and [here](https:\/\/pytorch.org\/tutorials\/intermediate\/dynamic_quantization_bert_tutorial.html).","__index_level_0__":2700}
+{"text":"2. ### **Post-Training Static Quantization**","__index_level_0__":2701}
+{"text":"   One can further improve the performance (latency) by converting networks to use both integer arithmetic and int8 memory accesses. Static quantization performs the additional step of first feeding batches of data through the network and computing the resulting distributions of the different activations (specifically, this is done by inserting \u201cobserver\u201d modules at different points that record these distributions). This information is used to determine how specifically the different activations should be quantized at inference time (a simple technique would be to simply divide the entire range of activations into 256 levels, but we support more sophisticated methods as well). Importantly, this additional step allows us to pass quantized values between operations instead of converting these values to floats - and then back to ints - between every operation, resulting in a significant speed-up.","__index_level_0__":2702}
+{"text":"   With this release, we\u2019re supporting several features that allow users to optimize their static quantization:\n   1. Observers: you can customize observer modules which specify how statistics are collected prior to quantization to try out more advanced methods to quantize your data.\n   2. Operator fusion: you can fuse multiple operations into a single operation, saving on memory access while also improving the operation\u2019s numerical accuracy.\n   3. Per-channel quantization: we can independently quantize weights for each output channel in a convolution\/linear layer, which can lead to higher accuracy with almost the same speed.","__index_level_0__":2703}
+{"text":"   * ### **PyTorch API**:\n     * To fuse modules, we have `torch.quantization.fuse_modules`\n     * Observers are inserted using `torch.quantization.prepare`\n     * Finally, quantization itself is done using `torch.quantization.convert`","__index_level_0__":2704}
+{"text":"   We have a tutorial with an end-to-end example of quantization (this same tutorial also covers our third quantization method, quantization-aware training), but because of our simple API, the three lines that perform post-training static quantization on the pre-trained model `myModel` are:\n  ```python\n   # set quantization config for server (x86)\n   deploymentmyModel.qconfig = torch.quantization.get_default_config('fbgemm')","__index_level_0__":2705}
+{"text":"   # insert observers\n   torch.quantization.prepare(myModel, inplace=True)\n   # Calibrate the model and collect statistics","__index_level_0__":2706}
+{"text":"   # convert to quantized version\n   torch.quantization.convert(myModel, inplace=True)\n  ```","__index_level_0__":2707}
+{"text":"3. ### **Quantization Aware Training**\n   **Quantization-aware training(QAT)** is the third method, and the one that typically results in highest accuracy of these three. With QAT, all weights and activations are \u201cfake quantized\u201d during both the forward and backward passes of training: that is, float values are rounded to mimic int8 values, but all computations are still done with floating point numbers. Thus, all the weight adjustments during training are made while \u201caware\u201d of the fact that the model will ultimately be quantized; after quantizing, therefore, this method usually yields higher accuracy than the other two methods.\n* ### **PyTorch API**:\n  * `torch.quantization.prepare_qat` inserts fake quantization modules to model quantization.\n  * Mimicking the static quantization API, `torch.quantization.convert` actually quantizes the model once training is complete.","__index_level_0__":2708}
+{"text":"   For example, in [the end-to-end example](https:\/\/pytorch.org\/tutorials\/advanced\/static_quantization_tutorial.html), we load in a pre-trained model as `qat_model`, then we simply perform quantization-aware training using:","__index_level_0__":2709}
+{"text":"   ```python\n   # specify quantization config for QAT\n   qat_model.qconfig=torch.quantization.get_default_qat_qconfig('fbgemm')","__index_level_0__":2710}
+{"text":"   # prepare QAT\n   torch.quantization.prepare_qat(qat_model, inplace=True)","__index_level_0__":2711}
+{"text":"   # convert to quantized version, removing dropout, to check for accuracy on each\n   epochquantized_model=torch.quantization.convert(qat_model.eval(), inplace=False)\n   ```","__index_level_0__":2712}
+{"text":"### **Device and Operator Support**\nQuantization support is restricted to a subset of available operators, depending on the method being used, for a list of supported operators, please see the documentation at [https:\/\/pytorch.org\/docs\/stable\/quantization.html](https:\/\/pytorch.org\/docs\/stable\/quantization.html).","__index_level_0__":2713}
+{"text":"The set of available operators and the quantization numerics also depend on the backend being used to run quantized models. Currently quantized operators are supported only for CPU inference in the following backends: x86 and ARM. Both the quantization configuration (how tensors should be quantized and the quantized kernels (arithmetic with quantized tensors) are backend dependent. One can specify the backend by doing:","__index_level_0__":2714}
+{"text":"```python\nimport torchbackend='fbgemm'\n# 'fbgemm' for server, 'qnnpack' for mobile\nmy_model.qconfig = torch.quantization.get_default_qconfig(backend)\n# prepare and convert model\n# Set the backend on which the quantized kernels need to be run\ntorch.backends.quantized.engine=backend\n```","__index_level_0__":2715}
+{"text":"However, quantization aware training occurs in full floating point and can run on either GPU or CPU. Quantization aware training is typically only used in CNN models when post training static or dynamic quantization doesn\u2019t yield sufficient accuracy. This can occur with models that are highly optimized to achieve small size (such as Mobilenet).","__index_level_0__":2716}
+{"text":"#### **Integration in torchvision**\nWe\u2019ve also enabled quantization for some of the most popular models in [torchvision](https:\/\/github.com\/pytorch\/vision\/tree\/master\/torchvision\/models\/quantization): Googlenet, Inception, Resnet, ResNeXt, Mobilenet and Shufflenet. We have upstreamed these changes to torchvision in three forms:\n1. Pre-trained quantized weights so that you can use them right away.\n2. Quantization ready model definitions so that you can do post-training quantization or quantization aware training.\n3. A script for doing quantization aware training \u2014 which is available for any of these model though, as you will learn below, we only found it necessary for achieving accuracy with Mobilenet.\n4. We also have a [tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/quantized_transfer_learning_tutorial.html) showing how you can do transfer learning with quantization using one of the torchvision models.","__index_level_0__":2717}
+{"text":"### **Choosing an approach**\nThe choice of which scheme to use depends on multiple factors:\n1. Model\/Target requirements: Some models might be sensitive to quantization, requiring quantization aware training.\n2. Operator\/Backend support: Some backends require fully quantized operators.","__index_level_0__":2718}
+{"text":"Currently, operator coverage is limited and may restrict the choices listed in the table below:\nThe table below provides a guideline.","__index_level_0__":2719}
+{"text":"<style type=\"text\/css\">\n.tg  {border-collapse:collapse;border-spacing:0;border-color:black;}\n.tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}\n.tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}\n.tg .tg-c3ow{border-color:inherit;text-align:center;vertical-align:top}\n.tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top;font-weight:bold;color:black;}\narticle.pytorch-article table tr th:first-of-type, article.pytorch-article table tr td:first-of-type{padding-left:5px}\n<\/style>\n<table class=\"tg\">\n  <tr>\n    <th class=\"tg-0pky\">Model Type<\/th>\n    <th class=\"tg-0pky\">Preferred scheme<\/th>\n    <th class=\"tg-0pky\">Why<\/th>\n  <\/tr>\n  <tr>\n    <td class=\"tg-lboi\">LSTM\/RNN<\/td>\n    <td class=\"tg-lboi\">Dynamic Quantization<\/td>\n    <td class=\"tg-lboi\">Throughput dominated by compute\/memory bandwidth for weights<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-lboi\">BERT\/Transformer<\/td>\n    <td class=\"tg-lboi\">Dynamic Quantization<\/td>\n    <td class=\"tg-lboi\">Throughput dominated by compute\/memory bandwidth for weights<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-lboi\">CNN<\/td>\n    <td class=\"tg-lboi\">Static Quantization<\/td>\n    <td class=\"tg-lboi\">Throughput limited by memory bandwidth for activations<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-lboi\">CNN<\/td>\n    <td class=\"tg-lboi\">Quantization Aware Training<\/td>\n    <td class=\"tg-lboi\">In the case where accuracy can't be achieved with static quantization<\/td>\n  <\/tr>\n<\/table>","__index_level_0__":2720}
+{"text":"### **Performance Results**\nQuantization provides a 4x reduction in the model size and a speedup of 2x to 3x compared to floating point implementations depending on the hardware platform and the model being benchmarked. Some sample results are:","__index_level_0__":2721}
+{"text":"<div class=\"table-responsive\">\n  <table class=\"tg\">\n    <tr>\n      <td class=\"tg-0pky\">Model<\/td>\n      <td class=\"tg-0pky\">Float Latency (ms)<\/td>\n      <td class=\"tg-0pky\">Quantized Latency (ms)<\/td>\n      <td class=\"tg-0pky\">Inference Performance Gain<\/td>\n      <td class=\"tg-0pky\">Device<\/td>\n      <td class=\"tg-0pky\">Notes<\/td>\n    <\/tr>\n    <tr>\n      <td class=\"tg-lboi\">BERT<\/td>\n      <td class=\"tg-lboi\">581<\/td>\n      <td class=\"tg-lboi\">313<\/td>\n      <td class=\"tg-lboi\">1.8x<\/td>\n      <td class=\"tg-lboi\">Xeon-D2191 (1.6GHz)<\/td>\n      <td class=\"tg-lboi\">Batch size = 1, Maximum sequence length= 128, Single thread, x86-64, Dynamic quantization<\/td>\n    <\/tr>\n    <tr>\n      <td class=\"tg-lboi\">Resnet-50<\/td>\n      <td class=\"tg-lboi\">214<\/td>\n      <td class=\"tg-lboi\">103<\/td>\n      <td class=\"tg-lboi\">2x<\/td>\n      <td class=\"tg-lboi\">Xeon-D2191 (1.6GHz)<\/td>\n      <td class=\"tg-lboi\">Single thread, x86-64, Static quantization<\/td>\n    <\/tr>\n    <tr>\n      <td class=\"tg-lboi\">Mobilenet-v2<\/td>\n      <td class=\"tg-lboi\">97<\/td>\n      <td class=\"tg-lboi\">17<\/td>\n      <td class=\"tg-lboi\">5.7x<\/td>\n      <td class=\"tg-lboi\">Samsung S9<\/td>\n      <td class=\"tg-lboi\">Static quantization, Floating point numbers are based on Caffe2 run-time and are not optimized<\/td>\n    <\/tr>\n  <\/table>\n<\/div>","__index_level_0__":2722}
+{"text":"### **Accuracy results**\nWe also compared the accuracy of static quantized models with the floating point models on Imagenet. For dynamic quantization, we [compared](https:\/\/github.com\/huggingface\/transformers\/blob\/master\/examples\/run_glue.py) the F1 score of BERT on the GLUE benchmark for MRPC.","__index_level_0__":2723}
+{"text":"#### **Computer Vision Model accuracy**","__index_level_0__":2724}
+{"text":"<table class=\"tg\">\n  <tr>\n    <td class=\"tg-0pky\">Model<\/td>\n    <td class=\"tg-0pky\">Top-1 Accuracy (Float)<\/td>\n    <td class=\"tg-0pky\">Top-1 Accuracy (Quantized)<\/td>\n    <td class=\"tg-0pky\">Quantization scheme<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-cly1\">Googlenet<\/td>\n    <td class=\"tg-cly1\">69.8<\/td>\n    <td class=\"tg-cly1\">69.7<\/td>\n    <td class=\"tg-cly1\">Static post training quantization<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-cly1\">Inception-v3<\/td>\n    <td class=\"tg-cly1\">77.5<\/td>\n    <td class=\"tg-cly1\">77.1<\/td>\n    <td class=\"tg-cly1\">Static post training quantization<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-0lax\">ResNet-18<\/td>\n    <td class=\"tg-0lax\">69.8<\/td>\n    <td class=\"tg-0lax\">69.4<\/td>\n    <td class=\"tg-0lax\">Static post training quantization<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-0lax\">Resnet-50<\/td>\n    <td class=\"tg-0lax\">76.1<\/td>\n    <td class=\"tg-0lax\">75.9<\/td>\n    <td class=\"tg-0lax\">Static post training quantization<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-0lax\">ResNext-101 32x8d<\/td>\n    <td class=\"tg-0lax\">79.3<\/td>\n    <td class=\"tg-0lax\">79<\/td>\n    <td class=\"tg-0lax\">Static post training quantization<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-0lax\">Mobilenet-v2<\/td>\n    <td class=\"tg-0lax\">71.9<\/td>\n    <td class=\"tg-0lax\">71.6<\/td>\n    <td class=\"tg-0lax\">Quantization Aware Training<\/td>\n  <\/tr>\n  <tr>\n    <td class=\"tg-0lax\">Shufflenet-v2<\/td>\n    <td class=\"tg-0lax\">69.4<\/td>\n    <td class=\"tg-0lax\">68.4<\/td>\n    <td class=\"tg-0lax\">Static post training quantization<\/td>\n  <\/tr>\n<\/table>","__index_level_0__":2725}
+{"text":"#### **Speech and NLP Model accuracy**","__index_level_0__":2726}
+{"text":"<div class=\"table-responsive\">\n  <table class=\"tg\">\n    <tr>\n      <td class=\"tg-0pky\">Model<\/td>\n      <td class=\"tg-0pky\">F1 (GLUEMRPC) Float<\/td>\n      <td class=\"tg-0pky\">F1 (GLUEMRPC) Quantized<\/td>\n      <td class=\"tg-0pky\">Quantization scheme<\/td>\n    <\/tr>\n    <tr>\n      <td class=\"tg-cly1\">BERT<\/td>\n      <td class=\"tg-cly1\">0.902<\/td>\n      <td class=\"tg-cly1\">0.895<\/td>\n      <td class=\"tg-cly1\">Dynamic quantization<\/td>\n    <\/tr>\n  <\/table>\n<\/div>","__index_level_0__":2727}
+{"text":"### **Conclusion**\nTo get started on quantizing your models in PyTorch, start with [the tutorials on the PyTorch website](https:\/\/pytorch.org\/tutorials\/#model-optimization). If you are working with sequence data start with [dynamic quantization for LSTM](https:\/\/pytorch.org\/tutorials\/advanced\/dynamic_quantization_tutorial.html), or [BERT](https:\/\/pytorch.org\/tutorials\/intermediate\/dynamic_quantization_bert_tutorial.html). If you are working with image data then we recommend starting with the [transfer learning with quantization](https:\/\/pytorch.org\/tutorials\/intermediate\/quantized_transfer_learning_tutorial.html) tutorial. Then you can explore [static post training quantization](https:\/\/pytorch.org\/tutorials\/advanced\/static_quantization_tutorial.html). If you find that the accuracy drop with post training quantization is too high, then try [quantization aware training](https:\/\/pytorch.org\/tutorials\/advanced\/static_quantization_tutorial.html).","__index_level_0__":2728}
+{"text":"If you run into issues you can get community help by posting in at [discuss.pytorch.org](https:\/\/discuss.pytorch.org\/), use the quantization category for quantization related issues.","__index_level_0__":2729}
+{"text":"_This post is authored by Raghuraman Krishnamoorthi, James Reed, Min Ni, Chris Gottbrath and Seth Weidman. Special thanks to Jianyu Huang, Lingyi Liu and Haixin Liu for producing quantization metrics included in this post._","__index_level_0__":2730}
+{"text":"### **Further reading**:\n1. PyTorch quantization presentation at Neurips: [(https:\/\/research.fb.com\/wp-content\/uploads\/2019\/12\/2.-Quantization.pptx)](https:\/\/research.fb.com\/wp-content\/uploads\/2019\/12\/2.-Quantization.pptx)\n2. Quantized Tensors [(https:\/\/github.com\/pytorch\/pytorch\/wiki\/\nIntroducing-Quantized-Tensor)](https:\/\/github.com\/pytorch\/pytorch\/wiki\/Introducing-Quantized-Tensor)\n3. Quantization RFC on Github [(https:\/\/github.com\/pytorch\/pytorch\/\nissues\/18318)](https:\/\/github.com\/pytorch\/pytorch\/issues\/18318)\n \n source: https:\/\/pytorch.org\/blog\/introduction-to-quantization-on-pytorch\/ \n category: pytorch blogs","__index_level_0__":2731}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Scaling PyTorch FSDP for Training Foundation Models on IBM Cloud\"\nauthor:  Linsong Chu, Less Wright, Hamid Shojanazeri, Sophia Wen, Raghu Ganti, Geeta Chauhan\nfeatured-img: \"\/assets\/images\/scaling-pytorch-fsdp-image1-IBM_scaling_FSDP_visual_new.png\"\n---","__index_level_0__":2732}
+{"text":"Large model training using a cloud native approach is of growing interest for many enterprises given the emergence and success of [foundation models](https:\/\/research.ibm.com\/blog\/what-are-foundation-models). Some AI practitioners may assume that the only way they can achieve high GPU utilization for distributed training jobs is to run them on HPC systems, such as those inter-connected with Infiniband and may not consider Ethernet connected systems. We demonstrate how the latest distributed training technique, Fully Sharded Data Parallel (FSDP) from PyTorch, successfully scales to models of size 10B+ parameters using commodity Ethernet networking in IBM Cloud.","__index_level_0__":2733}
+{"text":"## PyTorch FSDP Scaling","__index_level_0__":2734}
+{"text":"As models get larger, the standard techniques for data parallel training work only if the GPU can hold a full replica of the model, along with its training state (optimizer, activations, etc.). However, GPU memory increases have not kept up with the model size increases and new techniques for training such models have emerged (e.g., Fully Sharded Data Parallel, [DeepSpeed](https:\/\/www.deepspeed.ai\/)), which allow us to efficiently distribute the model and data over multiple GPUs during training. In this blog post, we demonstrate a path to achieve remarkable scaling of model training to 64 nodes (512 GPUs) using PyTorch native FSDP APIs as we increase model sizes to 11B.","__index_level_0__":2735}
+{"text":"### What is Fully Sharded Data Parallel?","__index_level_0__":2736}
+{"text":"FSDP extends the distributed data parallel training (DDP) approach by sharding model parameters, gradient and optimizer states into K FSDP units, determined by using a wrapping policy. FSDP achieves large model training efficiency in terms of resources and performance by significantly reducing the memory footprint on each GPU and overlapping computation and communication.","__index_level_0__":2737}
+{"text":"Resource efficiency is achieved with memory footprint reduction by having all GPUs own a portion of each FSDP unit. To process a given FSDP unit, all GPUs share their locally owned portion via all_gather communication calls.","__index_level_0__":2738}
+{"text":"Performance efficiency is accomplished by overlapping all_gather communication calls for upcoming FSDP units with computation of the current FSDP unit. Once the current FSDP unit has been processed, the non-locally owned parameters are dropped, freeing memory for the upcoming FSDP units.  This process achieves training efficiency by the overlap of computation and communication, while also reducing the peak memory needed by each GPU.","__index_level_0__":2739}
+{"text":"In what follows, we demonstrate how FSDP allows us to keep hundreds of GPUs highly utilized throughout a distributed training job, while running over standard Ethernet networking (system description towards the end of the blog). We chose the T5 architecture for our experiments and leveraged the code from the [FSDP workshop](https:\/\/github.com\/pytorch\/workshops\/tree\/master\/FSDP_Workshop). In each of our experiments, we start with a single node experiment to create a baseline and report the metric seconds\/iteration normalized by the batch size as well as compute the teraflops based on the [Megatron-LM paper](https:\/\/cs.stanford.edu\/~matei\/papers\/2021\/sc_megatron_lm.pdf) (see Appendix for details of teraflop computation for T5). Our experiments aim to maximize the batch size (while avoiding cudaMalloc retries) to take full advantage of overlap in computation and communications, as discussed below. Scaling is defined as the ratio of the seconds\/iteration normalized by batch size for N nodes versus a single node, representing how well we can utilize the additional GPUs as more nodes are added.","__index_level_0__":2740}
+{"text":"### Experimental Results","__index_level_0__":2741}
+{"text":"Our first set of experiments using the T5-3B configuration (mixed precision with BF16, activation checkpointing, and transformer wrapping policy) demonstrated scaling efficiency of 95% as we increased the number of GPUs from 8 to 512 (1 to 64 nodes, respectively). We achieved these results without any modifications to the existing FSDP APIs. We observed that, for this scale, over Ethernet based network, there is sufficient bandwidth to enable continuous overlap of communication and computation.","__index_level_0__":2742}
+{"text":"However, when we increased the T5 model size to 11B, the scaling efficiency declined substantially to 20%. The PyTorch profiler shows that overlap of communication and computation was very limited. Further investigation into the network bandwidth usage revealed that the poor overlap is being caused by latency in the communication of individual packets and not the bandwidth required (in fact, our peak bandwidth utilization is 1\/4th of that available). This led us to hypothesize that if we can increase the compute time by increasing the batch size, we can better overlap communication and computation. However, given we are already at maximum GPU memory allocation, we must identify opportunities to rebalance the memory allocation to allow for increase in batch size. We identified that the model state was being allocated a lot more memory than was needed. The primary function of these reservations is to have pre-reserved memory ready to aggressively send\/receive tensors during the communication periods and too few buffers can result in increased wait times, whereas too many buffers result in smaller batch sizes.","__index_level_0__":2743}
+{"text":"To achieve better efficiency, the PyTorch distributed team introduced a new control knob, the rate_limiter which controls how much memory is allocated for send\/receive of tensors, alleviating the memory pressure and providing room for higher batch sizes.  In our case, the rate_limiter could increase the batch size from 20 to 50, thus increasing compute time by 2.5x and allowing for much greater overlap of communication and computation. With this fix, we increased the scaling efficiency to >75% (at 32 nodes)!","__index_level_0__":2744}
+{"text":"Continued investigation into the factors limiting scaling efficiency uncovered that the rate limiter was creating a recurring pipeline bubble of GPU idle time. This was due to the rate limiter using a block and flush approach for the allocation and release of each set of memory buffers. By waiting for the entire block to complete before initiating a new all_gather, the GPU was idling at the start of each block, while waiting for the new set of all_gather parameters to arrive. This bubble was alleviated by moving to a sliding window approach. Upon the completion of a single all_gather step and its computation (rather than a block of them), the memory is freed and the next all_gather is immediately issued in a much more uniform manner.  This improvement eliminated the pipeline bubble and boosted the scaling efficiencies to >90% (at 32 nodes).","__index_level_0__":2745}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/scaling-pytorch-fsdp-image1-IBM_scaling_FSDP_visual_new.png\" width=\"100%\">\n<\/p>","__index_level_0__":2746}
+{"text":"<p align=\"center\">\nFigure 1: Scaling of T5-XL (3B) and T5-XXL (11B) from 1 node to 64 nodes\n<\/p>","__index_level_0__":2747}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/scaling-pytorch-fsdp-image2-tflops_per_second_new.png\" width=\"100%\">\n<\/p>","__index_level_0__":2748}
+{"text":"<p align=\"center\">\nFigure 2: TFLOPs\/sec usage for T5-XL(3B) and T5-XXL (11B) as we increase number of nodes\n<\/p>","__index_level_0__":2749}
+{"text":"## IBM Cloud AI System and Middleware","__index_level_0__":2750}
+{"text":"The AI infrastructure used for this work is a large-scale AI system on IBM Cloud consisting of nearly 200 nodes, each node with 8 NVIDIA A100 80GB cards, 96 vCPUs, and 1.2TB CPU RAM. The GPU cards within a node are connected via NVLink with a card-to-card bandwidth of 600GBps. Nodes are connected by 2 x 100Gbps Ethernet links with SRIOV based TCP\/IP stack, providing a usable bandwidth of 120Gbps.","__index_level_0__":2751}
+{"text":"The IBM Cloud AI System has been production-ready since May of 2022 and is configured with the OpenShift container platform to run AI workloads. We also built a software stack for production AI workloads that provide end-to-end tools for training workloads. The middleware leverages Ray for pre and post processing workloads and PyTorch for training of models. We also integrate a Kubernetes native scheduler, MCAD, that manages multiple jobs with job queuing, gang scheduling, prioritization, and quota management. A multi-NIC CNI discovers all available network interfaces and handles them as a single NIC pool enabling optimized use of the network interfaces in Kubernetes. Finally, CodeFlare CLI supports a single pane for observability of the full stack using a desktop CLI (e.g., GPU utilization, application metrics like loss, gradient norm).","__index_level_0__":2752}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/scaling-pytorch-fsdp-image3-cli-and-dashboard.png\" width=\"100%\">\n<\/p>","__index_level_0__":2753}
+{"text":"<p align=\"center\">\nFigure 3: Foundation Model Middleware Stack\n<\/p>","__index_level_0__":2754}
+{"text":"### Conclusion and Future Work","__index_level_0__":2755}
+{"text":"In conclusion, we demonstrated how we can achieve remarkable scaling of FSDP APIs over non-InfiniBand networks. We identified the bottleneck that had limited scaling to less than 20% efficiency for 11B parameter model training.  After identifying the issue, we were able to correct this with a new rate limiter control to ensure a more optimal balance of reserved memory and communication overlap relative to compute time. With this improvement, we were able to achieve 90% scaling efficiency (a 4.5x improvement), at 256 GPUs and 80% at 512 GPUs for training of the 11B parameter model. In addition, the 3B parameter model scales extremely well with 95% efficiency even as we increase the number of GPUs to 512.","__index_level_0__":2756}
+{"text":"This is a first in the industry to achieve such scaling efficiencies for up to 11B parameter models using Kubernetes with vanilla Ethernet and PyTorch native FSDP API\u2019s. This improvement enables users to train huge models on a Hybrid Cloud platform in a cost efficient and sustainable manner.","__index_level_0__":2757}
+{"text":"We plan on continuing to investigate scaling with decoder only models and increasing the size of these models to 100B+ parameters. From a system design perspective, we are exploring capabilities such as RoCE and GDR that can improve latencies of communications over Ethernet networks.","__index_level_0__":2758}
+{"text":"## Acknowledgements","__index_level_0__":2759}
+{"text":"This blog was possible because of contributions from both PyTorch Distributed and IBM Research teams.","__index_level_0__":2760}
+{"text":"From the PyTorch Distributed team, we would like to thank Less Wright, Hamid Shojanazeri, Geeta Chauhan, Shen Li, Rohan Varma, Yanli Zhao, Andrew Gu, Anjali Sridhar, Chien-Chin Huang, and Bernard Nguyen.","__index_level_0__":2761}
+{"text":"From the IBM Research team, we would like to thank Linsong Chu, Sophia Wen, Lixiang (Eric) Luo, Marquita Ellis, Davis Wertheimer, Supriyo Chakraborty, Raghu Ganti, Mudhakar Srivatsa, Seetharami Seelam, Carlos Costa, Abhishek Malvankar, Diana Arroyo, Alaa Youssef, Nick Mitchell.","__index_level_0__":2762}
+{"text":"## Appendix","__index_level_0__":2763}
+{"text":"#### Teraflop computation","__index_level_0__":2764}
+{"text":"The T5-XXL (11B) architecture has two types of T5 blocks, one is an encoder and the second is a decoder. Following the approach of Megatron-LM, where each matrix multiplication requires 2m\u00d7k\u00d7n FLOPs, where the first matrix is of size m\u00d7k and the second is k\u00d7n. The encoder block consists of self-attention and feed forward layers, whereas the decoder block consists of self-attention, cross-attention, and feed forward layers.","__index_level_0__":2765}
+{"text":"The attention (both self and cross) block consists of a QKV projection, which requires 6Bsh<sup>2<\/sup> operations, an attention matrix computation requiring 2Bs<sup>2<\/sup>h operations, an attention over values which needs 2Bs<sup>2<\/sup>h computations, and the post-attention linear projection requires 2Bsh<sup>2<\/sup> operations. Finally, the feed forward layer requires 15Bsh<sup>2<\/sup> operations. ","__index_level_0__":2766}
+{"text":"The total for an encoder block is 23Bsh<sup>2<\/sup>+4Bs<sup>2<\/sup>h, whereas for a decoder block, it comes to 31Bsh<sup>2<\/sup>+8Bs<sup>2<\/sup>h. With a total of 24 encoder and 24 decoder blocks and 2 forward passes (as we discard the activations) and one backward pass (equivalent to two forward passes), the final FLOPs computation comes to be 96\u00d7(54Bsh<sup>2<\/sup>+ 12Bs<sup>2<\/sup>h) + 6BshV. Here, B is the batch size per GPU, s is sequence length, h is hidden state size, and V is vocabulary size. \nWe repeat a similar computation for T5-XL (3B) architecture, which is slightly different. \n source: https:\/\/pytorch.org\/blog\/scaling-pytorch-fsdp-for-training-foundation-models-on-ibm-cloud\/ \n category: pytorch blogs","__index_level_0__":2767}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Empowering PyTorch on Intel\u00ae Xeon\u00ae Scalable processors with Bfloat16\"\nauthor: Mingfei Ma (Intel), Vitaly Fedyunin (Meta), Wei Wei (Meta)\nfeatured-img: '\\assets\\images\\empowering-pytorch-on-intel-xeon-scalable-processors-with-bfloat16.png'\n---","__index_level_0__":2768}
+{"text":"## Overview","__index_level_0__":2769}
+{"text":"Recent years, the growing complexity of AI models have been posing requirements on hardware for more and more compute capability. Reduced precision numeric format has been proposed to address this problem. Bfloat16 is a custom 16-bit floating point format for AI which consists of one sign bit, eight exponent bits, and seven mantissa bits. With the same dynamic range as float32, bfloat16 doesn\u2019t require a special handling such as loss scaling. Therefore, bfloat16 is a drop-in replacement for float32 when running deep neural networks for both inference and training.","__index_level_0__":2770}
+{"text":"The 3rd Gen Intel<sup>\u00ae<\/sup> Xeon<sup>\u00ae<\/sup> Scalable processor (codenamed Cooper Lake), is the first general purpose x86 CPU with native bfloat16 support. Three new bfloat16 instructions were introduced in Intel<sup>\u00ae<\/sup> Advanced Vector Extensions-512 (Intel<sup>\u00ae<\/sup> AVX-512): VCVTNE2PS2BF16, VCVTNEPS2BF16, and VDPBF16PS. The first two instructions perform conversion from float32 to bfloat16, and the last one performs a dot product of bfloat16 pairs. Bfloat16 theoretical compute throughput is doubled over float32 on Cooper Lake. On the next generation of Intel<sup>\u00ae<\/sup> Xeon<sup>\u00ae<\/sup> Scalable Processors, bfloat16 compute throughput will be further enhanced through Advanced Matrix Extensions (Intel<sup>\u00ae<\/sup> AMX) instruction set extension.","__index_level_0__":2771}
+{"text":"Intel and Meta previously collaborated to enable bfloat16 on PyTorch, and the related work was published in an earlier [blog](https:\/\/community.intel.com\/t5\/Blogs\/Tech-Innovation\/Artificial-Intelligence-AI\/Intel-and-Facebook-Accelerate-PyTorch-Performance-with-3rd-Gen\/post\/1335659) during launch of Cooper Lake. In that blog, we introduced the hardware advancement for native bfloat16 support and showcased a performance boost of 1.4x to 1.6x of bfloat16 over float32 from DLRM, ResNet-50 and ResNext-101-32x4d.","__index_level_0__":2772}
+{"text":"In this blog, we will introduce the latest software enhancement on bfloat16 in PyTorch 1.12, which would apply to much broader scope of user scenarios and showcase even higher performance boost.","__index_level_0__":2773}
+{"text":"## Native Level Optimization on Bfloat16","__index_level_0__":2774}
+{"text":"On PyTorch CPU bfloat16 path, the compute intensive operators, e.g., convolution, linear and bmm, use oneDNN (oneAPI Deep Neural Network Library) to achieve optimal performance on Intel CPUs with AVX512_BF16 or AMX support. The other operators,  such as tensor operators and neural network operators, are optimized at PyTorch native level. We have enlarged bfloat16 kernel level optimizations to majority of operators on dense tensors, both inference and training applicable (sparse tensor bfloat16 support will be covered in future work), specifically:","__index_level_0__":2775}
+{"text":"- **Bfloat16 vectorization**: Bfloat16 is stored as unsigned 16-bit integer, which requires it to be casted to float32 for arithmetic operations such as add, mul, etc. Specifically, each bfloat16 vector will be converted to two float32 vectors, processed accordingly and then converted back. While for non-arithmetic operations such as cat, copy, etc., it is a straight memory copy and no data type conversion will be involved.\n- **Bfloat16 reduction**: Reduction on bfloat16 data uses float32 as accumulation type to guarantee numerical stability, e.g., sum, BatchNorm2d, MaxPool2d, etc.\n- **Channels Last optimization**: For vision models, Channels Last is the preferable memory format over Channels First from performance perspective. We have implemented fully optimized CPU kernels for all the commonly used CV modules on channels last memory format, taking care of both float32 and bfloat16.","__index_level_0__":2776}
+{"text":"## Run Bfloat16 with Auto Mixed Precision","__index_level_0__":2777}
+{"text":"To run model on bfloat16, typically user can either explicitly convert the data and model to bfloat16, for example:","__index_level_0__":2778}
+{"text":"```console\n# with explicit conversion\ninput = input.to(dtype=torch.bfloat16)\nmodel = model.to(dtype=torch.bfloat16)\n```","__index_level_0__":2779}
+{"text":"or utilize torch.amp (Automatic Mixed Precision) package. The autocast instance serves as context managers or decorators that allow regions of your script to run in mixed precision, for example:","__index_level_0__":2780}
+{"text":"```console\n# with AMP\nwith torch.autocast(device_type=\"cpu\", dtype=torch.bfloat16):\n    output = model(input)\n```","__index_level_0__":2781}
+{"text":"Generally, the explicit conversion approach and AMP approach have similar performance. Even though, we recommend run bfloat16 models with AMP, because:","__index_level_0__":2782}
+{"text":"- **Better user experience with automatic fallback**: If your script includes operators that don\u2019t have bfloat16 support, autocast will implicitly convert them back to float32 while the explicit converted model will give a runtime error.","__index_level_0__":2783}
+{"text":"- **Mixed data type for activation and parameters**: Unlike the explicit conversion which converts all the model parameters to bfloat16, AMP mode will run in mixed data type. To be specific, input\/output will be kept in bfloat16 while parameters, e.g., weight\/bias, will be kept in float32. The mixed data type of activation and parameters will help improve performance while maintaining the accuracy.","__index_level_0__":2784}
+{"text":"## Performance Gains","__index_level_0__":2785}
+{"text":"We benchmarked inference performance of TorchVision models on Intel\u00ae Xeon\u00ae Platinum 8380H CPU @ 2.90GHz (codenamed Cooper Lake), single instance per socket (batch size = 2 x number of physical cores). Results show that bfloat16 has 1.4x to 2.2x performance gain over float32.","__index_level_0__":2786}
+{"text":"<p align=\"center\">\n  <img src=\"\\assets\\images\\empowering-pytorch-on-intel-xeon-scalable-processors-with-bfloat16.png\" width=\"100%\">\n<\/p>","__index_level_0__":2787}
+{"text":"## The performance boost of bfloat16 over float32 primarily comes from 3 aspects:","__index_level_0__":2788}
+{"text":"- The compute intensive operators take advantage of the new bfloat16 native instruction VDPBF16PS which doubles the hardware compute throughput.\n- Bfloat16 have only half the memory footprint of float32, so theoretically the memory bandwidth intensive operators will be twice faster.\n- On Channels Last, we intentionally keep the same parallelization scheme for all the memory format aware operators (can\u2019t do this on Channels First though), which increases the data locality when passing each layer\u2019s output to the next. Basically, it keeps the data closer to CPU cores while data would reside in cache anyway.  And bfloat16 will have a higher cache hit rate compared with float32 in such scenarios due to smaller memory footprint.","__index_level_0__":2789}
+{"text":"## Conclusion & Future Work","__index_level_0__":2790}
+{"text":"In this blog, we introduced recent software optimizations on bfloat16 introduced in PyTorch 1.12. Results on the 3rd Gen Intel<sup>\u00ae<\/sup> Xeon<sup>\u00ae<\/sup> Scalable processor show that bfloat16 has 1.4x to 2.2x performance gain over float32 on the TorchVision models. Further improvement is expected on the next generation of Intel<sup>\u00ae<\/sup> Xeon<sup>\u00ae<\/sup> Scalable Processors with AMX instruction support. Though the performance number for this blog is collected with TorchVision models, the benefit is broad across all topologies. And we will continue to extend the bfloat16 optimization effort to a broader scope in the future!","__index_level_0__":2791}
+{"text":"## Acknowledgement","__index_level_0__":2792}
+{"text":"The results presented in this blog is a joint effort of Meta and Intel PyTorch team. Special thanks to Vitaly Fedyunin and Wei Wei from Meta who spent precious time and gave substantial assistance! Together we made one more step on the path of improving the PyTorch CPU eco system.","__index_level_0__":2793}
+{"text":"## Reference","__index_level_0__":2794}
+{"text":"- [The bfloat16 numerical format](https:\/\/cloud.google.com\/tpu\/docs\/bfloat16?hl=en)\n- [https:\/\/pytorch.org\/docs\/master\/amp.html#torch.autocast](https:\/\/pytorch.org\/docs\/master\/amp.html#torch.autocast)\n- [Intel and Facebook Accelerate PyTorch Performance with 3rd Gen Intel\u00ae Xeon\u00ae Processors and Intel\u00ae Deep Learning Boost\u2019s new BFloat16 capability](https:\/\/community.intel.com\/t5\/Blogs\/Tech-Innovation\/Artificial-Intelligence-AI\/Intel-and-Facebook-Accelerate-PyTorch-Performance-with-3rd-Gen\/post\/1335659) \n source: https:\/\/pytorch.org\/blog\/empowering-pytorch-on-intel-xeon-scalable-processors-with-bfloat16\/ \n category: pytorch blogs","__index_level_0__":2795}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Announcing PyTorch Conference 2022\"\nauthor:\nfeatured-img: \"\/assets\/images\/pytorch-conference-2022.png\"\n---","__index_level_0__":2796}
+{"text":"We are excited to announce that the PyTorch Conference returns in-person as a satellite event to [NeurlPS](https:\/\/l.workplace.com\/l.php?u=https%3A%2F%2Fnips.cc%2F&h=AT3cdRwSEhyuNXpH2ptWjk-KxMxcceaYeTfflT6PEezDQ_zeUxRv1gjX7GhTQBgvZxFAR0wlSBwuhpipdMjUknMnhY5oJ5C4HjLNO40-12UnoeYALriwrvdxGfgigo8KYlWu_gRIQwlO-2r0wTnNft0whoSaOdVAxw&__tn__=-UK-R&c[0]=AT3z6QRLu8Uw48lKQ_P6FFq7ncHfjsfI16OGZvWO9kALatCY4sZcMjNzR7a4OiOG25RKVHpDX0TGutZHyM_R8Kl2s71Y3DEbq5QccmUVaSzCbcMUSc5Ms2zXHoeGxUlw1XirihAydPsX4Y1OmF6GRjqH8YFTNTFQRN3I8j2SFhR8LEUDxDmfnZ8Q7c2hXi0HeGc) (Neural Information Processing Systems) in New Orleans on Dec. 2nd.","__index_level_0__":2797}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/pytorch-conference-2022.png\" width=\"100%\">\n<\/p>","__index_level_0__":2798}
+{"text":"We changed the name from PyTorch Developer Day to PyTorch Conference to signify the turning of a new chapter as we look to the future of PyTorch, encompassing the entire PyTorch Community. This conference will bring together leading researchers, academics and developers from the Machine Learning (ML) and Deep Learning (DL) communities to join a multiple set of talks and a poster session; covering new software releases on [PyTorch](https:\/\/pytorch.org\/), use cases in academia and industry, as well as ML\/DL development and production trends.","__index_level_0__":2799}
+{"text":"### EVENT OVERVIEW","__index_level_0__":2800}
+{"text":"When: Dec 2nd, 2022 (In-Person and Virtual)","__index_level_0__":2801}
+{"text":"Where: New Orleans, Louisiana (USA) &#124; *Virtual option as well*","__index_level_0__":2802}
+{"text":"### SCHEDULE","__index_level_0__":2803}
+{"text":"<em><sub>All times in Central Standard.<\/sub><\/em>","__index_level_0__":2804}
+{"text":"8:00-9:00 am  &emsp; Registration\/Check in","__index_level_0__":2805}
+{"text":"9:00-11:20 am &ensp; Keynote & Technical Talks","__index_level_0__":2806}
+{"text":"11:30-1:00 pm &ensp; Lunch","__index_level_0__":2807}
+{"text":"1:00-3:00 pm &emsp; Poster Session & Breakouts","__index_level_0__":2808}
+{"text":"3:00-4:00 pm &emsp; Community\/Partner Talks","__index_level_0__":2809}
+{"text":"4:00-5:00 pm &emsp; Panel Discussion","__index_level_0__":2810}
+{"text":"<em><sup>Agenda subject to change.<\/sup><\/em>","__index_level_0__":2811}
+{"text":"All talks will be livestreamed and available to the public. The in-person event will be by invitation only as space is limited. If you\u2019d like to apply to attend in person, please submit all requests [here](https:\/\/pytorchconference22.splashthat.com\/).","__index_level_0__":2812}
+{"text":"- [Submit Content for Consideration by Sept. 30th](https:\/\/docs.google.com\/forms\/d\/121ptOuhqhmcPev9g5Zt2Ffl-NtB_oeyFk5CWjumUVLQ\/edit)\n- [Livestream event page](https:\/\/www.facebook.com\/events\/1562940847455759)\n- [Apply for an invitation to the in-person event](https:\/\/pytorchconference22.splashthat.com\/) \n source: https:\/\/pytorch.org\/blog\/announcing-pytorch-conference-2022\/ \n category: pytorch blogs","__index_level_0__":2814}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'New PyTorch library releases including TorchVision Mobile, TorchAudio I\/O, and more'\nauthor: Team PyTorch \n---","__index_level_0__":2815}
+{"text":"Today, we are announcing updates to a number of PyTorch libraries, alongside the [PyTorch 1.8 release](https:\/\/pytorch.org\/blog\/pytorch-1.8-released). The updates include new releases for the domain libraries including TorchVision, TorchText and TorchAudio as well as new version of TorchCSPRNG. These releases include a number of new features and improvements and, along with the PyTorch 1.8 release, provide a broad set of updates for the PyTorch community to build on and leverage. ","__index_level_0__":2816}
+{"text":"Some highlights include:\n* **TorchVision** - Added support for PyTorch Mobile including [Detectron2Go](https:\/\/ai.facebook.com\/blog\/d2go-brings-detectron2-to-mobile) (D2Go), auto-augmentation of data during training, on the fly type conversion, and [AMP autocasting](https:\/\/pytorch.org\/docs\/stable\/amp.html).  \n* **TorchAudio** - Major improvements to I\/O, including defaulting to sox_io backend and file-like object support. Added Kaldi Pitch feature and support for CMake based build allowing TorchAudio to better support no-Python environments.\n* **TorchText** - Updated the dataset loading API to be compatible with standard PyTorch data loading utilities.\n* **TorchCSPRNG** - Support for cryptographically secure pseudorandom number generators for PyTorch is now stable with new APIs for AES128 ECB\/CTR and CUDA support on Windows.","__index_level_0__":2817}
+{"text":"Please note that, starting in PyTorch 1.6, features are classified as Stable, Beta, and Prototype. Prototype features are not included as part of the binary distribution and are instead available through either building from source, using nightlies or via compiler flag. You can see the detailed announcement [here](https:\/\/pytorch.org\/blog\/pytorch-feature-classification-changes\/).","__index_level_0__":2818}
+{"text":"\n# TorchVision 0.9.0\n### [Stable] TorchVision Mobile: Operators, Android Binaries, and Tutorial\nWe are excited to announce the first on-device support and binaries for a PyTorch domain library. We have seen significant appetite in both research and industry for on-device vision support to allow low latency, privacy friendly, and resource efficient mobile vision experiences. You can follow this [new tutorial](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/D2Go) to build your own Android object detection app using TorchVision operators, D2Go, or your own custom operators and model.","__index_level_0__":2819}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/tochvisionmobile.png\" width=\"30%\">\n<\/div>","__index_level_0__":2820}
+{"text":"### [Stable] New Mobile models for Classification, Object Detection and Semantic Segmentation\nWe have added support for the MobileNetV3 architecture and provided pre-trained weights for Classification, Object Detection and Segmentation. It is easy to get up and running with these models, just import and load them as you would any ```torchvision``` model:\n```python\nimport torch\nimport torchvision","__index_level_0__":2821}
+{"text":"# Classification\nx = torch.rand(1, 3, 224, 224)\nm_classifier = torchvision.models.mobilenet_v3_large(pretrained=True)\nm_classifier.eval()\npredictions = m_classifier(x)","__index_level_0__":2822}
+{"text":"# Quantized Classification\nx = torch.rand(1, 3, 224, 224)\nm_classifier = torchvision.models.quantization.mobilenet_v3_large(pretrained=True)\nm_classifier.eval()\npredictions = m_classifier(x)","__index_level_0__":2823}
+{"text":"# Object Detection: Highly Accurate High Resolution Mobile Model\nx = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]\nm_detector = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_fpn(pretrained=True)\nm_detector.eval()\npredictions = m_detector(x)","__index_level_0__":2824}
+{"text":"# Semantic Segmentation: Highly Accurate Mobile Model\nx = torch.rand(1, 3, 520, 520)\nm_segmenter = torchvision.models.segmentation.deeplabv3_mobilenet_v3_large(pretrained=True)\nm_segmenter.eval()\npredictions = m_segmenter(x)\n```\nThese models are highly competitive with TorchVision\u2019s existing models on resource efficiency, speed, and accuracy. See our [release notes](https:\/\/github.com\/pytorch\/vision\/releases) for detailed performance metrics.","__index_level_0__":2825}
+{"text":"### [Stable] AutoAugment\n[AutoAugment](https:\/\/arxiv.org\/pdf\/1805.09501.pdf) is a common Data Augmentation technique that can increase the accuracy of Scene Classification models. Though the data augmentation policies are directly linked to their trained dataset, empirical studies show that ImageNet policies provide significant improvements when applied to other datasets. We\u2019ve implemented 3 policies learned on the following datasets: ImageNet, CIFA10 and SVHN. These can be used standalone or mixed-and-matched with existing transforms:\n```python\nfrom torchvision import transforms","__index_level_0__":2826}
+{"text":"t = transforms.AutoAugment()\ntransformed = t(image)","__index_level_0__":2827}
+{"text":"\ntransform=transforms.Compose([\n   transforms.Resize(256),\n   transforms.AutoAugment(),\n   transforms.ToTensor()])\n```\n### Other New Features for TorchVision\n* [Stable] All read and decode methods in the io.image package now support:\n  * Palette, Grayscale Alpha and RBG Alpha image types during PNG decoding\n  * On-the-fly conversion of image from one type to the other during read\n* [Stable] WiderFace dataset\n* [Stable] Improved FasterRCNN speed and accuracy by introducing a score threshold on RPN\n* [Stable] Modulation input for DeformConv2D\n* [Stable] Option to write audio to a video file\n* [Stable] Utility to draw bounding boxes\n* [Beta] Autocast support in all Operators\nFind the full TorchVision release notes [here](https:\/\/github.com\/pytorch\/vision\/releases).","__index_level_0__":2828}
+{"text":"# TorchAudio 0.8.0\n### I\/O Improvements\nWe have continued our work from the [previous release](https:\/\/github.com\/pytorch\/audio\/releases\/tag\/v0.7.0) to improve TorchAudio\u2019s I\/O support, including:\n* [Stable] Changing the default backend to \u201csox_io\u201d (for Linux\/macOS), and updating the \u201csoundfile\u201d backend\u2019s interface to align with that of \u201csox_io\u201d. The legacy backend and interface are still accessible, though it is strongly discouraged to use them.\n* [Stable] File-like object support in both \"sox_io\" backend, \u201csoundfile\u201d backend and sox_effects.\n* [Stable] New options to change the format, encoding, and bits_per_sample when saving.\n* [Stable] Added GSM, HTK, AMB, AMR-NB and AMR-WB format support to the \u201csox_io\u201d backend.\n* [Beta] A new ```functional.apply_codec``` function which can degrade audio data by applying audio codecs supported by \u201csox_io\u201d backend in an in-memory fashion.\nHere are some examples of features landed in this release:","__index_level_0__":2829}
+{"text":"```python\n# Load audio over HTTP\nwith requests.get(URL, stream=True) as response:\n    waveform, sample_rate = torchaudio.load(response.raw)\n \n# Saving to Bytes buffer as 32-bit floating-point PCM\nbuffer_ = io.BytesIO()\ntorchaudio.save(\n    buffer_, waveform, sample_rate,\n    format=\"wav\", encoding=\"PCM_S\", bits_per_sample=16)\n \n# Apply effects while loading audio from S3\nclient = boto3.client('s3')\nresponse = client.get_object(Bucket=S3_BUCKET, Key=S3_KEY)\nwaveform, sample_rate = torchaudio.sox_effects.apply_effect_file(\n    response['Body'],\n    [[\"lowpass\", \"-1\", \"300\"], [\"rate\", \"8000\"]])\n \n# Apply GSM codec to Tensor\nencoded = torchaudio.functional.apply_codec(\n    waveform, sample_rate, format=\"gsm\")\n```","__index_level_0__":2830}
+{"text":"Check out the revamped audio preprocessing tutorial, [Audio Manipulation with TorchAudio](https:\/\/pytorch.org\/tutorials\/beginner\/audio_preprocessing_tutorial.html).","__index_level_0__":2831}
+{"text":"### [Stable] Switch to CMake-based build\nIn the previous version of TorchAudio, it was utilizing CMake to build third party dependencies. Starting in 0.8.0, TorchaAudio uses CMake to build its C++ extension. This will open the door to integrate TorchAudio in non-Python environments (such as C++ applications and mobile). We will continue working on adding example applications and mobile integrations.","__index_level_0__":2832}
+{"text":"### [Beta] Improved and New Audio Transforms\nWe have added two widely requested operators in this release: the SpectralCentroid transform and the Kaldi Pitch feature extraction (detailed in [\"A pitch extraction algorithm tuned for automatic speech recognition\"](https:\/\/ieeexplore.ieee.org\/document\/6854049)). We\u2019ve also exposed a normalization method to Mel transforms, and additional STFT arguments to Spectrogram. We would like to ask  our community to continue to [raise feature requests](https:\/\/github.com\/pytorch\/audio\/issues\/new?assignees=&labels=&template=feature-request.md) for core audio processing features like these!","__index_level_0__":2833}
+{"text":"### Community Contributions\nWe had more contributions from the open source community in this release than ever before, including several completely new features. We would like to extend our sincere thanks to the community. Please check out the newly added [CONTRIBUTING.md](https:\/\/github.com\/pytorch\/audio\/blob\/master\/CONTRIBUTING.md) for ways to contribute code, and remember that reporting bugs and requesting features are just as valuable. We will continue posting well-scoped work items as issues labeled \u201chelp-wanted\u201d and \u201ccontributions-welcome\u201d for anyone who would like to contribute code, and are happy to coach new contributors through the contribution process.","__index_level_0__":2834}
+{"text":"Find the full TorchAudio release notes [here](https:\/\/github.com\/pytorch\/audio\/releases).","__index_level_0__":2835}
+{"text":"# TorchText 0.9.0\n### [Beta] Dataset API Updates\nIn this release, we are updating TorchText\u2019s dataset API to be compatible with PyTorch data utilities, such as DataLoader, and are deprecating TorchText\u2019s custom data abstractions such as ```Field```. The updated datasets are simple string-by-string iterators over the data. For guidance about migrating from the legacy abstractions to use modern PyTorch data utilities, please refer to our [migration guide](https:\/\/github.com\/pytorch\/text\/blob\/master\/examples\/legacy_tutorial\/migration_tutorial.ipynb).","__index_level_0__":2836}
+{"text":"The text datasets listed below have been updated as part of this work. For examples of how to use these datasets, please refer to our [end-to-end text classification tutorial](https:\/\/pytorch.org\/tutorials\/beginner\/text_sentiment_ngrams_tutorial.html).\n* **Language modeling:** WikiText2, WikiText103, PennTreebank, EnWik9\n* **Text classification:** AG_NEWS, SogouNews, DBpedia, YelpReviewPolarity, YelpReviewFull, YahooAnswers, AmazonReviewPolarity, AmazonReviewFull, IMDB\n* **Sequence tagging:** UDPOS, CoNLL2000Chunking\n* **Translation:** IWSLT2016, IWSLT2017\n* **Question answer:** SQuAD1, SQuAD2","__index_level_0__":2837}
+{"text":"Find the full TorchText release notes [here](https:\/\/github.com\/pytorch\/text\/releases).","__index_level_0__":2838}
+{"text":"# [Stable] TorchCSPRNG 0.2.0\nWe [released TorchCSPRNG in August 2020](https:\/\/pytorch.org\/blog\/torchcsprng-release-blog\/), a PyTorch C++\/CUDA extension that provides cryptographically secure pseudorandom number generators for PyTorch. Today, we are releasing the 0.2.0 version and designating the library as stable. This release includes a new API for encrypt\/decrypt with AES128 ECB\/CTR as well as CUDA 11 and Windows CUDA support.","__index_level_0__":2839}
+{"text":"Find the full TorchCSPRNG release notes [here](https:\/\/github.com\/pytorch\/csprng\/releases\/).","__index_level_0__":2840}
+{"text":"Thanks for reading, and if you are excited about these updates and want to participate in the future of PyTorch, we encourage you to join the [discussion forums](https:\/\/discuss.pytorch.org\/) and [open GitHub issues](https:\/\/github.com\/pytorch).","__index_level_0__":2844}
+{"text":"***Team PyTorch***\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.8-new-library-releases\/ \n category: pytorch blogs","__index_level_0__":2846}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'An overview of the ML models introduced in TorchVision v0.9'\nauthor: Team PyTorch \n---","__index_level_0__":2847}
+{"text":"TorchVision v0.9 has been [released](https:\/\/github.com\/pytorch\/vision\/releases) and it is packed with numerous new Machine Learning models and features, speed improvements and bug fixes. In this blog post, we provide a quick overview of the newly introduced ML models and discuss their key features and characteristics.","__index_level_0__":2848}
+{"text":"### Classification\n* **MobileNetV3 Large & Small:** These two classification models are optimized for Mobile use-cases and are used as backbones on other Computer Vision tasks. The implementation of the new [MobileNetV3 architecture](https:\/\/github.com\/pytorch\/vision\/blob\/master\/torchvision\/models\/mobilenetv3.py) supports the Large & Small variants and the depth multiplier parameter as described in the [original paper](https:\/\/arxiv.org\/pdf\/1905.02244.pdf). We offer pre-trained weights on ImageNet for both Large and Small networks with depth multiplier 1.0 and resolution 224x224. Our previous [training recipes](https:\/\/github.com\/pytorch\/vision\/tree\/master\/references\/classification#mobilenetv3-large--small) have been updated and can be used to easily train the models from scratch (shoutout to Ross Wightman for inspiring some of our [training configuration](https:\/\/rwightman.github.io\/pytorch-image-models\/training_hparam_examples\/#mobilenetv3-large-100-75766-top-1-92542-top-5)). The Large variant offers a [competitive accuracy](https:\/\/github.com\/pytorch\/vision\/blob\/master\/docs\/source\/models.rst#classification) comparing to ResNet50 while being over 6x faster on CPU, meaning that it is a good candidate for applications where speed is important. For applications where speed is critical, one can sacrifice further accuracy for speed and use the Small variant which is 15x faster than ResNet50.","__index_level_0__":2849}
+{"text":"* **Quantized MobileNetV3 Large:** The quantized version of MobilNetV3 Large reduces the number of parameters by 45% and it is roughly 2.5x faster than the non-quantized version while remaining competitive in [terms of accuracy](https:\/\/github.com\/pytorch\/vision\/blob\/master\/docs\/source\/models.rst#quantized-models). It was fitted on ImageNet using Quantization Aware Training by iterating on the non-quantized version and it can be trained from scratch using the existing [reference scripts](https:\/\/github.com\/pytorch\/vision\/tree\/master\/references\/classification#quantized).","__index_level_0__":2850}
+{"text":"**Usage:**\n```\nmodel = torchvision.models.mobilenet_v3_large(pretrained=True)\n# model = torchvision.models.mobilenet_v3_small(pretrained=True)\n# model = torchvision.models.quantization.mobilenet_v3_large(pretrained=True)\nmodel.eval()\npredictions = model(img)\n```\n### Object Detection\n* **Faster R-CNN MobileNetV3-Large FPN:** Combining the MobileNetV3 Large backbone with a Faster R-CNN detector and a Feature Pyramid Network leads to a highly accurate and fast object detector. The pre-trained weights are fitted on COCO 2017 using the provided reference [scripts](https:\/\/github.com\/pytorch\/vision\/tree\/master\/references\/detection#faster-r-cnn-mobilenetv3-large-fpn) and the model is 5x faster on CPU than the equivalent ResNet50 detector while remaining competitive in [terms of accuracy](https:\/\/github.com\/pytorch\/vision\/blob\/master\/docs\/source\/models.rst#object-detection-instance-segmentation-and-person-keypoint-detection). \n* **Faster R-CNN MobileNetV3-Large 320 FPN:** This is an iteration of the previous model that uses reduced resolution (min_size=320 pixel) and sacrifices accuracy for speed. It is 25x faster on CPU than the equivalent ResNet50 detector and thus it is good for real mobile use-cases.","__index_level_0__":2851}
+{"text":"**Usage:**\n```\nmodel = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_fpn(pretrained=True)\n# model = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_320_fpn(pretrained=True)\nmodel.eval()\npredictions = model(img)\n```\n### Semantic Segmentation\n* **DeepLabV3 with Dilated MobileNetV3 Large Backbone:** A dilated version of the MobileNetV3 Large backbone combined with DeepLabV3 helps us build a highly accurate and fast semantic segmentation model. The pre-trained weights are fitted on COCO 2017 using our [standard training recipes](https:\/\/github.com\/pytorch\/vision\/tree\/master\/references\/segmentation#deeplabv3_mobilenet_v3_large). The final model has the [same accuracy](https:\/\/github.com\/pytorch\/vision\/blob\/master\/docs\/source\/models.rst#semantic-segmentation) as the FCN ResNet50 but it is 8.5x faster on CPU and thus making it an excellent replacement for the majority of applications.\n* **Lite R-ASPP with Dilated MobileNetV3 Large Backbone:** We introduce the implementation of a new segmentation head called Lite R-ASPP and combine it with the dilated MobileNetV3 Large backbone to build a very fast segmentation model. The new model sacrifices some accuracy to achieve a 15x speed improvement comparing to the previously most lightweight segmentation model which was the FCN ResNet50.","__index_level_0__":2852}
+{"text":"**Usage:**\n```\nmodel = torchvision.models.segmentation.deeplabv3_mobilenet_v3_large(pretrained=True)\n# model = torchvision.models.segmentation.lraspp_mobilenet_v3_large(pretrained=True)\nmodel.eval()\npredictions = model(img)\n```\nIn the near future we plan to publish an article that covers the details of how the above models were trained and discuss their tradeoffs and design choices. Until then we encourage you to try out the new models and provide your feedback.\n \n source: https:\/\/pytorch.org\/blog\/ml-models-torchvision-v0.9\/ \n category: pytorch blogs","__index_level_0__":2853}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Introducing nvFuser, a deep learning compiler for PyTorch'\nauthor: Christian Sarofeen, Piotr Bialecki, Jie Jiang, Kevin Stephano, Masaki Kozuki, Neal Vaidya, Stas Bekman\nfeatured-img: \"\/assets\/images\/introducing-nvfuser-a-deep-learning-compiler-for-pytorch-1.png\"\n---","__index_level_0__":2854}
+{"text":"nvFuser is a Deep Learning Compiler for NVIDIA GPUs that automatically just-in-time compiles fast and flexible kernels to reliably accelerate users' networks. It provides significant speedups for deep learning networks running on Volta and later CUDA accelerators by generating fast custom \u201cfusion\u201d kernels at runtime. nvFuser is specifically designed to meet the unique requirements of the PyTorch community, and it supports diverse network architectures and programs with dynamic inputs of varying shapes and strides.\nIn this blog post we\u2019ll describe nvFuser and how it\u2019s used today, show the significant performance improvements it can obtain on models from HuggingFace and TIMM, and look ahead to nvFuser in PyTorch 1.13 and beyond. If you would like to know more about how and why fusion improves the speed of training for Deep Learning networks, please see our previous talks on nvFuser from [GTC 2022](https:\/\/www.nvidia.com\/en-us\/on-demand\/session\/gtcspring22-s41958\/) and [GTC 2021](https:\/\/www.nvidia.com\/en-us\/on-demand\/session\/gtcspring21-s31952\/).\nnvFuser relies on a graph representation of PyTorch operations to optimize and accelerate. Since PyTorch has an eager execution model, the PyTorch operations users are running are not directly accessible as a whole program that can be optimized by a system like nvFuser. Therefore users must utilize systems built on top of nvFuser which are capable of capturing users programs and translating them into a form that is optimizable by nvFuser. These higher level systems then pass these captured operations to nvFuser, so that nvFuser can optimize the execution of the user\u2019s script for NVIDIA GPUs. There are three systems that capture, translate, and pass user programs to nvFuser for optimization:","__index_level_0__":2855}
+{"text":"- [TorchScript jit.script](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.jit.script.html#torch.jit.script)\n  - This system directly parses sections of an annotated python script to translate into its own representation what the user is doing. This system then applies its own version of auto differentiation to the graph, and passes sections of the subsequent forward and backwards graphs to nvFuser for optimization.\n- [FuncTorch](https:\/\/pytorch.org\/functorch\/stable\/generated\/functorch.compile.memory_efficient_fusion.html#functorch.compile.memory_efficient_fusion)\n  - This system doesn\u2019t directly look at the user python script, instead inserting a mechanism that captures PyTorch operations as they\u2019re being run. We refer to this type of capture system as \u201ctrace program acquisition\u201d, since we\u2019re tracing what has been performed. FuncTorch doesn\u2019t perform its own auto differentiation \u2013 it simply traces PyTorch\u2019s autograd directly to get backward graphs.\n- [TorchDynamo](https:\/\/github.com\/pytorch\/torchdynamo)\n  - TorchDynamo is another program acquisition mechanism built on top of FuncTorch. TorchDynamo parses the Python bytecode produced from the user script in order to select portions to trace with FuncTorch. The benefit of TorchDynamo is that it\u2019s able to apply decorators to a user\u2019s script, effectively isolating what should be sent to FuncTorch, making it easier for FuncTorch to successfully trace complex Python scripts.","__index_level_0__":2856}
+{"text":"These systems are available for users to interact with directly while nvFuser automatically and seamlessly optimizes performance critical regions of the user\u2019s code. These systems automatically send parsed user programs to nvFuser so nvFuser can:","__index_level_0__":2857}
+{"text":"1. Analyze the operations being run on GPUs\n2. Plan parallelization and optimization strategies for those operations\n3. Apply those strategies in generated GPU code\n4. Runtime-compile the generated optimized GPU functions\n5. Execute those CUDA kernels on subsequent iterations","__index_level_0__":2858}
+{"text":"It is important to note nvFuser does not yet support all PyTorch operations, and there are still some scenarios that are actively being improved in nvFuser that are discussed herein. However, nvFuser does support many DL performance critical operations today, and the number of supported operations will grow in subsequent PyTorch releases. nvFuser is capable of generating highly specialized and optimized GPU functions for the operations it does have support for. This means nvFuser is able to power new PyTorch systems like TorchDynamo and FuncTorch to combine the flexibility PyTorch is known for with unbeatable performance.","__index_level_0__":2859}
+{"text":"## nvFuser Performance","__index_level_0__":2860}
+{"text":"Before getting into how to use nvFuser, in this section we\u2019ll show the improvements in training speed nvFuser provides for a variety of models from the [HuggingFace Transformers](https:\/\/github.com\/huggingface\/transformers) and [PyTorch Image Models (TIMM)](https:\/\/github.com\/rwightman\/pytorch-image-models) repositories and we will discuss current gaps in nvFuser performance that are under development today. All performance numbers in this section were taken using an NVIDIA A100 40GB GPU, and used either FuncTorch alone or Functorch with TorchDynamo.","__index_level_0__":2861}
+{"text":"## HuggingFace Transformer Benchmarks","__index_level_0__":2862}
+{"text":"nvFuser can dramatically accelerate training of HuggingFace Transformers when combined with another important optimization (more on that in a moment). Performance improvements can be seen in Figure 1 to range between 1.12x and 1.50x across a subset of popular HuggingFace Transformer networks.","__index_level_0__":2863}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/introducing-nvfuser-a-deep-learning-compiler-for-pytorch-1.png\" width=\"70%\">\n<\/p>","__index_level_0__":2864}
+{"text":"<p align=\"center\">\nFigure 1: Performance gains of 8 training scenarios from HuggingFace\u2019s Transformer repository. First performance boost in the dark green is due to replacing the optimizer with an NVIDIA Apex fused AdamW optimizer. The light green is due to adding nvFuser. Models were run with batch size and sequence lengths of [64, 128], [8, 512], [2, 1024], [64, 128], [8, 512], [8, src_seql=512, tgt_seql=128], [8, src_seql=1024, tgt_seql=128], and [8, 512] respectively. All networks were run with Automatic Mixed Precision (AMP) enabled with dtype=float16.\n<\/p>","__index_level_0__":2865}
+{"text":"While these speedups are significant, it\u2019s important to understand that nvFuser doesn\u2019t (yet) automate everything about running networks quickly. For HuggingFace Transformers, for example, it was important to use the AdamW fused optimizer from [NVIDIA\u2019s Apex repository](https:\/\/github.com\/NVIDIA\/apex) as the optimizer otherwise consumed a large portion of runtime. Using the fused AdamW optimizer to make the network faster exposes the next major performance bottleneck \u2014 memory bound operations. These operations are optimized by nvFuser, providing another large performance boost. With the fused optimizer and nvFuser enabled, the training speed of these networks improved between 1.12x to 1.5x.\nHuggingFace Transformer models were run with [the torch.amp module](https:\/\/pytorch.org\/docs\/stable\/amp.html). (\u201camp\u201d stands for Automated Mixed Precision, see the [\u201cWhat Every User Should Know about Mixed Precision in PyTorch\u201d](https:\/\/pytorch.org\/blog\/what-every-user-should-know-about-mixed-precision-training-in-pytorch\/) blog post for details.) An option to use nvFuser was added to HuggingFace\u2019sTrainer. If you have [TorchDynamo installed](https:\/\/github.com\/pytorch\/torchdynamo#requirements-and-setup) you can activate it to enable nvFuser in HuggingFace by passing *torchdynamo = \u2018nvfuser\u2019* to the Trainer class.\nnvFuser has great support for normalization kernels and related fusions frequently found in Natural Language Processing (NLP) models, and it is recommended users try nvFuser in their NLP workloads.","__index_level_0__":2866}
+{"text":"## PyTorch Image Models (TIMM) Benchmarks\nnvFuser, can also significantly reduce the training time of TIMM networks, up to over 1.3x vs. eager PyTorch, and up to 1.44x vs. eager PyTorch when combined with the torch.amp module. Figure 1 shows nvFuser\u2019s speedup without torch.amp, and when torch.amp is used with the NHWC (\u201cchannels last\u201d) and NCHW (\u201cchannels first\u201d) formats. nvFuser is integrated in TIMM through FuncTorch tracing directly (without TorchDynamo) and can be used by adding the [--aot-autograd command line argument](https:\/\/github.com\/rwightman\/pytorch-image-models\/commit\/ca991c1fa57373286b9876aa63370fd19f5d6032) when running the TIMM benchmark or training script.","__index_level_0__":2867}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/introducing-nvfuser-a-deep-learning-compiler-for-pytorch-2.png\" width=\"100%\">\n<\/p>","__index_level_0__":2868}
+{"text":"<p align=\"center\">\nFigure 1: The Y-axis is the performance gain nvFuser provides over not using nvFuser. A value of 1.0 means no change in perf, 2.0 would mean nvFuser is twice as fast, 0.5 would mean nvFuser takes twice the time to run. Square markers are with float16 Automatic Mixed Precision (AMP) and channels first contiguous inputs, circle markers are float32 inputs, and triangles are with float16 AMP and channels last contiguous inputs. Missing data points are due to an error being encountered when tracing.\n<\/p>","__index_level_0__":2869}
+{"text":"When running with float32 precision nvFuser provides a 1.12x geometric mean (\u201cgeomean\u201d) speedup on TIMM networks, and when running with torch.amp and \u201cchannels first\u201d it provides a 1.14x geomean speedup. However, nvFuser currently doesn\u2019t speedup torch.amp and \u201cchannels last\u201d training (a .9x geomean regression), so we recommend not using it in those cases. We are actively working on improving \u201cchannels last\u201d performance now, and soon we will have two additional optimization strategies (grid persistent optimizations for channels-last normalizations and fast transposes) which we expect will provide speedups comparable to \u201cchannels first\u201d in PyTorch version 1.13 and later. Many of nvFuser\u2019s optimizations can also help in inference cases. However, in PyTorch when running inference on small batch sizes, the performance is typically limited by CPU overhead, which nvFuser can\u2019t completely remove or fix. Therefore, typically the most important optimization for inference is to enable [CUDA Graphs](https:\/\/pytorch.org\/blog\/accelerating-pytorch-with-cuda-graphs\/) when possible. Once CUDA Graphs is enabled, then it can also be beneficial to also enable fusion through nvFuser. Performance of inference is shown in Figure 2 and Figure 3. Inference is only run with float16 AMP as it is uncommon to run inference workloads in full float32 precision.","__index_level_0__":2870}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/introducing-nvfuser-a-deep-learning-compiler-for-pytorch-3.png\" width=\"100%\">\n<\/p>","__index_level_0__":2871}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/introducing-nvfuser-a-deep-learning-compiler-for-pytorch-4.png\" width=\"100%\">\n<\/p>","__index_level_0__":2872}
+{"text":"<p align=\"center\">\nFigure 2: Performance gains of enabling CUDA Graphs, and CUDA Graphs with nvFuser compared to the performance of native PyTorch without CUDA Graphs and nvFuser across TIMM models with float16 AMP, <b>channels first inputs<\/b>, and a batch size of 1 and 8 respectively. There is a geomean speedup of 2.74x with CUDA Graphs and 2.71x with CUDA Graphs + nvFuser respectively. nvFuser provides a maximum regression of 0.68x and a maximum performance gain of 2.74x (relative to CUDA Graphs without nvFuser). Performance gain is measured relative to the average time per iteration PyTorch takes without CUDA Graphs and without nvFuser. Models are sorted by how much additional performance nvFuser is providing.\n<\/p>","__index_level_0__":2873}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/introducing-nvfuser-a-deep-learning-compiler-for-pytorch-5.png\" width=\"100%\">\n<\/p>","__index_level_0__":2874}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/introducing-nvfuser-a-deep-learning-compiler-for-pytorch-6.png\" width=\"100%\">\n<\/p>","__index_level_0__":2875}
+{"text":"<p align=\"center\">\nFigure 3: Performance gains of enabling CUDA Graphs, and CUDA Graphs with nvFuser compared to the performance of native PyTorch without CUDA Graphs and nvFuser across TIMM models with AMP, <b>channels last inputs<\/b>, and a batch size of 1 and 8 respectively. There is a geomean speedup of 2.29x with CUDA Graphs and 2.95x with CUDA Graphs + nvFuser respectively. nvFuser provides a maximum regression of 0.86x and a maximum performance gain of 3.82x (relative to CUDA Graphs without nvFuser). Performance gain is measured relative to the average time per iteration PyTorch takes without CUDA Graphs and without nvFuser. Models are sorted by how much additional performance nvFuser is providing.\n<\/p>","__index_level_0__":2876}
+{"text":"So far nvFuser performance has not been tuned for inference workloads so its performance benefit is not consistent across all cases. However, there are still many models that benefit significantly from nvFuser during inference and we encourage users to try nvFuser in inference workloads to see if you would benefit today. Performance of nvFuser in inference workloads will improve in the future and if you\u2019re interested in nvFuser in inference workloads please reach out to us on the PyTorch forums.","__index_level_0__":2877}
+{"text":"## Getting Started - Accelerate Your Scripts with nvFuser","__index_level_0__":2878}
+{"text":"We\u2019ve created [a tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/nvfuser_intro_tutorial.html) demonstrating how to take advantage of nvFuser to accelerate part of a standard transformer block, and how nvFuser can be used to define fast and novel operations. There are still some rough edges in nvFuser that we\u2019re working hard on improving as we\u2019ve outlined in this blog post. However we\u2019ve also demonstrated some great improvements for training speed on multiple networks in HuggingFace and TIMM and we expect there are opportunities in your networks where nvFuser can help today, and many more opportunities it will help in the future.\nIf you would like to learn more about nvFuser we recommend watching our presentations from NVIDIA\u2019s GTC conference [GTC 2022](https:\/\/www.nvidia.com\/en-us\/on-demand\/session\/gtcspring22-s41958\/) and [GTC 2021](https:\/\/www.nvidia.com\/en-us\/on-demand\/session\/gtcspring21-s31952\/).\n \n source: https:\/\/pytorch.org\/blog\/introducing-nvfuser-a-deep-learning-compiler-for-pytorch\/ \n category: pytorch blogs","__index_level_0__":2879}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Introducing PyTorch Profiler - the new and improved performance tool'\nauthor: Maxim Lukiyanov - Principal PM at Microsoft, Guoliang Hua - Principal Engineering Manager at Microsoft, Geeta Chauhan - Partner Engineering Lead at Facebook, Gisle Dankel - Tech Lead at Facebook\n---","__index_level_0__":2880}
+{"text":"Along with [PyTorch 1.8.1 release](https:\/\/github.com\/pytorch\/pytorch\/releases\/tag\/v1.8.1), we are excited to announce PyTorch Profiler \u2013 the new and improved performance debugging profiler for PyTorch. Developed as part of a collaboration between Microsoft and Facebook, the PyTorch Profiler is an open-source tool that enables accurate and efficient performance analysis and troubleshooting for large-scale deep learning models.","__index_level_0__":2881}
+{"text":"Analyzing and improving large-scale deep learning model performance is an ongoing challenge that grows in importance as the model sizes increase. For a long time, PyTorch users had a hard time solving this challenge due to the lack of available tools. There were standard performance debugging tools that provide GPU hardware level information but missed PyTorch-specific context of operations. In order to recover missed information, users needed to combine multiple tools together or manually add minimum correlation information to make sense of the data. There was also the autograd profiler (```torch.autograd.profiler```) which can capture information about PyTorch operations but does not capture detailed GPU hardware-level information and cannot provide support for visualization.","__index_level_0__":2882}
+{"text":"The new PyTorch Profiler (```torch.profiler```) is a tool that brings both types of information together and then builds experience that realizes the full potential of that information. This new profiler collects both GPU hardware and PyTorch related information, correlates them, performs automatic detection of bottlenecks in the model, and generates recommendations on how to resolve these bottlenecks. All of this information from the profiler is visualized for the user in TensorBoard. The new Profiler API is natively supported in PyTorch and delivers the simplest experience available to date where users can profile their models without installing any additional packages and see results immediately in TensorBoard with the new PyTorch Profiler plugin. Below is the screenshot of PyTorch Profiler - automatic bottleneck detection. ","__index_level_0__":2883}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/pytorch-profiler-bottleneck.png\" width=\"100%\">\n<\/div>","__index_level_0__":2884}
+{"text":"## Getting started","__index_level_0__":2885}
+{"text":"PyTorch Profiler is the next version of the PyTorch autograd profiler. It has a new module namespace ```torch.profiler``` but maintains compatibility with autograd profiler APIs. The Profiler uses a new GPU profiling engine, built using Nvidia CUPTI APIs, and is able to capture GPU kernel events with high fidelity. To profile your model training loop, wrap the code in the profiler context manager as shown below.","__index_level_0__":2886}
+{"text":"```python\n with torch.profiler.profile(\n    schedule=torch.profiler.schedule(\n        wait=2,\n        warmup=2,\n        active=6,\n        repeat=1),\n    on_trace_ready=tensorboard_trace_handler,\n    with_stack=True\n) as profiler:\n    for step, data in enumerate(trainloader, 0):\n        print(\"step:{}\".format(step))\n        inputs, labels = data[0].to(device=device), data[1].to(device=device)","__index_level_0__":2887}
+{"text":"        outputs = model(inputs)\n        loss = criterion(outputs, labels)","__index_level_0__":2888}
+{"text":"        optimizer.zero_grad()\n        loss.backward()\n        optimizer.step()\n        profiler.step()\n```\nThe ```schedule``` parameter allows you to limit the number of training steps included in the profile to reduce the amount of data collected and simplify visual analysis by focusing on what\u2019s important. The ```tensorboard_trace_handler``` automatically saves profiling results to disk for analysis in TensorBoard.","__index_level_0__":2889}
+{"text":"To view results of the profiling session in TensorBoard, install PyTorch Profiler TensorBoard Plugin package.","__index_level_0__":2890}
+{"text":"```python\npip install torch_tb_profiler\n```\n## Visual Studio Code Integration\n[Microsoft Visual Studio Code](https:\/\/code.visualstudio.com\/) is one of the most popular code editors for Python developers and data scientists. The [Python extension](https:\/\/marketplace.visualstudio.com\/items?itemName=ms-python.python)  for VS Code recently added the integration of TensorBoard into the code editor, including support for the PyTorch Profiler. Once you have VS Code and the Python extension installed, you can quickly open the TensorBoard Profiler plugin by launching the Command Palette using the keyboard shortcut CTRL + SHIFT + P (CMD + SHIFT + P on a Mac) and typing the \u201cLaunch TensorBoard\u201d command.","__index_level_0__":2891}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/pytorch-profiler-vscode-launch.png\" width=\"100%\">\n<\/div>","__index_level_0__":2892}
+{"text":"This integration comes with a built-in lifecycle   management feature. VS Code will install the TensorBoard package and the PyTorch Profiler plugin package (coming in mid-April) automatically if you don\u2019t have them on your system. VS Code will also launch TensorBoard process for you and automatically look for any TensorBoard log files within your current directory. When you\u2019re done, just close the tab and VS Code will automatically close the process.  No more Terminal windows running on your system to provide a backend for the TensorBoard UI! Below is PyTorch Profiler Trace View running in TensorBoard.","__index_level_0__":2893}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/pytorch-profiler-vscode.png\" width=\"100%\">\n<\/div>","__index_level_0__":2894}
+{"text":"Learn more about TensorBoard support in VS Code in [this blog](https:\/\/devblogs.microsoft.com\/python\/python-in-visual-studio-code-february-2021-release\/).","__index_level_0__":2895}
+{"text":"## Feedback","__index_level_0__":2896}
+{"text":"Review [PyTorch Profiler documentation](https:\/\/pytorch.org\/docs\/stable\/profiler.html), give Profiler a try and let us know about your experience. Provide your feedback on [PyTorch Discussion Forum](https:\/\/discuss.pytorch.org\/) or file issues on [PyTorch GitHub](https:\/\/github.com\/pytorch\/pytorch).","__index_level_0__":2897}
+{"text":" \n source: https:\/\/pytorch.org\/blog\/introducing-pytorch-profiler-the-new-and-improved-performance-tool\/ \n category: pytorch blogs","__index_level_0__":2898}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"How Disney Improved Activity Recognition Through Multimodal Approaches with PyTorch\"\nauthor: Monica Alfaro, Albert Aparicio, Francesc Guitart, Marc Junyent, Pablo Pernias, Marcel Porta, and Miquel \u00c0ngel Farr\u00e9 (former Senior Technology Manager)\nfeatured-img: 'assets\/images\/disney_media_logo.jpg'\n---","__index_level_0__":2899}
+{"text":"# Introduction","__index_level_0__":2900}
+{"text":"Among the many things Disney Media & Entertainment Distribution (DMED) is responsible for, is the management and distribution of a huge array of media assets including news, sports, entertainment and features, episodic programs, marketing and advertising and more.","__index_level_0__":2901}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/disney_media_logo.jpg\" width=\"80%\">\n<\/p>","__index_level_0__":2903}
+{"text":"Our team focuses on media annotation as part of DMED Technology\u2019s content platforms group. In our day-to-day work, we automatically analyze a variety of content that constantly challenges the efficiency of our machine learning workflow and the accuracy of our models.","__index_level_0__":2905}
+{"text":"Several of our colleagues recently discussed the workflow efficiencies that we achieved by switching to an end-to-end video analysis pipeline using PyTorch, as well as how we approach animated character recognition. We invite you to read more about both in this previous post.","__index_level_0__":2906}
+{"text":"While the conversion to an end-to-end PyTorch pipeline is a solution that any company might benefit from, animated character recognition was a uniquely-Disney concept and solution.","__index_level_0__":2907}
+{"text":"In this article we will focus on activity recognition, which is a general challenge across industries \u2014 but with some specific opportunities when leveraged in the media production field, because we can combine audio, video, and subtitles to provide a solution.","__index_level_0__":2908}
+{"text":"# Experimenting with Multimodality","__index_level_0__":2909}
+{"text":"Working on a multimodal problem adds more complexity to the usual training pipelines. Having multiple information modes for each example means that the multimodal pipeline has to have specific implementations to process each mode in the dataset. Usually after this processing step, the pipeline has to merge or fuse the outputs.","__index_level_0__":2910}
+{"text":"Our initial experiments in multimodality were completed using the [MMF framework](https:\/\/github.com\/facebookresearch\/mmf). MMF is a modular framework for vision and language multimodal research. MMF contains reference implementations of state-of-the-art vision and language models and has also powered multiple research projects at Meta AI Research (as seen in this [poster](https:\/\/assets.pytorch.org\/pted2021\/posters\/A3.png) presented in PyTorch Ecosystem Day 2020). Along with the recent release of TorchMultimodal, a PyTorch library for training state-of-the-art multimodal models at scale, MMF highlights the growing interest in Multimodal understanding.","__index_level_0__":2911}
+{"text":"MMF tackles this complexity with modular management of all the elements of the pipeline through a wide set of different implementations for specific modules, ranging from the processing of the modalities to the fusion of the processed information.","__index_level_0__":2912}
+{"text":"In our scenario, MMF was a great entry point to experiment with multimodality. It allowed us to iterate quickly by combining audio, video and closed captioning and experiment at different levels of scale with certain multimodal models, shifting from a single GPU to TPU Pods.","__index_level_0__":2913}
+{"text":"# Multimodal Transformers","__index_level_0__":2914}
+{"text":"With a workbench based on MMF, our initial model was based on a concatenation of features from each modality evolving to a pipeline that included a Transformer-based fusion module to combine the different input modes.","__index_level_0__":2915}
+{"text":"Specifically, we made use of the fusion module called MMFTransformer, developed in collaboration with the Meta AI Research team. This is an implementation based on [VisualBERT](https:\/\/arxiv.org\/abs\/1908.03557) for which the necessary modifications were added to be able to work with text, audio and video.","__index_level_0__":2916}
+{"text":"Despite having decent results with the out-of-box implementation MMFTransformer, we were still far from our goal, and the Transformers-based models required more data than we had available.","__index_level_0__":2917}
+{"text":"# Searching for less data-hungry solutions","__index_level_0__":2918}
+{"text":"Searching for less data-hungry solutions, our team started studying [MLP-Mixer](https:\/\/arxiv.org\/abs\/2105.01601). This new architecture has been proposed by the Google Brain team and it provides an alternative to well established de facto architectures like convolutions or self-attention for computer vision tasks.","__index_level_0__":2919}
+{"text":"## MLP-Mixer","__index_level_0__":2920}
+{"text":"The core idea behind mixed variations consists of replacing the convolutions or self-attention mechanisms used in transformers with Multilayer Perceptrons. This change in architecture favors the performance of the model in high data regimes (especially with respect to the Transformers), while also opening some questions regarding the inductive biases hidden in the convolutions and the self-attention layers.","__index_level_0__":2921}
+{"text":"Those proposals perform great in solving image classification tasks by splitting the image in chunks, flattening those chunks into 1D vectors and passing them through a sequence of Mixer Layers.","__index_level_0__":2922}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/google_MLPMixer_architecture.png\" width=\"100%\">\n<\/p>","__index_level_0__":2924}
+{"text":"Inspired by the advantages of Mixer based architectures, our team searched for parallelisms with the type of problems we try to solve in video classification: specifically, instead of a single image, we have a set of frames that need to be classified, along with audio and closed captioning in the shape of new modalities.","__index_level_0__":2926}
+{"text":"# Activity Recognition reinterpreting the MLP-Mixer","__index_level_0__":2927}
+{"text":"Our proposal takes the core idea of the [MLP-Mixer](https:\/\/arxiv.org\/abs\/2105.01601) \u2014 using multiple multi-layer perceptrons on a sequence and transposed sequence and extends it into a Multi Modal framework that allows us to process video, audio & text with the same architecture.","__index_level_0__":2928}
+{"text":"For each of the modalities, we use different extractors that will provide embeddings describing the content. Given the embeddings of each modality, the MLP-Mixer architecture solves the problem of deciding which of the modalities might be the most important, while also weighing how much each modality contributes to the final labeling.","__index_level_0__":2929}
+{"text":"For example, when it comes to detecting laughs, sometimes the key information is in audio or in the frames, and in some of the cases we have a strong signal in the closed caption.","__index_level_0__":2930}
+{"text":"We tried processing each frame separately with a ResNet34 and getting a sequence of embeddings and by using a video-specific model called R3D, both pre-trained on ImageNet and Kinetics400 respectively.","__index_level_0__":2931}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/video-backbone-image-1.png\" width=\"80%\">\n<\/p>","__index_level_0__":2933}
+{"text":"To process the audio, we use the pretrained ResNet34, and we remove the final layers to be able to extract 2D embeddings from the audio spectrograms (for 224x224 images we end up with 7x7 embeddings).","__index_level_0__":2935}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/audio-backbone-image-1.png\" width=\"60%\">\n<\/p>","__index_level_0__":2937}
+{"text":"For closed captioning, we are using a pre-trained BERT-large, with all layers frozen, except for the Embeddings & LayerNorms.","__index_level_0__":2939}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/text-backbone-image-1.png\" width=\"60%\">\n<\/p>","__index_level_0__":2941}
+{"text":"Once we have extracted the embedding from each modality, we concatenate them into a single sequence and pass it through a set of MLP-Mixer blocks; next we use average pooling & a classification head to get predictions.","__index_level_0__":2943}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/full-architecture-image-1.png\" width=\"100%\">\n<\/p>","__index_level_0__":2945}
+{"text":"Our experiments have been performed on a custom, manually labeled dataset for activity recognition with 15 classes, which we know from experiments are hard and cannot all be predicted accurately using a single modality.","__index_level_0__":2947}
+{"text":"These experiments have shown a significant increase in performance using our approach, especially in a low\/mid-data regime (75K training samples).","__index_level_0__":2948}
+{"text":"When it comes to using only Text and Audio, our experiments showed a 15 percent improvement in accuracy over using a classifier on top of the features extracted by state-of-the-art backbones.","__index_level_0__":2949}
+{"text":"Using Text, Audio and Video we have seen a 17 percent improvement in accuracy over using Meta AIFacebook\u2019s MMF Framework, which uses a VisualBERT-like model to combine modalities using more powerful state of the art backbones.","__index_level_0__":2950}
+{"text":"Currently, we extended the initial model to cover up to 55 activity classes and 45 event classes. One of the challenges we expect to improve upon in the future is to include all activities and events, even those that are less frequent.","__index_level_0__":2951}
+{"text":"## Interpreting the MLP-Mixer mode combinations ","__index_level_0__":2952}
+{"text":"An MLP-Mixer is a concatenation of MultiLayer Perceptrons. This can be, very roughly, approximated to a linear operation, in the sense that, once trained, the weights are fixed and the input will directly affect the output.","__index_level_0__":2953}
+{"text":"Once we assume that approximation, we also assume that for an input consisting of NxM numbers, we could find a NxM matrix that (when multiplied elementwise) could approximate the predictions of the MLP-Mixer for a class.","__index_level_0__":2954}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/stencil-image-1.png\" width=\"100%\">\n<\/p>","__index_level_0__":2956}
+{"text":"We will call this matrix a stencil, and if we have access to it, we can find what parts of the input embeddings are responsible for a specific prediction.","__index_level_0__":2958}
+{"text":"You can think of it as a punch card with holes in specific positions. Only information in those positions will pass and contribute to a specific prediction. So we can measure the intensity of the input at those positions.","__index_level_0__":2959}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/stencil-image-2.png\" width=\"100%\">\n<\/p>","__index_level_0__":2961}
+{"text":"Of course, this is an oversimplification, and there won't exist a unique stencil that perfectly represents all of the contributions of the input to a class (otherwise that would mean that the problem could be solved linearly). So this should be used for visualization purposes only, not as an accurate predictor.","__index_level_0__":2963}
+{"text":"Once we have a set of stencils for each class, we can effortlessly measure input contribution without relying on any external visualization techniques.","__index_level_0__":2964}
+{"text":"To find a stencil, we can start from a \"random noise\" stencil and optimize it to maximize the activations for a specific class by just back-propagating through the MLP-Mixer.","__index_level_0__":2965}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/stencil-image-3.png\" width=\"100%\">\n<\/p>","__index_level_0__":2967}
+{"text":"By doing this we can end up with many valid stencils, and we can reduce them to a few by using K-means to cluster them into similar stencils and averaging each cluster.","__index_level_0__":2969}
+{"text":"# Using the Mixer to get the best of each world","__index_level_0__":2970}
+{"text":"MLP-Mixer, used as an image classification model without convolutional layers, requires a lot of data, since the lack of inductive bias \u2013 one of the model's good points overall \u2013 is a weakness when it comes to working in low data domains.","__index_level_0__":2971}
+{"text":"When used as a way to combine information previously extracted by large pretrained backbones (as opposed to being used as a full end-to-end solution), they shine. The Mixer\u2019s strength lies in finding temporal or structural coherence between different inputs. For example, in video-related tasks we could extract embeddings from the frames using a powerful, pretrained model that understands what is going on at frame level and use the mixer to make sense of it in a sequential manner.","__index_level_0__":2972}
+{"text":"This way of using the Mixer allows us to work with limited amounts of data and still get better results than what was achieved with Transformers. This is because Mixers seem to be more stable during training and seem to pay attention to all the inputs, while Transformers tend to collapse and pay attention only to some modalities\/parts of the sequence.","__index_level_0__":2973}
+{"text":"Acknowledgements: We would like to thank the Meta AI Research and Partner Engineering teams for this collaboration.\n \n source: https:\/\/pytorch.org\/blog\/how-disney-improved-activity-recognition-with-multimodal-approaches-with-pytorch\/ \n category: pytorch blogs","__index_level_0__":2974}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Practical Quantization in PyTorch'\nauthor: Suraj Subramanian, Mark Saroufim, Jerry Zhang\nfeatured-img: ''\n---","__index_level_0__":2975}
+{"text":"Quantization is a cheap and easy way to make your DNN run faster and with lower memory requirements. PyTorch offers a few different approaches to quantize your model. In this blog post, we'll lay a (quick) foundation of quantization in deep learning, and then take a look at how each technique looks like in practice. Finally we'll end with recommendations from the literature for using quantization in your workflows.","__index_level_0__":2976}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/quantization-practice\/hero.gif\" width=\"60%\">\n  <br>\n  Fig 1. PyTorch <3 Quantization\n<\/p>","__index_level_0__":2977}
+{"text":"**Contents**\n* TOC\n{:toc}\n## Fundamentals of Quantization","__index_level_0__":2978}
+{"text":"> If someone asks you what time it is, you don't respond \"10:14:34:430705\", but you might say \"a quarter past 10\".","__index_level_0__":2979}
+{"text":"Quantization has roots in information compression; in deep networks it refers to reducing the numerical precision of its weights and\/or activations. ","__index_level_0__":2980}
+{"text":"Overparameterized DNNs have more degrees of freedom and this makes them good candidates for information compression [[1]]. When you quantize a model, two things generally happen - the model gets smaller and runs with better efficiency. Hardware vendors explicitly allow for faster processing of 8-bit data (than 32-bit data) resulting in higher throughput. A smaller model has lower memory footprint and power consumption [[2]], crucial for deployment at the edge.","__index_level_0__":2981}
+{"text":"### Mapping function\nThe mapping function is what you might guess - a function that maps values from floating-point to integer space. A commonly used mapping function is a linear transformation given by <img src=\"https:\/\/latex.codecogs.com\/gif.latex?Q(r) = round(r\/S + Z)\">, where <img src=\"https:\/\/latex.codecogs.com\/gif.latex?r\"> is the input and <img src=\"https:\/\/latex.codecogs.com\/gif.latex?S, Z\"> are **quantization parameters**.","__index_level_0__":2982}
+{"text":"To reconvert to floating point space, the inverse function is given by <img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\tilde r = (Q(r) - Z) \\cdot S\">. ","__index_level_0__":2983}
+{"text":"<img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\tilde r \\neq r\">, and their difference constitutes the *quantization error*.","__index_level_0__":2984}
+{"text":"### Quantization Parameters\nThe mapping function is parameterized by the **scaling factor** <img src=\"https:\/\/latex.codecogs.com\/gif.latex?S\"> and **zero-point** <img src=\"https:\/\/latex.codecogs.com\/gif.latex?Z\">. ","__index_level_0__":2985}
+{"text":"<img src=\"https:\/\/latex.codecogs.com\/gif.latex?S\"> is simply the ratio of the input range to the output range \n<img src=\"https:\/\/latex.codecogs.com\/gif.latex?S = \\frac{\\beta - \\alpha}{\\beta_q - \\alpha_q}\">","__index_level_0__":2986}
+{"text":"where [<img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\alpha, \\beta\">] is the clipping range of the input, i.e. the boundaries of permissible inputs. [<img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\alpha_q, \\beta_q\">] is the range in quantized output space that it is mapped to. For 8-bit quantization, the output range <img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\beta_q - \\alpha_q <= (2^8 - 1)\">.","__index_level_0__":2987}
+{"text":"\n<img src=\"https:\/\/latex.codecogs.com\/gif.latex?Z\"> acts as a bias to ensure that a 0 in the input space maps perfectly to a 0 in the quantized space. <img src=\"https:\/\/latex.codecogs.com\/gif.latex?Z = -(\\frac{\\alpha}{S} - \\alpha_q)\">","__index_level_0__":2988}
+{"text":"### Calibration\nThe process of choosing the input clipping range is known as **calibration**. The simplest technique (also the default in PyTorch) is to record the running mininmum and maximum values and assign them to <img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\alpha\"> and <img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\beta\">. [TensorRT](https:\/\/docs.nvidia.com\/deeplearning\/tensorrt\/pytorch-quantization-toolkit\/docs\/calib.html) also uses entropy minimization (KL divergence), mean-square-error minimization, or percentiles of the input range. ","__index_level_0__":2990}
+{"text":"In PyTorch, `Observer` modules ([docs](https:\/\/PyTorch.org\/docs\/stable\/torch.quantization.html?highlight=observer#observers), [code](https:\/\/github.com\/PyTorch\/PyTorch\/blob\/748d9d24940cd17938df963456c90fa1a13f3932\/torch\/ao\/quantization\/observer.py#L88)) collect statistics on the input values and calculate the qparams <img src=\"https:\/\/latex.codecogs.com\/gif.latex?S, Z\">. Different calibration schemes result in different quantized outputs, and it's best to empirically verify which scheme works best for your application and architecture (more on that later).","__index_level_0__":2991}
+{"text":"```python\nfrom torch.quantization.observer import MinMaxObserver, MovingAverageMinMaxObserver, HistogramObserver\nC, L = 3, 4\nnormal = torch.distributions.normal.Normal(0,1)\ninputs = [normal.sample((C, L)), normal.sample((C, L))]\nprint(inputs)","__index_level_0__":2992}
+{"text":"# >>>>>\n# [tensor([[-0.0590,  1.1674,  0.7119, -1.1270],\n#          [-1.3974,  0.5077, -0.5601,  0.0683],\n#          [-0.0929,  0.9473,  0.7159, -0.4574]]]),","__index_level_0__":2993}
+{"text":"# tensor([[-0.0236, -0.7599,  1.0290,  0.8914],\n#          [-1.1727, -1.2556, -0.2271,  0.9568],\n#          [-0.2500,  1.4579,  1.4707,  0.4043]])]","__index_level_0__":2994}
+{"text":"observers = [MinMaxObserver(), MovingAverageMinMaxObserver(), HistogramObserver()]\nfor obs in observers:\n  for x in inputs: obs(x) \n  print(obs.__class__.__name__, obs.calculate_qparams())","__index_level_0__":2995}
+{"text":"# >>>>>\n# MinMaxObserver (tensor([0.0112]), tensor([124], dtype=torch.int32))\n# MovingAverageMinMaxObserver (tensor([0.0101]), tensor([139], dtype=torch.int32))\n# HistogramObserver (tensor([0.0100]), tensor([106], dtype=torch.int32))\n```","__index_level_0__":2996}
+{"text":"### Affine and Symmetric Quantization Schemes\n**Affine or asymmetric quantization** schemes assign the input range to the min and max observed values. Affine schemes generally offer tighter clipping ranges and are useful for quantizing non-negative activations (you don't need the input range to contain negative values if your input tensors are never negative). The range is calculated as \n<img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\alpha = min(r), \\beta = max(r)\">. Affine quantization leads to more computationally expensive inference when used for weight tensors [[3]].","__index_level_0__":2997}
+{"text":"**Symmetric quantization** schemes center the input range around 0, eliminating the need to calculate a zero-point offset. The range is calculated as \n<img src=\"https:\/\/latex.codecogs.com\/gif.latex?-\\alpha = \\beta = max(|max(r)|,|min(r)|)\">. For skewed signals (like non-negative activations) this can result in bad quantization resolution because the clipping range includes values that never show up in the input (see the pyplot below).","__index_level_0__":2998}
+{"text":"```python\nact =  torch.distributions.pareto.Pareto(1, 10).sample((1,1024))\nweights = torch.distributions.normal.Normal(0, 0.12).sample((3, 64, 7, 7)).flatten()","__index_level_0__":2999}
+{"text":"def get_symmetric_range(x):\n  beta = torch.max(x.max(), x.min().abs())\n  return -beta.item(), beta.item()","__index_level_0__":3000}
+{"text":"def get_affine_range(x):\n  return x.min().item(), x.max().item()","__index_level_0__":3001}
+{"text":"def plot(plt, data, scheme):\n  boundaries = get_affine_range(data) if scheme == 'affine' else get_symmetric_range(data)\n  a, _, _ = plt.hist(data, density=True, bins=100)\n  ymin, ymax = np.quantile(a[a>0], [0.25, 0.95])\n  plt.vlines(x=boundaries, ls='--', colors='purple', ymin=ymin, ymax=ymax)","__index_level_0__":3002}
+{"text":"fig, axs = plt.subplots(2,2)\nplot(axs[0, 0], act, 'affine')\naxs[0, 0].set_title(\"Activation, Affine-Quantized\")","__index_level_0__":3003}
+{"text":"plot(axs[0, 1], act, 'symmetric')\naxs[0, 1].set_title(\"Activation, Symmetric-Quantized\")","__index_level_0__":3004}
+{"text":"plot(axs[1, 0], weights, 'affine')\naxs[1, 0].set_title(\"Weights, Affine-Quantized\")","__index_level_0__":3005}
+{"text":"plot(axs[1, 1], weights, 'symmetric')\naxs[1, 1].set_title(\"Weights, Symmetric-Quantized\")\nplt.show()\n```","__index_level_0__":3006}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/quantization-practice\/affine-symmetric.png\" width=\"100%\">\n  <br> Fig 2. Clipping ranges (in purple) for affine and symmetric schemes\n<\/p>","__index_level_0__":3007}
+{"text":"\nIn PyTorch, you can specify affine or symmetric schemes while initializing the Observer. Note that not all observers support both schemes.","__index_level_0__":3008}
+{"text":"```python\nfor qscheme in [torch.per_tensor_affine, torch.per_tensor_symmetric]:\n  obs = MovingAverageMinMaxObserver(qscheme=qscheme)\n  for x in inputs: obs(x)\n  print(f\"Qscheme: {qscheme} | {obs.calculate_qparams()}\")","__index_level_0__":3009}
+{"text":"# >>>>>\n# Qscheme: torch.per_tensor_affine | (tensor([0.0101]), tensor([139], dtype=torch.int32))\n# Qscheme: torch.per_tensor_symmetric | (tensor([0.0109]), tensor([128]))\n```","__index_level_0__":3010}
+{"text":"### Per-Tensor and Per-Channel Quantization Schemes\nQuantization parameters can be calculated for the layer's entire weight tensor as a whole, or separately for each channel. In per-tensor, the same clipping range is applied to all the channels in a layer","__index_level_0__":3011}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/quantization-practice\/per-channel-tensor.svg\" width=\"60%\">\n  <br> Fig 3. Per-Channel uses one set of qparams for each channel. Per-tensor uses the same qparams for the entire tensor.\n<\/p>","__index_level_0__":3012}
+{"text":"For weights quantization, symmetric-per-channel quantization provides better accuracies; per-tensor quantization performs poorly, possibly due to high variance in conv weights across channels from batchnorm folding [[3]].","__index_level_0__":3013}
+{"text":"```python\nfrom torch.quantization.observer import MovingAveragePerChannelMinMaxObserver\nobs = MovingAveragePerChannelMinMaxObserver(ch_axis=0)  # calculate qparams for all `C` channels separately\nfor x in inputs: obs(x)\nprint(obs.calculate_qparams())","__index_level_0__":3014}
+{"text":"# >>>>>\n# (tensor([0.0090, 0.0075, 0.0055]), tensor([125, 187,  82], dtype=torch.int32))\n```","__index_level_0__":3015}
+{"text":"### Backend Engine\nCurrently, quantized operators run on x86 machines via the [FBGEMM backend](https:\/\/github.com\/pytorch\/FBGEMM), or use [QNNPACK](https:\/\/github.com\/pytorch\/QNNPACK) primitives on ARM machines. Backend support for server GPUs (via TensorRT and cuDNN) is coming soon. Learn more about extending quantization to custom backends: [RFC-0019](https:\/\/github.com\/pytorch\/rfcs\/blob\/master\/RFC-0019-Extending-PyTorch-Quantization-to-Custom-Backends.md).","__index_level_0__":3016}
+{"text":"```python\nbackend = 'fbgemm' if x86 else 'qnnpack'\nqconfig = torch.quantization.get_default_qconfig(backend)  \ntorch.backends.quantized.engine = backend\n```","__index_level_0__":3017}
+{"text":"\n### QConfig","__index_level_0__":3018}
+{"text":"The `QConfig` ([code](https:\/\/github.com\/PyTorch\/PyTorch\/blob\/d6b15bfcbdaff8eb73fa750ee47cef4ccee1cd92\/torch\/ao\/quantization\/qconfig.py#L165), [docs](https:\/\/pytorch.org\/docs\/stable\/torch.quantization.html?highlight=qconfig#torch.quantization.QConfig)) NamedTuple stores the Observers and the quantization schemes used to quantize activations and weights.","__index_level_0__":3019}
+{"text":"Be sure to pass the Observer class (not the instance), or a callable that can return Observer instances. Use `with_args()` to override the default arguments.","__index_level_0__":3020}
+{"text":"```python\nmy_qconfig = torch.quantization.QConfig(\n  activation=MovingAverageMinMaxObserver.with_args(qscheme=torch.per_tensor_affine),\n  weight=MovingAveragePerChannelMinMaxObserver.with_args(qscheme=torch.qint8)\n)\n# >>>>>\n# QConfig(activation=functools.partial(<class 'torch.ao.quantization.observer.MovingAverageMinMaxObserver'>, qscheme=torch.per_tensor_affine){}, weight=functools.partial(<class 'torch.ao.quantization.observer.MovingAveragePerChannelMinMaxObserver'>, qscheme=torch.qint8){})\n```","__index_level_0__":3021}
+{"text":"\n## In PyTorch","__index_level_0__":3022}
+{"text":"PyTorch allows you a few different ways to quantize your model depending on\n- if you prefer a flexible but manual, or a restricted automagic process (*Eager Mode* v\/s *FX Graph Mode*)\n- if qparams for quantizing activations (layer outputs) are precomputed for all inputs, or calculated afresh with each input (*static* v\/s *dynamic*),\n- if qparams are computed with or without retraining (*quantization-aware training* v\/s *post-training quantization*)","__index_level_0__":3023}
+{"text":"FX Graph Mode automatically fuses eligible modules, inserts Quant\/DeQuant stubs, calibrates the model and returns a quantized module - all in two method calls - but only for networks that are [symbolic traceable](https:\/\/PyTorch.org\/docs\/stable\/fx.html#torch.fx.symbolic_trace). The examples below contain the calls using Eager Mode and FX Graph Mode for comparison.","__index_level_0__":3024}
+{"text":"In DNNs, eligible candidates for quantization are the FP32 weights (layer parameters) and activations (layer outputs). Quantizing weights reduces the model size. Quantized activations typically result in faster inference.","__index_level_0__":3025}
+{"text":"As an example, the 50-layer ResNet network has ~26 million weight parameters and computes ~16 million activations in the forward pass.","__index_level_0__":3026}
+{"text":"### Post-Training Dynamic\/Weight-only Quantization \nHere the model's weights are pre-quantized; the activations are quantized on-the-fly (\"dynamic\") during inference. The simplest of all approaches, it has a one line API call in `torch.quantization.quantize_dynamic`. Currently only Linear and Recurrent (`LSTM`, `GRU`, `RNN`) layers are supported for dynamic quantization.","__index_level_0__":3027}
+{"text":" **(+)** Can result in higher accuracies since the clipping range is exactly calibrated for each input [[1]].\n \n **(+)** Dynamic quantization is preferred for models like LSTMs and Transformers where writing\/retrieving the model's weights from memory dominate bandwidths [[4]]. \n \n **(-)** Calibrating and quantizing the activations at each layer during runtime can add to the compute overhead. ","__index_level_0__":3028}
+{"text":"```python\nimport torch\nfrom torch import nn","__index_level_0__":3029}
+{"text":"# toy model\nm = nn.Sequential(\n  nn.Conv2d(2, 64, (8,)),\n  nn.ReLU(),\n  nn.Linear(16,10),\n  nn.LSTM(10, 10))","__index_level_0__":3030}
+{"text":"## EAGER MODE\nfrom torch.quantization import quantize_dynamic\nmodel_quantized = quantize_dynamic(\n    model=m, qconfig_spec={nn.LSTM, nn.Linear}, dtype=torch.qint8, inplace=False\n)","__index_level_0__":3032}
+{"text":"## FX MODE\nfrom torch.quantization import quantize_fx\nqconfig_dict = {\"\": torch.quantization.default_dynamic_qconfig}  # An empty key denotes the default applied to all modules\nmodel_prepared = quantize_fx.prepare_fx(m, qconfig_dict)\nmodel_quantized = quantize_fx.convert_fx(model_prepared)\n```","__index_level_0__":3033}
+{"text":"### Post-Training Static Quantization (PTQ)\nPTQ also pre-quantizes model weights but instead of calibrating activations on-the-fly, the clipping range is pre-calibrated and fixed (\"static\") using validation data. Activations stay in quantized precision between operations during inference. About 100 mini-batches of representative data are sufficient to calibrate the observers [[2]]. The examples below use random data in calibration for convenience - using that in your application will result in bad qparams.","__index_level_0__":3034}
+{"text":"\n<p align=\"center\">\n  <img src=\"\/assets\/images\/quantization-practice\/ptq-flowchart.svg\" alt=\"PTQ flowchart\" width=\"60%\">\n  <br>\n  Fig 4. Steps in Post-Training Static Quantization\n<\/p>","__index_level_0__":3035}
+{"text":"\n[Module fusion](https:\/\/pytorch.org\/tutorials\/recipes\/fuse.html) combines multiple sequential modules (eg: `[Conv2d, BatchNorm, ReLU]`) into one. Fusing modules means the compiler needs to only run one kernel instead of many; this speeds things up and improves accuracy by reducing quantization error.","__index_level_0__":3036}
+{"text":"**(+)** Static quantization has faster inference than dynamic quantization because it eliminates the float<->int conversion costs between layers. ","__index_level_0__":3037}
+{"text":"**(-)** Static quantized models may need regular re-calibration to stay robust against distribution-drift.","__index_level_0__":3038}
+{"text":"\n```python\n# Static quantization of a model consists of the following steps:","__index_level_0__":3039}
+{"text":"#     Fuse modules\n#     Insert Quant\/DeQuant Stubs\n#     Prepare the fused module (insert observers before and after layers)\n#     Calibrate the prepared module (pass it representative data)\n#     Convert the calibrated module (replace with quantized version)","__index_level_0__":3040}
+{"text":"import torch\nfrom torch import nn\nimport copy","__index_level_0__":3041}
+{"text":"backend = \"fbgemm\"  # running on a x86 CPU. Use \"qnnpack\" if running on ARM.","__index_level_0__":3042}
+{"text":"model = nn.Sequential(\n     nn.Conv2d(2,64,3),\n     nn.ReLU(),\n     nn.Conv2d(64, 128, 3),\n     nn.ReLU()\n)","__index_level_0__":3043}
+{"text":"## EAGER MODE\nm = copy.deepcopy(model)\nm.eval()\n\"\"\"Fuse\n- Inplace fusion replaces the first module in the sequence with the fused module, and the rest with identity modules\n\"\"\"\ntorch.quantization.fuse_modules(m, ['0','1'], inplace=True) # fuse first Conv-ReLU pair\ntorch.quantization.fuse_modules(m, ['2','3'], inplace=True) # fuse second Conv-ReLU pair","__index_level_0__":3044}
+{"text":"\"\"\"Insert stubs\"\"\"\nm = nn.Sequential(torch.quantization.QuantStub(), \n                  *m, \n                  torch.quantization.DeQuantStub())","__index_level_0__":3045}
+{"text":"\"\"\"Prepare\"\"\"\nm.qconfig = torch.quantization.get_default_qconfig(backend)\ntorch.quantization.prepare(m, inplace=True)","__index_level_0__":3046}
+{"text":"\"\"\"Calibrate\n- This example uses random data for convenience. Use representative (validation) data instead.\n\"\"\"\nwith torch.inference_mode():\n  for _ in range(10):\n    x = torch.rand(1,2, 28, 28)\n    m(x)\n    \n\"\"\"Convert\"\"\"\ntorch.quantization.convert(m, inplace=True)","__index_level_0__":3047}
+{"text":"\"\"\"Check\"\"\"\nprint(m[[1]].weight().element_size()) # 1 byte instead of 4 bytes for FP32","__index_level_0__":3048}
+{"text":"\n## FX GRAPH\nfrom torch.quantization import quantize_fx\nm = copy.deepcopy(model)\nm.eval()\nqconfig_dict = {\"\": torch.quantization.get_default_qconfig(backend)}\n# Prepare\nmodel_prepared = quantize_fx.prepare_fx(m, qconfig_dict)\n# Calibrate - Use representative (validation) data.\nwith torch.inference_mode():\n  for _ in range(10):\n    x = torch.rand(1,2,28, 28)\n    model_prepared(x)\n# quantize\nmodel_quantized = quantize_fx.convert_fx(model_prepared)\n```","__index_level_0__":3049}
+{"text":"### Quantization-aware Training (QAT)\n<p align=\"center\">\n  <img src=\"\/assets\/images\/quantization-practice\/qat-flowchart.svg\" alt=\"QAT flowchart\" width=\"60%\">\n  <br>\n  Fig 5. Steps in Quantization-Aware Training\n<\/p>","__index_level_0__":3050}
+{"text":"The PTQ approach is great for large models, but accuracy suffers in smaller models [[6]]. This is of course due to the loss in numerical precision when adapting a model from FP32 to the INT8 realm *(Figure 6(a))*. QAT tackles this by including this quantization error in the training loss, thereby training an INT8-first model.","__index_level_0__":3051}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/quantization-practice\/ptq_vs_qat.png\" alt=\"Fig. 6: Comparison of PTQ and QAT\" width=\"100%\">\n  <br>\n  Fig 6. Comparison of PTQ and QAT convergence [3]\n<\/p>","__index_level_0__":3052}
+{"text":"All weights and biases are stored in FP32, and backpropagation happens as usual. However in the forward pass, quantization is internally simulated via `FakeQuantize` modules. They are called fake because they quantize and immediately dequantize the data, adding quantization noise similar to what might be encountered during quantized inference. The final loss thus accounts for any expected quantization errors. Optimizing on this allows the model to identify a wider region in the loss function *(Figure 6(b))*, and identify FP32 parameters such that quantizing them to INT8 does not significantly affect accuracy.","__index_level_0__":3053}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/quantization-practice\/qat-fake-quantization.png\" alt=\"Fake Quantization in the forward and backward pass\" width=\"100%\">\n  <br> Fig 7. Fake Quantization in the forward and backward pass \n  <br> Image source: https:\/\/developer.nvidia.com\/blog\/achieving-fp32-accuracy-for-int8-inference-using-quantization-aware-training-with-tensorrt\n<\/p>","__index_level_0__":3054}
+{"text":"**(+)** QAT yields higher accuracies than PTQ.","__index_level_0__":3055}
+{"text":"**(+)** Qparams can be learned during model training for more fine-grained accuracy (see [LearnableFakeQuantize](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/ao\/quantization\/_learnable_fake_quantize.py))","__index_level_0__":3056}
+{"text":"**(-)** Computational cost of retraining a model in QAT can be several hundred epochs [[1]]","__index_level_0__":3057}
+{"text":"\n```python\n# QAT follows the same steps as PTQ, with the exception of the training loop before you actually convert the model to its quantized version","__index_level_0__":3058}
+{"text":"import torch\nfrom torch import nn","__index_level_0__":3059}
+{"text":"backend = \"fbgemm\"  # running on a x86 CPU. Use \"qnnpack\" if running on ARM.","__index_level_0__":3060}
+{"text":"m = nn.Sequential(\n     nn.Conv2d(2,64,8),\n     nn.ReLU(),\n     nn.Conv2d(64, 128, 8),\n     nn.ReLU()\n)","__index_level_0__":3061}
+{"text":"\"\"\"Fuse\"\"\"\ntorch.quantization.fuse_modules(m, ['0','1'], inplace=True) # fuse first Conv-ReLU pair\ntorch.quantization.fuse_modules(m, ['2','3'], inplace=True) # fuse second Conv-ReLU pair","__index_level_0__":3062}
+{"text":"\"\"\"Insert stubs\"\"\"\nm = nn.Sequential(torch.quantization.QuantStub(), \n                  *m, \n                  torch.quantization.DeQuantStub())","__index_level_0__":3063}
+{"text":"\"\"\"Prepare\"\"\"\nm.train()\nm.qconfig = torch.quantization.get_default_qconfig(backend)\ntorch.quantization.prepare_qat(m, inplace=True)","__index_level_0__":3064}
+{"text":"\"\"\"Training Loop\"\"\"\nn_epochs = 10\nopt = torch.optim.SGD(m.parameters(), lr=0.1)\nloss_fn = lambda out, tgt: torch.pow(tgt-out, 2).mean()\nfor epoch in range(n_epochs):\n  x = torch.rand(10,2,24,24)\n  out = m(x)\n  loss = loss_fn(out, torch.rand_like(out))\n  opt.zero_grad()\n  loss.backward()\n  opt.step()","__index_level_0__":3065}
+{"text":"\"\"\"Convert\"\"\"\nm.eval()\ntorch.quantization.convert(m, inplace=True)\n```","__index_level_0__":3066}
+{"text":"## Sensitivity Analysis\nNot all layers respond to quantization equally, some are more sensitive to precision drops than others. Identifying the optimal combination of layers that minimizes accuracy drop is time-consuming, so [[3]] suggest a one-at-a-time sensitivity analysis to identify which layers are most sensitive, and retaining FP32 precision on those. In their experiments, skipping just 2 conv layers (out of a total 28 in MobileNet v1) give them near-FP32 accuracy. Using FX Graph Mode, we can create custom qconfigs to do this easily:","__index_level_0__":3068}
+{"text":"```python\n# ONE-AT-A-TIME SENSITIVITY ANALYSIS ","__index_level_0__":3069}
+{"text":"for quantized_layer, _ in model.named_modules():\n  print(\"Only quantizing layer: \", quantized_layer)","__index_level_0__":3070}
+{"text":"  # The module_name key allows module-specific qconfigs. \n  qconfig_dict = {\"\": None, \n  \"module_name\":[(quantized_layer, torch.quantization.get_default_qconfig(backend))]}","__index_level_0__":3071}
+{"text":"  model_prepared = quantize_fx.prepare_fx(model, qconfig_dict)\n  # calibrate\n  model_quantized = quantize_fx.convert_fx(model_prepared)\n  # evaluate(model)\n```","__index_level_0__":3072}
+{"text":"Another approach is to compare statistics of the FP32 and INT8 layers; commonly used metrics for these are SQNR (Signal to Quantized Noise Ratio) and Mean-Squre-Error. Such a comparative analysis may also help in guiding further optimizations. ","__index_level_0__":3073}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/quantization-practice\/compare_output_ns.png\" alt=\"Fig 8. Comparing model weights and activations\" width=\"100%\" align=\"center\">\n  <br>\n  Fig 8. Comparing model weights and activations\n<\/p>","__index_level_0__":3074}
+{"text":"PyTorch provides tools to help with this analysis under the Numeric Suite. Learn more about using Numeric Suite from the [full tutorial](https:\/\/pytorch.org\/tutorials\/prototype\/numeric_suite_tutorial.html).","__index_level_0__":3075}
+{"text":"```python\n# extract from https:\/\/pytorch.org\/tutorials\/prototype\/numeric_suite_tutorial.html\nimport torch.quantization._numeric_suite as ns","__index_level_0__":3076}
+{"text":"def SQNR(x, y):\n    # Higher is better\n    Ps = torch.norm(x)\n    Pn = torch.norm(x-y)\n    return 20*torch.log10(Ps\/Pn)","__index_level_0__":3077}
+{"text":"wt_compare_dict = ns.compare_weights(fp32_model.state_dict(), int8_model.state_dict())\nfor key in wt_compare_dict:\n    print(key, compute_error(wt_compare_dict[key]['float'], wt_compare_dict[key]['quantized'].dequantize()))","__index_level_0__":3078}
+{"text":"act_compare_dict = ns.compare_model_outputs(fp32_model, int8_model, input_data)\nfor key in act_compare_dict:\n    print(key, compute_error(act_compare_dict[key]['float'][0], act_compare_dict[key]['quantized'][0].dequantize()))","__index_level_0__":3079}
+{"text":"\n## Recommendations for your workflow\n<p align=\"center\">\n  <img src=\"\/assets\/images\/quantization-practice\/quantization-flowchart2.png\" alt=\"Suggested quantization workflow\" width=\"100%\" align=\"center\">\n  <br>\n  Fig 9. Suggested quantization workflow\n<\/p>\n<a href=\"\/assets\/images\/quantization-practice\/quantization-flowchart2.png\" target=\"_blank\" align=\"center\"> Click for larger image <\/a>","__index_level_0__":3081}
+{"text":"### Points to note\n  - Large (10M+ parameters) models are more robust to quantization error. [[2]]\n  - Quantizing a model from a FP32 checkpoint provides better accuracy than training an INT8 model from scratch.[[2]]\n  - Profiling the model runtime is optional but it can help identify layers that bottleneck inference.\n  - Dynamic Quantization is an easy first step, especially if your model has many Linear or Recurrent layers.\n  - Use symmetric-per-channel quantization with `MinMax` observers for quantizing weights. Use affine-per-tensor quantization with `MovingAverageMinMax` observers for quantizing activations[[2], [3]]\n  - Use metrics like SQNR to identify which layers are most suscpetible to quantization error. Turn off quantization on these layers.\n  - Use QAT to fine-tune for around 10% of the original training schedule with an annealing learning rate schedule starting at 1% of the initial training learning rate. [[3]]\n  - If the above workflow didn't work for you, we want to know more. Post a thread with details of your code (model architecture, accuracy metric, techniques tried). Feel free to cc me [@suraj.pt](https:\/\/discuss.pytorch.org\/u\/suraj.pt\/).","__index_level_0__":3082}
+{"text":"  \nThat was a lot to digest, congratulations for sticking with it! Next, we'll take a look at quantizing a \"real-world\" model that uses dynamic control structures (if-else, loops). These elements disallow symbolic tracing a model, which makes it a bit tricky to directly quantize the model out of the box. In the next post of this series, we'll get our hands dirty on a model that is chock full of loops and if-else blocks, and even uses third-party libraries in the `forward` call. ","__index_level_0__":3083}
+{"text":"We'll also cover a cool new feature in PyTorch Quantization called Define-by-Run, that tries to ease this constraint by needing only subsets of the model's computational graph to be free of dynamic flow. Check out the [Define-by-Run poster at PTDD'21](https:\/\/s3.amazonaws.com\/assets.pytorch.org\/ptdd2021\/posters\/C8.png) for a preview.","__index_level_0__":3084}
+{"text":"\n## References\n[[1]] Gholami, A., Kim, S., Dong, Z., Yao, Z., Mahoney, M. W., & Keutzer, K. (2021). A survey of quantization methods for efficient neural network inference. arXiv preprint arXiv:2103.13630.","__index_level_0__":3085}
+{"text":"[[2]] Krishnamoorthi, R. (2018). Quantizing deep convolutional networks for efficient inference: A whitepaper. arXiv preprint arXiv:1806.08342.","__index_level_0__":3086}
+{"text":"[[3]] Wu, H., Judd, P., Zhang, X., Isaev, M., & Micikevicius, P. (2020). Integer quantization for deep learning inference: Principles and empirical evaluation. arXiv preprint arXiv:2004.09602.","__index_level_0__":3087}
+{"text":"[[4]] PyTorch Quantization Docs","__index_level_0__":3088}
+{"text":"\n[1]: https:\/\/arxiv.org\/pdf\/2103.13630.pdf\n[2]: https:\/\/arxiv.org\/pdf\/1806.08342.pdf\n[3]: https:\/\/arxiv.org\/abs\/2004.09602\n[4]: https:\/\/pytorch.org\/docs\/stable\/quantization.html#prototype-fx-graph-mode-quantization\n \n source: https:\/\/pytorch.org\/blog\/quantization-in-practice\/ \n category: pytorch blogs","__index_level_0__":3089}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Towards Reproducible Research with PyTorch Hub'\nauthor: Team PyTorch\nredirect_from: \/2019\/06\/10\/pytorch_hub.html\n---","__index_level_0__":3090}
+{"text":"Reproducibility is an essential requirement for many fields of research including those based on machine learning techniques. However, many machine learning publications are either not reproducible or are difficult to reproduce. With the continued growth in the number of research publications, including tens of thousands of papers now hosted on arXiv and submissions to conferences at an all time high, research reproducibility is more important than ever. While many of these publications are accompanied by code as well as trained models which is helpful but still leaves a number of steps for users to figure out for themselves.","__index_level_0__":3091}
+{"text":"We are excited to announce the availability of PyTorch Hub, a simple API and workflow that provides the basic building blocks for improving machine learning research reproducibility. PyTorch Hub consists of a pre-trained model repository designed specifically to facilitate research reproducibility and enable new research. It also has built-in support for [Colab](https:\/\/colab.research.google.com\/), integration with [*Papers With Code*](https:\/\/paperswithcode.com\/) and currently contains a broad set of models that include Classification and Segmentation, Generative, Transformers, etc.","__index_level_0__":3092}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/hub-blog-header-1.png\" width=\"100%\">\n<\/div>","__index_level_0__":3093}
+{"text":"## [Owner] Publishing models","__index_level_0__":3094}
+{"text":"PyTorch Hub supports the publication of pre-trained models (model definitions and pre-trained weights) to a GitHub repository by adding a simple ```hubconf.py``` file.\nThis provides an enumeration of which models are to be supported and a list of dependencies needed to run the models.\nExamples can be found in the [torchvision](https:\/\/github.com\/pytorch\/vision\/blob\/master\/hubconf.py), [huggingface-bert](https:\/\/github.com\/huggingface\/pytorch-pretrained-BERT\/blob\/master\/hubconf.py) and [gan-model-zoo](https:\/\/github.com\/facebookresearch\/pytorch_GAN_zoo) repositories.","__index_level_0__":3095}
+{"text":"Let us look at the simplest case: `torchvision`'s `hubconf.py`:","__index_level_0__":3096}
+{"text":"```python\n# Optional list of dependencies required by the package\ndependencies = ['torch']","__index_level_0__":3097}
+{"text":"from torchvision.models.alexnet import alexnet\nfrom torchvision.models.densenet import densenet121, densenet169, densenet201, densenet161\nfrom torchvision.models.inception import inception_v3\nfrom torchvision.models.resnet import resnet18, resnet34, resnet50, resnet101, resnet152,\\\nresnext50_32x4d, resnext101_32x8d\nfrom torchvision.models.squeezenet import squeezenet1_0, squeezenet1_1\nfrom torchvision.models.vgg import vgg11, vgg13, vgg16, vgg19, vgg11_bn, vgg13_bn, vgg16_bn, vgg19_bn\nfrom torchvision.models.segmentation import fcn_resnet101, deeplabv3_resnet101\nfrom torchvision.models.googlenet import googlenet\nfrom torchvision.models.shufflenetv2 import shufflenet_v2_x0_5, shufflenet_v2_x1_0\nfrom torchvision.models.mobilenet import mobilenet_v2\n```","__index_level_0__":3098}
+{"text":"In `torchvision`, the models have the following properties:\n- Each model file can function and be executed independently\n- They dont require any package other than PyTorch (encoded in `hubconf.py` as `dependencies['torch']`)\n- They dont need separate entry-points, because the models when created, work seamlessly out of the box","__index_level_0__":3099}
+{"text":"Minimizing package dependencies reduces the friction for users to load your model for immediate experimentation.","__index_level_0__":3100}
+{"text":"A more involved example is HuggingFace's BERT models. Here is their `hubconf.py`","__index_level_0__":3101}
+{"text":"```python\ndependencies = ['torch', 'tqdm', 'boto3', 'requests', 'regex']","__index_level_0__":3102}
+{"text":"from hubconfs.bert_hubconf import (\n    bertTokenizer,\n    bertModel,\n    bertForNextSentencePrediction,\n    bertForPreTraining,\n    bertForMaskedLM,\n    bertForSequenceClassification,\n    bertForMultipleChoice,\n    bertForQuestionAnswering,\n    bertForTokenClassification\n)\n```","__index_level_0__":3103}
+{"text":"Each model then requires an entrypoint to be created. Here is a code snippet to specify an entrypoint of the ```bertForMaskedLM``` model, which returns the pre-trained model weights.","__index_level_0__":3104}
+{"text":"```python\ndef bertForMaskedLM(*args, **kwargs):\n    \"\"\"\n    BertForMaskedLM includes the BertModel Transformer followed by the\n    pre-trained masked language modeling head.\n    Example:\n      ...\n    \"\"\"\n    model = BertForMaskedLM.from_pretrained(*args, **kwargs)\n    return model\n```","__index_level_0__":3105}
+{"text":"These entry-points can serve as wrappers around complex model factories. They can give a clean and consistent help docstring, have logic to support downloading of pretrained weights (for example via `pretrained=True`) or have additional hub-specific functionality such as visualization.","__index_level_0__":3106}
+{"text":"With a `hubconf.py` in place, you can send a pull request based on the template [here](https:\/\/github.com\/pytorch\/hub\/blob\/master\/docs\/template.md).\nOur goal is to curate high-quality, easily-reproducible, maximally-beneficial models for research reproducibility.\nHence, we may work with you to refine your pull request and in some cases reject some low-quality models to be published.\nOnce we accept your pull request, your model will soon appear on [Pytorch hub webpage](https:\/\/pytorch.org\/hub) for all users to explore.","__index_level_0__":3107}
+{"text":"\n## [User] Workflow","__index_level_0__":3108}
+{"text":"As a user, PyTorch Hub allows you to follow a few simple steps and do things like: 1) explore available models; 2) load a model; and 3) understand what methods are available for any given model. Let's walk through some examples of each.","__index_level_0__":3109}
+{"text":"### Explore available entrypoints.","__index_level_0__":3110}
+{"text":"Users can list all available entrypoints in a repo using the ```torch.hub.list()``` API.","__index_level_0__":3111}
+{"text":"```python\n>>> torch.hub.list('pytorch\/vision')\n>>>\n['alexnet',\n'deeplabv3_resnet101',\n'densenet121',\n...\n'vgg16',\n'vgg16_bn',\n'vgg19',\n 'vgg19_bn']\n ```","__index_level_0__":3112}
+{"text":"Note that PyTorch Hub also allows auxillary entrypoints (other than pretrained models), e.g. ```bertTokenizer``` for preprocessing in the [BERT](https:\/\/pytorch.org\/hub\/huggingface_pytorch-pretrained-bert_bert\/) models, to make the user workflow smoother.","__index_level_0__":3113}
+{"text":"\n### Load a model","__index_level_0__":3114}
+{"text":"Now that we know which models are available in the Hub, users can load a model entrypoint using the ```torch.hub.load()``` API. This only requires a single command without the need to install a wheel. In addition the ```torch.hub.help()``` API can provide useful information about how to instantiate the model.","__index_level_0__":3115}
+{"text":"```python\nprint(torch.hub.help('pytorch\/vision', 'deeplabv3_resnet101'))\nmodel = torch.hub.load('pytorch\/vision', 'deeplabv3_resnet101', pretrained=True)\n```","__index_level_0__":3116}
+{"text":"It is also common that repo owners will want to continually add bug fixes or performance improvements. PyTorch Hub makes it super simple for users to get the latest update by calling:","__index_level_0__":3117}
+{"text":"```python\nmodel = torch.hub.load(..., force_reload=True)\n```","__index_level_0__":3118}
+{"text":"We believe this will help to alleviate the burden of repetitive package releases by repo owners and instead allow them to focus more on their research.\nIt also ensures that, as a user, you are getting the freshest available models.","__index_level_0__":3119}
+{"text":"On the contrary, stability is important for users. Hence, some model owners serve them from a specificed branch or tag, rather than the `master` branch, to ensure stability of the code.\nFor example, `pytorch_GAN_zoo` serves them from the `hub` branch:","__index_level_0__":3120}
+{"text":"```python\nmodel = torch.hub.load('facebookresearch\/pytorch_GAN_zoo:hub', 'DCGAN', pretrained=True, useGPU=False)\n```","__index_level_0__":3121}
+{"text":"Note that the ```*args```, ```**kwargs``` passed to `hub.load()` are used to *instantiate* a model. In the above example, `pretrained=True` and `useGPU=False` are given to the model's entrypoint.","__index_level_0__":3122}
+{"text":"\n### Explore a loaded model","__index_level_0__":3123}
+{"text":"Once you have a model from PyTorch Hub loaded, you can use the following workflow to find out the available methods that are supported as well as understand better what arguments are requires to run it.","__index_level_0__":3124}
+{"text":"\n```dir(model)``` to see all available methods of the model. Let's take a look at `bertForMaskedLM`'s available methods.","__index_level_0__":3125}
+{"text":"```python\n>>> dir(model)\n>>>\n['forward'\n...\n'to'\n'state_dict',\n]\n```","__index_level_0__":3126}
+{"text":"```help(model.forward)``` provides a view into what arguments are required to make your loaded model run","__index_level_0__":3127}
+{"text":"```python\n>>> help(model.forward)\n>>>\nHelp on method forward in module pytorch_pretrained_bert.modeling:\nforward(input_ids, token_type_ids=None, attention_mask=None, masked_lm_labels=None)\n...\n```","__index_level_0__":3128}
+{"text":"Have a closer look at the [BERT](https:\/\/pytorch.org\/hub\/huggingface_pytorch-pretrained-bert_bert\/) and [DeepLabV3](https:\/\/pytorch.org\/hub\/pytorch_vision_deeplabv3_resnet101\/) pages, where you can see how these models can be used once loaded.","__index_level_0__":3129}
+{"text":"### Other ways to explore","__index_level_0__":3130}
+{"text":"Models available in PyTorch Hub also support both [Colab](https:\/\/colab.research.google.com\/github\/pytorch\/pytorch.github.io\/blob\/master\/assets\/hub\/facebookresearch_pytorch-gan-zoo_pgan.ipynb) and are directly linked on [Papers With Code](https:\/\/paperswithcode.com\/) and you can get started with a single click. [Here](https:\/\/paperswithcode.com\/paper\/densely-connected-convolutional-networks) is a good example to get started with (shown below).","__index_level_0__":3131}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/hub-blog-pwc.png\" width=\"100%\">\n<\/div>","__index_level_0__":3132}
+{"text":"## Additional resources:","__index_level_0__":3133}
+{"text":"* PyTorch Hub API documentation can be found [here](https:\/\/pytorch.org\/docs\/stable\/hub.html).\n* Submit a model [here](https:\/\/github.com\/pytorch\/hub) for publication in PyTorch Hub.\n* Go to [https:\/\/pytorch.org\/hub](https:\/\/pytorch.org\/hub) to learn more about the available models.\n* Look for more models to come on [paperswithcode.com](https:\/\/paperswithcode.com\/).","__index_level_0__":3134}
+{"text":"\nA BIG thanks to the folks at HuggingFace, the PapersWithCode team, fast.ai and Nvidia as well as Morgane Riviere (FAIR Paris) and lots of others for helping bootstrap this effort!!","__index_level_0__":3135}
+{"text":"Team PyTorch","__index_level_0__":3137}
+{"text":"**Q: If we would like to contribute a model that is already in the Hub but perhaps mine has better accuracy, should I still contribute?**","__index_level_0__":3140}
+{"text":"\nA: Yes!! A next step for Hub is to implement an upvote\/downvote system to surface the best models.","__index_level_0__":3141}
+{"text":"**Q: Who hosts the model weights for PyTorch Hub?**","__index_level_0__":3142}
+{"text":"\nA: You, as the contributor, are responsible to host the model weights. You can host your model in your favorite cloud storage or, if it fits within the limits, on GitHub. If it is not within your means to host the weights, check with us via opening an issue on the hub repository.","__index_level_0__":3143}
+{"text":"**Q: What if my model is trained on private data? Should I still contribute this model?**","__index_level_0__":3144}
+{"text":"\nA: No! PyTorch Hub is centered around open research and that extends to the usage of open datasets to train these models on. If a pull request for a proprietary model is submitted, we will kindly ask that you resubmit a model trained on something open and available.","__index_level_0__":3145}
+{"text":"**Q: Where are my downloaded models saved?**","__index_level_0__":3146}
+{"text":"\nA: We follow the [XDG Base Directory Specification](https:\/\/specifications.freedesktop.org\/basedir-spec\/basedir-spec-latest.html) and adhere to common standards around cached files and directories.","__index_level_0__":3147}
+{"text":"The locations are used in the order of:","__index_level_0__":3148}
+{"text":"* Calling ```hub.set_dir(<PATH_TO_HUB_DIR>)```\n* ```$TORCH_HOME\/hub```, if environment variable ```TORCH_HOME``` is set.\n* ```$XDG_CACHE_HOME\/torch\/hub```, if environment variable ```XDG_CACHE_HOME``` is set.\n* ```~\/.cache\/torch\/hub```\n \n source: https:\/\/pytorch.org\/blog\/towards-reproducible-research-with-pytorch-hub\/ \n category: pytorch blogs","__index_level_0__":3149}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'The road to 1.0: production ready PyTorch'\nauthor: The PyTorch Team\nredirect_from: \/2018\/05\/02\/road-to-1.0.html\n---","__index_level_0__":3150}
+{"text":"We would like to give you a preview of the roadmap for PyTorch 1.0 , the next release of PyTorch. Over the last year, we've had 0.2, 0.3 and 0.4 transform PyTorch from a [Torch+Chainer]-like interface into something cleaner, adding double-backwards, numpy-like functions, advanced indexing and removing Variable boilerplate. At this time, we're confident that the API is in a reasonable and stable state to confidently release a 1.0.","__index_level_0__":3151}
+{"text":"However, 1.0 isn't just about stability of the interface.","__index_level_0__":3152}
+{"text":"One of PyTorch's biggest strengths is its first-class Python integration, imperative style, simplicity of the API and options. These are aspects that make PyTorch good for research and hackability.","__index_level_0__":3153}
+{"text":"One of its biggest downsides has been production-support. What we mean by production-support is the countless things one has to do to models to run them efficiently at massive scale:","__index_level_0__":3154}
+{"text":"- exporting to C++-only runtimes for use in larger projects\n- optimizing mobile systems on iPhone, Android, Qualcomm and other systems\n- using more efficient data layouts and performing kernel fusion to do faster inference (saving 10% of speed or memory at scale is a big win)\n- quantized inference (such as 8-bit inference)","__index_level_0__":3155}
+{"text":"Startups, large companies and anyone who wants to build a product around PyTorch have asked for production support. At Facebook (the largest stakeholder for PyTorch) we have Caffe2, which has been the production-ready platform, running in our datacenters and shipping to more than 1 billion phones spanning eight generations of iPhones and six generations of Android CPU architectures. It has server-optimized inference on Intel \/ ARM, TensorRT support, and all the necessary bits for production. Considering all this value locked-in to a platform that the PyTorch team works quite closely with, **we decided to marry PyTorch and Caffe2 which gives the production-level readiness for PyTorch**.","__index_level_0__":3156}
+{"text":"Supporting production features without adding usability issues for our researchers and end-users needs creative solutions.","__index_level_0__":3157}
+{"text":"## Production != Pain for researchers","__index_level_0__":3158}
+{"text":"Adding production capabilities involves increasing the API complexity and number of configurable options for models. One configures memory-layouts (NCHW vs NHWC vs N,C\/32,H,W,32, each providing different performance characteristics), quantization (8-bit? 3-bit?), fusion of low-level kernels (you used a Conv + BatchNorm + ReLU, let's fuse them into a single kernel), separate backend options (MKLDNN backend for a few layers and NNPACK backend for other layers), etc.","__index_level_0__":3159}
+{"text":"PyTorch's central goal is to provide a great platform for research and hackability. So, while we add all these optimizations, we've been working with a hard design constraint to never trade these off against usability.","__index_level_0__":3160}
+{"text":"To pull this off, we are introducing `torch.jit`, a just-in-time (JIT) compiler that at runtime takes your PyTorch models and rewrites them to run at production-efficiency. The JIT compiler can also export your model to run in a C++-only runtime based on Caffe2 bits.","__index_level_0__":3161}
+{"text":"> In 1.0, your code continues to work as-is, we're not making any big changes to the existing API.","__index_level_0__":3162}
+{"text":"Making your model production-ready is an opt-in annotation, which uses the `torch.jit` compiler to export your model to a Python-less environment, and improving its performance. Let's walk through the JIT compiler in detail.","__index_level_0__":3163}
+{"text":"## `torch.jit`: A JIT-compiler for your models","__index_level_0__":3164}
+{"text":"We strongly believe that it's hard to match the productivity you get from specifying your models directly as idiomatic Python code. This is what makes PyTorch so flexible, but it also means that PyTorch pretty much never knows the operation you'll run next. This however is a big blocker for export\/productionization and heavyweight automatic performance optimizations because they need full upfront knowledge of how the computation will look before it even gets executed.","__index_level_0__":3165}
+{"text":"We provide two opt-in ways of recovering this information from your code, one based on tracing native python code and one based on compiling a subset of the python language annotated into a python-free intermediate representation. After thorough discussions we concluded that they're both going to be useful in different contexts, and as such you will be able to mix and match them freely.","__index_level_0__":3166}
+{"text":"## Tracing Mode","__index_level_0__":3167}
+{"text":"The PyTorch tracer, `torch.jit.trace`, is a function that records all the native PyTorch operations performed in a code region, along with the data dependencies between them. In fact, PyTorch has had a tracer since 0.3, which has been used for exporting models through ONNX. What changes now, is that you no longer necessarily need to take the trace and run it elsewhere - PyTorch can re-execute it for you, using a carefully designed high-performance C++ runtime. As we develop PyTorch 1.0 this runtime will integrate all the optimizations and hardware integrations that Caffe2 provides.","__index_level_0__":3168}
+{"text":"The biggest benefit of this approach is that it doesn't really care how your Python code is structured \u2014 you can trace through generators or coroutines, modules or pure functions. Since we only record native PyTorch operators, these details have no effect on the trace recorded. This behavior, however, is a double-edged sword. For example, if you have a loop in your model, it will get unrolled in the trace, inserting a copy of the loop body for as many times as the loop ran. This opens up opportunities for zero-cost abstraction (e.g. you can loop over modules, and the actual trace will be loop-overhead free!), but on the other hand this will also affect data dependent loops (think of e.g. processing sequences of varying lengths), effectively hard-coding a single length into the trace.","__index_level_0__":3169}
+{"text":"For networks that do not contain loops and if statements, tracing is non-invasive and is robust enough to handle a wide variety of coding styles. This code example illustrates what tracing looks like:","__index_level_0__":3170}
+{"text":"```python\n# This will run your nn.Module or regular Python function with the example\n# input that you provided. The returned callable can be used to re-execute\n# all operations that happened during the example run, but it will no longer\n# use the Python interpreter.\nfrom torch.jit import trace\ntraced_model = trace(model, example_input=input)\ntraced_fn = trace(fn, example_input=input)","__index_level_0__":3171}
+{"text":"# The training loop doesn't change. Traced model behaves exactly like an\n# nn.Module, except that you can't edit what it does or change its attributes.\n# Think of it as a \"frozen module\".\nfor input, target in data_loader:\n    loss = loss_fn(traced_model(input), target)\n```","__index_level_0__":3172}
+{"text":"## Script Mode","__index_level_0__":3173}
+{"text":"Tracing mode is a great way to minimize the impact on your code, but we're also very excited about the models that fundamentally make use of control flow such as RNNs. Our solution to this is a scripting mode.","__index_level_0__":3174}
+{"text":"In this case you write out a regular Python function, except that you can no longer use certain more complicated language features. Once you isolated the desired functionality, you let us know that you'd like the function to get compiled by decorating it with an `@script` decorator. This annotation will transform your python function directly into our high-performance C++ runtime. This lets us recover all the PyTorch operations along with loops and conditionals. They will be embedded into our internal representation of this function, and will be accounted for every time this function is run.","__index_level_0__":3175}
+{"text":"```python\nfrom torch.jit import script","__index_level_0__":3176}
+{"text":"@script\ndef rnn_loop(x):\n    hidden = None\n    for x_t in x.split(1):\n        x, hidden = model(x, hidden)\n    return x\n```","__index_level_0__":3177}
+{"text":"## Optimization and Export","__index_level_0__":3178}
+{"text":"Regardless of whether you use tracing or `@script`, the result is a python-free representation of your model, which can be used to optimize the model or to export the model from python for use in production environments.","__index_level_0__":3179}
+{"text":"Extracting bigger segments of the model into an intermediate representation makes it possible to do sophisticated whole-program optimizations and to offload computation to specialized AI accelerators which operate on graphs of computation. We have already been developing the beginnings of these optimizations, including passes that fuse GPU operations together to improve the performance of smaller RNN models.","__index_level_0__":3180}
+{"text":"It also allows us to use existing high-performance backends available in Caffe2 today to run the model efficiently. Additionally, @script functions (and modules!) can be fully exported to ONNX in a way that retains their dynamic nature, such that you can easily run them in a Python-free environment using the model executors from Caffe2 or by transferring the model to any other framework supporting ONNX.","__index_level_0__":3181}
+{"text":"## Usability","__index_level_0__":3182}
+{"text":"**We care deeply about maintaining our current level of usability and we know that execution of the code not directly in Python leads to harder debugging, but this is something that we think about a lot, and we're making sure that you're not getting locked in to a completely different programming language.**","__index_level_0__":3183}
+{"text":"First, we follow the principle of pay for what you use \u2014 if you don't need to optimize or export your model, you do not have to use these new features and won't see any downsides. Furthermore, use of traced or @script modules\/functions can be done incrementally. For instance, all of these behaviors are allowed: You can trace part of your model and use the trace in a larger non-traced model. You can use tracing for 90% of your model, and use @script for the one sub-module that actually has some control flow in it. You can write a function using @script and have it call a native python function. If something appears incorrect in an @script function, you can remove the annotation and the code will execute in native python where it is easy to debug using your favorite tools and methods. Think of tracing and @script like type annotations using MyPy or TypeScript \u2014 each additional annotation can be tested incrementally, and none are required until you want to optimize or productionize.","__index_level_0__":3184}
+{"text":"Most importantly, these modes will be built into the core of PyTorch so that mixing and matching them with your existing code can happen seamlessly.","__index_level_0__":3185}
+{"text":"_Note: The name JIT for these components is a bit of a misnomer and comes from historical reasons. The tracing\/function execution in PyTorch started out as an optimizing JIT compiler that generated fused CUDA kernels but then grew to encompass optimization, @script, and export. When it is ready for release we will likely rename this functionality to the hybrid frontend, but we wanted to present it here as it is named in the code so that you can follow along as we develop it._","__index_level_0__":3186}
+{"text":"## Other changes and improvements","__index_level_0__":3187}
+{"text":"Production support is the big feature for 1.0, but we will continue optimizing and fixing other parts of PyTorch as course of the standard release process.","__index_level_0__":3188}
+{"text":"On the backend side of things, PyTorch will see some changes, which might affect user-written C and C++ extensions. We are replacing (or refactoring) the backend ATen library to incorporate features and optimizations from Caffe2.","__index_level_0__":3189}
+{"text":"## Last Words","__index_level_0__":3190}
+{"text":"We aim to release 1.0 some time during the summer. You can follow-along our progress on the [Pull Requests](https:\/\/github.com\/pytorch\/pytorch\/pulls) page.","__index_level_0__":3191}
+{"text":"You can read this from the perspective of the Caffe2 project at: [https:\/\/caffe2.ai\/blog\/2018\/05\/02\/Caffe2_PyTorch_1_0.html](https:\/\/caffe2.ai\/blog\/2018\/05\/02\/Caffe2_PyTorch_1_0.html)\n \n source: https:\/\/pytorch.org\/blog\/the-road-to-1_0\/ \n category: pytorch blogs","__index_level_0__":3192}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch adds new tools and libraries, welcomes Preferred Networks to its community'\nauthor: Team PyTorch\n---","__index_level_0__":3193}
+{"text":"PyTorch continues to be used for the latest state-of-the-art research on display at the NeurIPS conference next week, making up nearly [70% of papers](https:\/\/chillee.github.io\/pytorch-vs-tensorflow\/) that cite a framework. In addition, we\u2019re excited to welcome Preferred Networks, the maintainers of the Chainer framework, to the PyTorch community. Their teams are moving fully over to PyTorch for developing their ML capabilities and services.","__index_level_0__":3194}
+{"text":"This growth underpins PyTorch\u2019s focus on building for the needs of the research community, and increasingly, supporting the full workflow from research to production deployment. To further support researchers and developers, we\u2019re launching a number of new tools and libraries for large scale computer vision and elastic fault tolerant training. Learn more on GitHub and at our NeurIPS booth.","__index_level_0__":3195}
+{"text":"## Preferred Networks joins the PyTorch community","__index_level_0__":3196}
+{"text":"Preferred Networks, Inc. (PFN) announced plans to move its deep learning framework from Chainer to PyTorch. As part of this change, PFN will collaborate with the PyTorch community and contributors, including people from Facebook, Microsoft, CMU, and NYU, to participate in the development of PyTorch.","__index_level_0__":3197}
+{"text":"PFN developed Chainer, a deep learning framework that introduced the concept of define-by-run (also referred to as eager execution), to support and speed up its deep learning development. Chainer has been used at PFN since 2015 to rapidly solve real-world problems with the latest, cutting-edge technology. Chainer was also one of the inspirations for PyTorch\u2019s initial design, as outlined in the [PyTorch NeurIPS](https:\/\/papers.nips.cc\/paper\/9015-pytorch-an-imperative-style-high-performance-deep-learning-library) paper.","__index_level_0__":3198}
+{"text":"PFN has driven innovative work with [CuPy](https:\/\/cupy.chainer.org\/), ImageNet in 15 minutes, [Optuna](https:\/\/optuna.org\/), and other projects that have pushed the boundaries of design and engineering. As part of the PyTorch community, PFN brings with them creative engineering capabilities and experience to help take the framework forward. In addition, PFN\u2019s migration to PyTorch will allow it to efficiently incorporate the latest research results to accelerate its R&D activities, [given PyTorch\u2019s broad adoption with researchers](https:\/\/thegradient.pub\/state-of-ml-frameworks-2019-pytorch-dominates-research-tensorflow-dominates-industry\/), and to collaborate with the community to add support for PyTorch on MN-Core, a deep learning processor currently in development.","__index_level_0__":3199}
+{"text":"We are excited to welcome PFN to the PyTorch community, and to jointly work towards the common goal of furthering advances in deep learning technology. Learn more about the PFN\u2019s migration to PyTorch [here](https:\/\/preferred.jp\/en\/news\/pr20191205\/).","__index_level_0__":3200}
+{"text":"## Tools for elastic training and large scale computer vision","__index_level_0__":3201}
+{"text":"### PyTorch Elastic (Experimental)","__index_level_0__":3202}
+{"text":"Large scale model training is becoming commonplace with architectures like BERT and the growth of model parameter counts into the billions or even tens of billions. To achieve convergence at this scale in a reasonable amount of time, the use of distributed training is needed.","__index_level_0__":3203}
+{"text":"The current PyTorch Distributed Data Parallel (DDP) module enables data parallel training where each process trains the same model but on different shards of data. It enables bulk synchronous, multi-host, multi-GPU\/CPU execution of ML training. However, DDP has several shortcomings; e.g. jobs cannot start without acquiring all the requested nodes; jobs cannot continue after a node fails due to error or transient issue; jobs cannot incorporate a node that joined later; and lastly; progress cannot be made with the presence of a slow\/stuck node.","__index_level_0__":3204}
+{"text":"The focus of [PyTorch Elastic](https:\/\/github.com\/pytorch\/elastic), which uses Elastic Distributed Data Parallelism, is to address these issues and build a generic framework\/APIs for PyTorch to enable reliable and elastic execution of these data parallel training workloads. It will provide better programmability, higher resilience to failures of all kinds, higher-efficiency and larger-scale training compared with pure DDP.","__index_level_0__":3205}
+{"text":"Elasticity, in this case, means both: 1) the ability for a job to continue after node failure (by running with fewer nodes and\/or by incorporating a new host and transferring state to it); and 2) the ability to add\/remove nodes dynamically due to resource availability changes or bottlenecks.","__index_level_0__":3206}
+{"text":"While this feature is still experimental, you can try it out on AWS EC2, with the instructions [here](https:\/\/github.com\/pytorch\/elastic\/tree\/master\/aws). Additionally, the PyTorch distributed team is working closely with teams across AWS to support PyTorch Elastic training within services such as Amazon Sagemaker and Elastic Kubernetes Service (EKS). Look for additional updates in the near future.","__index_level_0__":3207}
+{"text":"### New Classification Framework","__index_level_0__":3208}
+{"text":"Image and video classification are at the core of content understanding. To that end, you can now leverage a new end-to-end framework for large-scale training of state-of-the-art image and video classification models. It allows researchers to quickly prototype and iterate on large distributed training jobs at the scale of billions of images. Advantages include:","__index_level_0__":3209}
+{"text":"* Ease of use - This framework features a modular, flexible design that allows anyone to train machine learning models on top of PyTorch using very simple abstractions. The system also has out-of-the-box integration with AWS on PyTorch Elastic, facilitating research at scale and making it simple to move between research and production.\n* High performance - Researchers can use the framework to train models such as Resnet50 on ImageNet in as little as 15 minutes.","__index_level_0__":3210}
+{"text":"You can learn more at the [NeurIPS Expo workshop](https:\/\/nips.cc\/ExpoConferences\/2019\/schedule?workshop_id=16) on Multi-Modal research to production or get started with the PyTorch Elastic Imagenet example [here](https:\/\/github.com\/pytorch\/elastic\/blob\/master\/examples\/imagenet\/main.py).","__index_level_0__":3211}
+{"text":"## Come see us at NeurIPS","__index_level_0__":3212}
+{"text":"The PyTorch team will be hosting workshops at NeurIPS during the industry expo on 12\/8. Join the sessions below to learn more, and visit the team at the PyTorch booth on the show floor and during the Poster Session. At the booth, we\u2019ll be walking through an interactive demo of PyTorch running fast neural style transfer on a Cloud TPU - here\u2019s a [sneak peek](https:\/\/colab.research.google.com\/github\/pytorch\/xla\/blob\/master\/contrib\/colab\/style_transfer_inference-xrt-1-15.ipynb).","__index_level_0__":3213}
+{"text":"We\u2019re also publishing a [paper that details the principles that drove the implementation of PyTorch](https:\/\/papers.nips.cc\/paper\/9015-pytorch-an-imperative-style-high-performance-deep-learning-library) and how they\u2019re reflected in its architecture.","__index_level_0__":3214}
+{"text":"*[Multi-modal Research to Production](https:\/\/nips.cc\/ExpoConferences\/2019\/schedule?workshop_id=16)* - This workshop will dive into a number of modalities such as computer vision (large scale image classification and instance segmentation) and Translation and Speech (seq-to-seq Transformers) from the lens of taking cutting edge research to production. Lastly, we will also walk through how to use the latest APIs in PyTorch to take eager mode developed models into graph mode via Torchscript and quantize them for scale production deployment on servers or mobile devices. Libraries used include:","__index_level_0__":3215}
+{"text":"* Classification Framework - a newly open sourced PyTorch framework developed by Facebook AI for research on large-scale image and video classification. It allows researchers to quickly prototype and iterate on large distributed training jobs. Models built on the framework can be seamlessly deployed to production.\n* Detectron2 - the recently released object detection library built by the Facebook AI Research computer vision team. We will articulate the improvements over the previous version including: 1) Support for latest models and new tasks; 2) Increased flexibility, to enable new computer vision research; 3) Maintainable and scalable, to support production use cases.\n* Fairseq - general purpose sequence-to-sequence library, can be used in many applications, including (unsupervised) translation, summarization, dialog and speech recognition.","__index_level_0__":3216}
+{"text":"*[Responsible and Reproducible AI](https:\/\/nips.cc\/ExpoConferences\/2019\/schedule?workshop_id=14)* - This workshop on Responsible and Reproducible AI will dive into important areas that are shaping the future of how we interpret, reproduce research, and build AI with privacy in mind. We will cover major challenges, walk through solutions, and finish each talk with a hands-on tutorial.","__index_level_0__":3217}
+{"text":"* Reproducibility: As the number of research papers submitted to arXiv and conferences skyrockets, scaling reproducibility becomes difficult. We must address the following challenges: aid extensibility by standardizing code bases, democratize paper implementation by writing hardware agnostic code, facilitate results validation by documenting \u201ctricks\u201d authors use to make their complex systems function. To offer solutions, we will dive into tool like PyTorch Hub and PyTorch Lightning which are used by some of the top researchers in the world to reproduce the state of the art.\n* Interpretability: With the increase in model complexity and the resulting lack of transparency, model interpretability methods have become increasingly important. Model understanding is both an active area of research as well as an area of focus for practical applications across industries using machine learning. To get hands on, we will use the recently released Captum library that provides state-of-the-art algorithms to provide researchers and developers with an easy way to understand the importance of neurons\/layers and the predictions made by our models.`\n* Private AI: Practical applications of ML via cloud-based or machine-learning-as-a-service platforms pose a range of security and privacy challenges. There are a number of technical approaches being studied including: homomorphic encryption, secure multi-party computation, trusted execution environments, on-device computation, and differential privacy. To provide an immersive understanding of how some of these technologies are applied, we will use the CrypTen project which provides a community based research platform to take the field of Private AI forward.","__index_level_0__":3218}
+{"text":"*We\u2019d like to thank the entire PyTorch team and the community for all their contributions to this work.*","__index_level_0__":3219}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-adds-new-tools-and-libraries-welcomes-preferred-networks-to-its-community\/ \n category: pytorch blogs","__index_level_0__":3221}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"How Computational Graphs are Executed in PyTorch\"\nauthor: Preferred Networks\nfeatured-img: \"\"\n---","__index_level_0__":3222}
+{"text":"Welcome to the last entry into understanding the autograd engine of PyTorch series!\nIf you haven\u2019t read parts [1](https:\/\/pytorch.org\/blog\/overview-of-pytorch-autograd-engine\/) & [2](https:\/\/pytorch.org\/blog\/computational-graphs-constructed-in-pytorch\/) check them now to understand how PyTorch creates the computational graph for the backward pass!","__index_level_0__":3223}
+{"text":"This post is based on PyTorch v1.11, so some highlighted parts may differ across versions.","__index_level_0__":3224}
+{"text":"# PyTorch autograd graph execution","__index_level_0__":3225}
+{"text":"The last post showed how PyTorch constructs the graph to calculate the outputs' derivatives w.r.t. the inputs when executing the forward pass. Now we will see how the execution of the backward pass is coordinated and done by looking at the whole process, starting from Python down to the lower C++ level internals.","__index_level_0__":3226}
+{"text":"# What Happens when Calling `backward()`\/`grad()` from Python\n## Using `variable.backward()`","__index_level_0__":3227}
+{"text":"After doing all our calculations with an input set to require the gradient, we call `.backward()` on the result to initiate the backward pass execution.","__index_level_0__":3228}
+{"text":"```python\n>>> x = torch.tensor([0.5, 0.75], requires_grad=True)\n>>> y = torch.exp(x).sum()\n>>> y.backward()\n```","__index_level_0__":3229}
+{"text":"Calling [`.backward()`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/_tensor.py#L307-L363) on a tensor results in a call to [`torch.autograd.backward()`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/autograd\/__init__.py#L85-L175).\n```python\n# torch\/_tensor.py","__index_level_0__":3230}
+{"text":"def backward(self, gradient=None, retain_graph=None, create_graph=False, inputs=None):\n    \u2026\n    torch.autograd.backward(self, gradient, retain_graph, create_graph, inputs=inputs)","__index_level_0__":3231}
+{"text":"```\n`torch.autograd.backward()` checks the arguments and calls the autograd engine in the C++ layer.","__index_level_0__":3232}
+{"text":"``` python\ndef backward(\n    tensors: _TensorOrTensors,\n    grad_tensors: Optional[_TensorOrTensors] = None,\n    retain_graph: Optional[bool] = None,\n    create_graph: bool = False,\n    grad_variables: Optional[_TensorOrTensors] = None,\n    inputs: Optional[_TensorOrTensors] = None,\n) -> None:\n    \u2026","__index_level_0__":3233}
+{"text":"    if inputs is not None and len(inputs) == 0:\n        raise RuntimeError(\"'inputs' argument to backward() cannot be empty.\")","__index_level_0__":3234}
+{"text":"    tensors = (tensors,) if isinstance(tensors, torch.Tensor) else tuple(tensors)\n    inputs = (inputs,) if isinstance(inputs, torch.Tensor) else \\\n        tuple(inputs) if inputs is not None else tuple()","__index_level_0__":3235}
+{"text":"    grad_tensors_ = _tensor_or_tensors_to_tuple(grad_tensors, len(tensors))\n    grad_tensors_ = _make_grads(tensors, grad_tensors_)\n    if retain_graph is None:\n        retain_graph = create_graph","__index_level_0__":3236}
+{"text":"    Variable._execution_engine.run_backward(\n        tensors, grad_tensors_, retain_graph, create_graph, inputs,\n        allow_unreachable=True, accumulate_grad=True)  # allow_unreachable flag","__index_level_0__":3237}
+{"text":"```\nFirst, whether the `grad_tensors` argument was specified or not, there is a call to the [`_make_grads`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/autograd\/__init__.py#L30-L74) function. This is used to check the provided `grad_tensors` or to specify the default value for them by looking at the `tensors` argument values\u2019 shapes. Check the first blog post for details on the default value for the `grad_tensors` of the backward pass. This function just provides the vector of the vector jacobian product if it was not initially specified.","__index_level_0__":3238}
+{"text":"In the above code, `Variable` has an `_execution_engine` attribute that is defined in [`torch.autograd.variable`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/autograd\/variable.py#L14) to be of type `ImperativeEngine`; the C++ engine exported to python and declared in [`torch\/csrc\/autograd\/python_engine.cpp`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/python_engine.cpp#L384). In the following sections, we explain in detail how this object executes the backward pass.","__index_level_0__":3239}
+{"text":"Note that the `torch.autograd.backward` function has an `inputs` optional argument. This argument is used when we want to calculate the `.grad` field of only a subset of input tensors in the forward pass.","__index_level_0__":3240}
+{"text":"```python\n>>> x = torch.tensor([0.5, 0.75], requires_grad=True)\n>>> y = torch.tensor([0.1, 0.90], requires_grad=True)\n>>> z = torch.exp(x * y).sum()\n>>> torch.autograd.backward([z], inputs=[x])\n>>> x.grad\ntensor([0.1051, 1.7676])\n>>> y.grad  # None\n>>>","__index_level_0__":3241}
+{"text":"```\n## Using `torch.autograd.grad`","__index_level_0__":3242}
+{"text":"An alternative to `backward()` is to use [`torch.autograd.grad()`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/autograd\/__init__.py#L177-L277). The main difference to `backward()` is that `grad()` returns a tuple of tensors with the gradients of the `outputs` w.r.t. the `inputs` kwargs instead of storing them in the `.grad` field of the tensors. As you can see, the `grad()` code shown below is very similar to backward.","__index_level_0__":3243}
+{"text":"```python\ndef grad(\n    outputs: _TensorOrTensors,\n    inputs: _TensorOrTensors,\n    grad_outputs: Optional[_TensorOrTensors] = None,\n    retain_graph: Optional[bool] = None,\n    create_graph: bool = False,\n    only_inputs: bool = True,\n    allow_unused: bool = False,\n   is_grads_batched: bool = False\n) -> Tuple[torch.Tensor, ...]:\n   \n    outputs = (outputs,) if isinstance(outputs, torch.Tensor) else tuple(outputs)\n    inputs = (inputs,) if isinstance(inputs, torch.Tensor) else tuple(inputs)\n    overridable_args = outputs + inputs\n    if has_torch_function(overridable_args):\n        return handle_torch_function(\n            grad,\n            overridable_args,\n            outputs,\n            inputs,\n            grad_outputs=grad_outputs,\n            retain_graph=retain_graph,\n            create_graph=create_graph,\n            only_inputs=only_inputs,\n            allow_unused=allow_unused,\n        )","__index_level_0__":3244}
+{"text":"    grad_outputs_ = _tensor_or_tensors_to_tuple(grad_outputs, len(outputs))\n    grad_outputs_ = _make_grads(outputs, grad_outputs_)","__index_level_0__":3245}
+{"text":"    if retain_graph is None:\n        retain_graph = create_graph","__index_level_0__":3246}
+{"text":"    if is_grads_batched:\n        # \u2026. It will not be covered here\n    else:\n        return Variable._execution_engine.run_backward(\n            outputs, grad_outputs_, retain_graph, create_graph, inputs,\n            allow_unused, accumulate_grad=False)  # Calls into the C++ engine to run the backward pass","__index_level_0__":3247}
+{"text":"Figure 1 shows the computational graph with the `backward()` and `grad()` arguments highlighted in red and blue, respectively:","__index_level_0__":3249}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/backward-grad-fig-1.png\" width=\"100%\">\n<\/p>","__index_level_0__":3250}
+{"text":"<p align = \"center\">\nFgiure 1: Correspondence of `backward`\/`grad` arguments in the graphs.\n<\/p>","__index_level_0__":3251}
+{"text":"# Going Inside the Autograd Engine","__index_level_0__":3252}
+{"text":"## Refreshing Concepts: Nodes and Edges","__index_level_0__":3253}
+{"text":"As we saw in [2](https:\/\/pytorch.org\/blog\/computational-graphs-constructed-in-pytorch\/)\nThe computational graph comprises `Node` and `Edge` objects. Please read that post if you haven\u2019t done it yet.","__index_level_0__":3254}
+{"text":"`Node` objects are defined in [`torch\/csrc\/autograd\/function.h`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/function.h#L105-L176), and they provide an overload of `operator()` for the associated function and a list of edges to do the graph traversal. Note that `Node` is a base class that autograd functions inherit from and override the `apply` method to execute the backward function.\n```c++\nstruct TORCH_API Node : std::enable_shared_from_this<Node> {\n ...\n \/\/\/ Evaluates the function on the given inputs and returns the result of the\n  \/\/\/ function call.\n  variable_list operator()(variable_list&& inputs) {\n  ...\n  }","__index_level_0__":3256}
+{"text":"protected:\n  \/\/\/ Performs the `Node`'s actual operation.\n  virtual variable_list apply(variable_list&& inputs) = 0;\n  \u2026\n  edge_list next_edges_;\n  uint64_t topological_nr_ = 0;\n  \u2026","__index_level_0__":3257}
+{"text":"There is an attribute called [`topological_nr_`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/function.h#L481) in every node object. This number is used to optimize the graph execution as it allows to discard of graph branches under certain conditions. The topological number is the longest distance between this node and any leaf node and it is shown in Figure 2. Its main property is that for any pair of nodes `x`, `y` in a directed graph `topo_nr(x) < topo_nr(y)` means that there is no path from `x` to `y`. So this allows for reducing the number of paths in the graph in need of traversal. Check the [topological_nr](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/function.h#L314-L343)\n) method comment for further details.","__index_level_0__":3259}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/topological-number-fig-2.png\" width=\"100%\">\n<\/p>","__index_level_0__":3260}
+{"text":"<p align = \"center\">\nFigure 2: Example of the Topological Number calculation\n<\/p>","__index_level_0__":3261}
+{"text":"The [`Edge`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/edge.h#L14-L39) object links `Node`s together, and its implementation is straightforward.","__index_level_0__":3263}
+{"text":"```c++\nstruct Edge {\n  ...\n  \/\/\/ The function this `Edge` points to.\n  std::shared_ptr<Node> function;\n  \/\/\/ The identifier of a particular input to the function.\n  uint32_t input_nr;\n};","__index_level_0__":3264}
+{"text":"It only requires a function pointer to the `Node` and an input number that is the index of the output from the forward function this edge points to. When preparing the set of gradients before calling \"function\", we know that what is flowing from this edge should be accumulated in the \"input_nr\"th argument. Note that the input\/output name is flipped here and this is the input to the backward function.\n `Edge` objects are constructed using the [`gradient_edge`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/variable.cpp#L221-L233)  function method.","__index_level_0__":3266}
+{"text":"```c++\n Edge gradient_edge(const Variable& self) {\n    if (const auto& gradient = self.grad_fn()) {\n      return Edge(gradient, self.output_nr());\n    } else {\n      return Edge(grad_accumulator(self), 0);\n    }\n  }","__index_level_0__":3267}
+{"text":"```\n## Entering the C++ Realm","__index_level_0__":3268}
+{"text":"Once that `torch.autograd.backward()` has been invoked, the\n[`THPEngine_run_backward`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/python_engine.cpp#L152-L286) routine starts the graph traversal. Following is a schema of the function body:\n```c++\nPyObject *THPEngine_run_backward(PyObject *self, PyObject *args, PyObject *kwargs)\n{\n  HANDLE_TH_ERRORS\n  PyObject *tensors = nullptr;\n  PyObject *grad_tensors = nullptr;\n  unsigned char keep_graph = 0;\n  unsigned char create_graph = 0;\n  PyObject *inputs = nullptr;\n  \n  \/\/ Convert the python arguments to C++ objects\n  const char *accepted_kwargs[] = { \/\/ NOLINT\n      \"tensors\", \"grad_tensors\", \"keep_graph\", \"create_graph\", \"inputs\",\n      \"allow_unreachable\", \"accumulate_grad\", nullptr\n  };\n  if (!PyArg_ParseTupleAndKeywords(args, kwargs, \"OObb|Obb\", (char**)accepted_kwargs,\n        &tensors, &grad_tensors, &keep_graph, &create_graph, &inputs, &allow_unreachable, &accumulate_grad))","__index_level_0__":3269}
+{"text":" \/\/ Prepare arguments\n for(const auto i : c10::irange(num_tensors)) {\n   \/\/ Check that the tensors require gradients\n  }","__index_level_0__":3270}
+{"text":"  std::vector<Edge> output_edges;\n  if (inputs != nullptr) {\n     \/\/ Prepare outputs\n  }","__index_level_0__":3271}
+{"text":"  {\n      \/\/ Calls the actual autograd engine\n    pybind11::gil_scoped_release no_gil;\n    outputs = engine.execute(roots, grads, keep_graph, create_graph, accumulate_grad, output_edges);\n  }\n    \/\/ Clean up and finish\n}","__index_level_0__":3272}
+{"text":"First, we prepare the input arguments after converting the `PyObject` arguments to actual C++ objects. The `tensors` list contains the tensors from which we start the backward pass. These tensors are converted to edges using `torch::autograd::impl::gradient_edge` and added to a list called `roots` where the graph traversal starts. ","__index_level_0__":3274}
+{"text":"\n```c++\n edge_list roots;\n  roots.reserve(num_tensors);\n  variable_list grads;\n  grads.reserve(num_tensors);\n  for(const auto i : c10::irange(num_tensors)) {\n    PyObject *_tensor = PyTuple_GET_ITEM(tensors, i);\n       const auto& variable = THPVariable_Unpack(_tensor);\n       auto gradient_edge = torch::autograd::impl::gradient_edge(variable);\n     roots.push_back(std::move(gradient_edge));","__index_level_0__":3275}
+{"text":"    PyObject *grad = PyTuple_GET_ITEM(grad_tensors, i);\n    if (THPVariable_Check(grad)) {\n      const Variable& grad_var = THPVariable_Unpack(grad);\n      grads.push_back(grad_var);\n    } \n  }","__index_level_0__":3276}
+{"text":"Now, if the `inputs` argument was specified in `backward` or we used the `torch.autograd.grad` api, the following code creates a list of edges to accumulate the gradients in the specified tensors at the end of the computation. The engine uses this later to optimize the execution as it doesn\u2019t add the gradients in all the leaf nodes, just the specified ones.","__index_level_0__":3278}
+{"text":"```c++\n  std::vector<Edge> output_edges;\n  if (inputs != nullptr) {\n    int num_inputs = PyTuple_GET_SIZE(inputs);\n    output_edges.reserve(num_inputs);\n    for (const auto i : c10::irange(num_inputs)) {\n      PyObject *input = PyTuple_GET_ITEM(inputs, i);\n      const auto& tensor = THPVariable_Unpack(input);\n      const auto output_nr = tensor.output_nr();\n      auto grad_fn = tensor.grad_fn();\n      if (!grad_fn) {\n        grad_fn = torch::autograd::impl::try_get_grad_accumulator(tensor);\n      }\n      if (accumulate_grad) {\n        tensor.retain_grad();\n      }\n      if (!grad_fn) {\n        output_edges.emplace_back(std::make_shared<Identity>(), 0);\n      } else {\n        output_edges.emplace_back(grad_fn, output_nr);\n      }\n    }\n  }","__index_level_0__":3279}
+{"text":"The next step is the actual graph traversal and node function execution, and finally, the cleanup and return.","__index_level_0__":3281}
+{"text":"```c++\n  {\n    \/\/ Calls the actual autograd engine\n    pybind11::gil_scoped_release no_gil;\n    auto& engine = python::PythonEngine::get_python_engine();\n    outputs = engine.execute(roots, grads, keep_graph, create_graph, accumulate_grad, output_edges);\n  }\n  \/\/ Clean up and finish\n}","__index_level_0__":3282}
+{"text":"# Starting the Real Execution","__index_level_0__":3284}
+{"text":"`engine.execute`is present in [torch\/csrc\/autograd\/engine.cpp](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L969-L1044) ","__index_level_0__":3285}
+{"text":"There are two differentiated steps here:","__index_level_0__":3286}
+{"text":"Analyze the graph to find dependencies between functions\nCreate worker threads that traverse the graph","__index_level_0__":3287}
+{"text":"## Data Structures Used for the Execution","__index_level_0__":3288}
+{"text":"### GraphTask","__index_level_0__":3289}
+{"text":"All the execution metadata is managed by the [`GraphTask`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.h#L51-L196) class in [torch\/csrc\/autograd\/engine.h](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.11\/torch\/csrc\/autograd\/engine.h)","__index_level_0__":3290}
+{"text":"```c++\nstruct GraphTask: std::enable_shared_from_this<GraphTask> {\n  std::atomic<uint64_t> outstanding_tasks_{0};\n  \/\/  \u2026 \n  std::unordered_map<Node*, InputBuffer> not_ready_;\n  std::unordered_map<Node*, int> dependencies_;","__index_level_0__":3291}
+{"text":"  struct ExecInfo {\n     \/\/ \u2026\n  };\n  std::unordered_map<Node*, ExecInfo> exec_info_;\n  std::vector<Variable> captured_vars_;\n  \/\/ \u2026\n  std::shared_ptr<ReadyQueue> cpu_ready_queue_;\n};","__index_level_0__":3292}
+{"text":"Here we see a series of variables dedicated to maintaining the execution state.\n`outstanding_tasks_` tracks the number of tasks left to be executed for the backward pass to complete. `not_ready_` holds the input arguments for the `Node`s that are not ready to be executed. `dependencies_` track the number of predecessors that a `Node` has. As the count reaches `0`,  the `Node` is ready for execution; it is placed in a ready queue to be retrieved and executed later. ","__index_level_0__":3294}
+{"text":"`exec_info_` and the associated `ExecInfo` struct are used only when the `inputs` argument is specified or it is a call to `autograd.grad()`. They allow filter paths on the graph that are not needeed since only the gradients are calculated only for the variables in the `inputs` list.","__index_level_0__":3295}
+{"text":" `captured_vars_` is where the results of the graph execution are temporarily stored if we used the `torch.autograd.grad()` api instead of `torch.autograd.backward()` since `grad()` returns the gradients as tensors instead of just filling the `.grad` field of the inputs.","__index_level_0__":3296}
+{"text":"\n### NodeTask","__index_level_0__":3297}
+{"text":"The [`NodeTask`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.h#L210-L242) struct is a basic class that holds an `fn_` pointer to the node to execute, and an `inputs_` buffer to store the input arguments to this function. Note that the functions executed by the backward pass are the derivatives specified in the `derivatives.yaml` file. or the user provided backward function when using custom functions as described in the second blog post.","__index_level_0__":3298}
+{"text":"The `inputs_` buffer is also where the output gradients of the previously executed functions are aggregated, and it is defined as a [`std::vector<Variable>` container](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.10\/torch\/csrc\/autograd\/input_buffer.h) with facilities to accumulate values at a given position.","__index_level_0__":3299}
+{"text":"```c++\nstruct NodeTask {\n  std::weak_ptr<GraphTask> base_;\n  std::shared_ptr<Node> fn_;\n  \/\/ This buffer serves as an implicit \"addition\" node for all of the\n  \/\/ gradients flowing here.  Once all the dependencies are finished, we\n  \/\/ use the contents of this buffer to run the function.\n  InputBuffer inputs_;\n};","__index_level_0__":3300}
+{"text":"```\n### GraphRoot","__index_level_0__":3301}
+{"text":"The [`GraphRoot`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/functions\/basic_ops.h#L72-L89) is a special function used to hold multiple input variables in a single place. The code is pretty simple as it only acts as a container of variables.","__index_level_0__":3302}
+{"text":"```c++\nstruct TORCH_API GraphRoot : public Node {\n  GraphRoot(edge_list functions, variable_list inputs)\n      : Node(std::move(functions)),\n      outputs(std::move(inputs)) {\n    for (const auto& t : outputs) {\n      add_input_metadata(t);\n    }\n  }","__index_level_0__":3303}
+{"text":"  variable_list apply(variable_list&& inputs) override {\n    return outputs;\n  }","__index_level_0__":3304}
+{"text":"### AccumulateGrad","__index_level_0__":3306}
+{"text":"This function is set during the graph creation in `gradient_edge` when the `Variable` object doesn\u2019t have a `grad_fn`. This is, it is a leaf node.","__index_level_0__":3307}
+{"text":"```c++\n    if (const auto& gradient = self.grad_fn()) {\n      \/\/ \u2026\n    } else {\n      return Edge(grad_accumulator(self), 0);\n    }","__index_level_0__":3308}
+{"text":"The function body is defined in [`torch\/csrc\/autograd\/functions\/accumulate_grad.cpp`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/functions\/accumulate_grad.cpp#L25-L63) and it essentially accumulates the input grads in the object\u2019s `.grad` attribute.","__index_level_0__":3310}
+{"text":"```c++\nauto AccumulateGrad::apply(variable_list&& grads) -> variable_list {\n  check_input_variables(\"AccumulateGrad\", grads, 1, 0);\n  \u2026","__index_level_0__":3311}
+{"text":"  at::Tensor new_grad = callHooks(variable, std::move(grads[0]));\n  std::lock_guard<std::mutex> lock(mutex_);","__index_level_0__":3312}
+{"text":"  at::Tensor& grad = variable.mutable_grad();\n  accumulateGrad(\n      variable,\n      grad,\n      new_grad,\n      1 + !post_hooks().empty() \/* num_expected_refs *\/,\n      [&grad](at::Tensor&& grad_update) { grad = std::move(grad_update); });\n  return variable_list();\n}\n}} \/\/ namespace torch::autograd","__index_level_0__":3313}
+{"text":"[`accumulateGrad`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/functions\/accumulate_grad.h#L100)\ndoes several checks on the tensors format and eventually performs the `variable_grad += new_grad;` accumulation.","__index_level_0__":3316}
+{"text":"## Preparing the graph for execution","__index_level_0__":3317}
+{"text":"Now, let\u2019s walk through [`Engine::execute`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L969-L1126). The first thing to do besides arguments consistency checks is to create the actual `GraphTask` object we described above. This object keeps all the metadata of the graph execution.","__index_level_0__":3318}
+{"text":"```c++\nauto Engine::execute(const edge_list& roots,\n                     const variable_list& inputs,\n                     bool keep_graph,\n                     bool create_graph,\n                     bool accumulate_grad,\n                     const edge_list& outputs) -> variable_list {","__index_level_0__":3319}
+{"text":"  validate_outputs(roots, const_cast<variable_list&>(inputs), [](const std::string& msg) {\n    return msg;\n  });","__index_level_0__":3320}
+{"text":"  \/\/ Checks","__index_level_0__":3321}
+{"text":"  auto graph_task = std::make_shared<GraphTask>(\n      \/* keep_graph *\/ keep_graph,\n      \/* create_graph *\/ create_graph,\n      \/* depth *\/ not_reentrant_backward_call ? 0 : total_depth + 1,\n      \/* cpu_ready_queue *\/ local_ready_queue);","__index_level_0__":3322}
+{"text":"  \/\/ If we receive a single root, skip creating extra root node\n  \/\/ \u2026\n  \/\/ Prepare graph by computing dependencies\n  \/\/ \u2026\n  \/\/ Queue the root \n  \/\/ \u2026\n  \/\/ launch execution\n  \/\/ \u2026\n}","__index_level_0__":3323}
+{"text":"After creating the `GraphTask`, we use its associated function if we only have one root node. If we have multiple root nodes, we create a special `GraphRoot` object as described before.","__index_level_0__":3325}
+{"text":"```c++\n  bool skip_dummy_node = roots.size() == 1;\n  auto graph_root = skip_dummy_node ?\n    roots.at(0).function :\n    std::make_shared<GraphRoot>(roots, inputs);","__index_level_0__":3326}
+{"text":"The next step is to fill the `dependencies_` map in the `GraphTask` object since the engine must know when it can execute a task. The `outputs` here is the `inputs` argument passed to the `torch.autograd.backward()` call in Python. But here, we have reversed the names since the gradients w.r.t. the inputs of the forward pass are now the outputs of the backward pass. And from now on, there is no concept of forward\/backward, but only graph traversal and execution.","__index_level_0__":3328}
+{"text":"```c++\n  auto min_topo_nr = compute_min_topological_nr(outputs);\n  \/\/ Now compute the dependencies for all executable functions\n  compute_dependencies(graph_root.get(), *graph_task, min_topo_nr);","__index_level_0__":3329}
+{"text":"  if (!outputs.empty()) {\n    graph_task->init_to_execute(*graph_root, outputs, accumulate_grad, min_topo_nr);\n  }","__index_level_0__":3330}
+{"text":"Here we preprocess the graph for the execution of the nodes. First, [`compute_min_topological_nr`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L922-L933) is called to to obtain the minimum topological number of the tensors specified in `outputs` (0 if no `inputs` kwarg was supplied to `.backward` or `input` for `.grad`). This computation prunes paths in the graph that lead to input variables of which we don\u2019t want\/need to calculate the grads.","__index_level_0__":3332}
+{"text":"Second, is the [`compute_dependencies`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L935-L967) call. This function is a very simple graph traversal that starts with the root `Node`, and for each of the edges in `node.next_edges()` it increments the counter in `dependencies_`. Figure 3 shows the result of the dependencies calculation for the example graph. Note that the number of dependencies of any node is just the number of edges arriving at it.","__index_level_0__":3333}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/node-fig-3.png\" width=\"100%\">\n<\/p>","__index_level_0__":3334}
+{"text":"<p align = \"center\">\nFigure 3:  Number of dependencies for each node\n<\/p>","__index_level_0__":3335}
+{"text":"Finally, the [`init_to_execute`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L1281-L1383) call, this is the one that populates the `GraphTask::exec_info_` map in case that `inputs` were specified in the python `backward` call. It iterates the graph again, starting from the root, and records in the `exec_info_` map the intermediate nodes needed to calculate only the given `inputs` gradients.","__index_level_0__":3336}
+{"text":"```c++\n  \/\/ Queue the root\n  if (skip_dummy_node) {\n    InputBuffer input_buffer(roots.at(0).function->num_inputs());\n    auto input = inputs.at(0);","__index_level_0__":3337}
+{"text":"\n    input_buffer.add(roots.at(0).input_nr,\n                      std::move(input),\n                      input_stream,\n                      opt_next_stream);","__index_level_0__":3338}
+{"text":"    execute_with_graph_task(graph_task, graph_root, std::move(input_buffer));\n  } else {\n    execute_with_graph_task(graph_task, graph_root, InputBuffer(variable_list()));\n  }\n  \/\/ Avoid a refcount bump for the Future, since we check for refcount in\n  \/\/ DistEngine (see TORCH_INTERNAL_ASSERT(futureGrads.use_count() == 1)\n  \/\/ in dist_engine.cpp).\n  auto& fut = graph_task->future_result_;\n  fut->wait();\n  return fut->value().toTensorVector();\n}","__index_level_0__":3339}
+{"text":"And now, we are ready to start the actual execution by creating the `InputBuffer`. In case we only have one root variable, we begin by copying the value of the `inputs` tensor (this is the `gradients` passed to python `backward`) in position 0 of the input_buffer. This is a small optimization that avoids running the `RootNode` for no reason. Also, if the rest of the graph is not on the cpu, we directly start on that worker while the `RootNode` is always placed on the cpu ready queue. Details of the workers and ready queues are explained in the section below.","__index_level_0__":3341}
+{"text":"On the other hand, if we have multiple roots, the `GraphRoot` object also holds the inputs, so it is enough to pass it an empty `InputBuffer`.","__index_level_0__":3342}
+{"text":"## Graph Traversal and Node Execution\n### Devices, Threads and Queues","__index_level_0__":3343}
+{"text":"Before diving into the actual execution, we need to see how the engine is structured.","__index_level_0__":3344}
+{"text":"First of all, the engine is multithreaded with one thread per device. For example, the caller thread is associated with the CPU while additional threads are created and associated with each GPU or other devices available in the system. Each thread tracks its device using thread-local storage in the [`worker_device`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L69) variable. In addition, the threads have a queue of tasks to be executed also located in thread-local storage, the [`local_ready_queue`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L103-L104). This is where work is queued for this thread to execute in the `thread_main` function that is explained later.\nYou will wonder how the device where a task should be executed is decided. The `InputBuffer` class has a [`device()`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/input_buffer.cpp#L173-L189) function that returns the first non-cpu device of all its tensors.\nThis function is used together with [`Engine::ready_queue`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L1181-L1190) to select the queue to queue a task.","__index_level_0__":3345}
+{"text":"```c++\nauto Engine::ready_queue(std::shared_ptr<ReadyQueue> cpu_ready_queue, at::Device device) -> std::shared_ptr<ReadyQueue>{\n  if (device.type() == at::kCPU || device.type() == at::DeviceType::Meta) {\n    return cpu_ready_queue;\n  } else {\n    \/\/ See Note [Allocating GPUs to autograd threads]\n    return device_ready_queues_.at(device.index());\n  }\n}","__index_level_0__":3346}
+{"text":"The [`ReadyQueue`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.h#L245-L283) object is defined in `torch\/csrc\/autograd\/engine.h` and it is a simple wrapper over `std::priority_queue` that allows a thread to [wait for a task](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L219) if it\u2019s empty. One interesting property of the `ReadyQueue` is that it increases the [`GraphTask::outstanding_tasks_`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L195) value used to determine if the execution has completed or not.","__index_level_0__":3348}
+{"text":"```c++\nauto ReadyQueue::push(NodeTask item, bool incrementOutstandingTasks) -> void {\n  {\n    std::lock_guard<std::mutex> lock(mutex_);\n    if (incrementOutstandingTasks) {\n      std::shared_ptr<GraphTask> graph_task = item.base_.lock();\n      ++graph_task->outstanding_tasks_;\n    }\n    heap_.push(std::move(item));\n  }\n  not_empty_.notify_one();\n}","__index_level_0__":3349}
+{"text":"auto ReadyQueue::pop() -> NodeTask {\n  std::unique_lock<std::mutex> lock(mutex_);\n  not_empty_.wait(lock, [this]{ return !heap_.empty(); });\n  auto task = std::move(const_cast<NodeTask&>(heap_.top())); heap_.pop();\n  return task;\n}","__index_level_0__":3350}
+{"text":"### Reentrant Backward","__index_level_0__":3352}
+{"text":"A reentrant backward happens when one of the tasks in a backward pass calls again `backward`. It is not a very common case, but it can be used to reduce memory utilization as it could potentially avoid saving intermediate results. For more information, check this [PyTorch forum post](https:\/\/discuss.pytorch.org\/t\/what-is-the-scenario-of-reentrant-backwards-in-pytorch-source-code\/19330\/2).","__index_level_0__":3353}
+{"text":"```python\nclass ReentrantBackward(torch.autograd.Function):\n    @staticmethod\n    def forward(ctx, input):\n        return input.sum()","__index_level_0__":3354}
+{"text":"    @staticmethod\n    def backward(ctx, input):\n        # Let's compute the backward by using autograd\n        input = input.detach().requires_grad_()\n        with torch.enable_grad():\n            out = input.sum()\n        out.backward()  # REENTRANT CALL!!\n        return out.detach()","__index_level_0__":3355}
+{"text":"Here, we call `backward()` inside `backward()` for a user custom-defined autograd function.\nThis situation can lead to deadlocks because the first backward needs to wait for the second one to complete. But some internal implementation details can prevent the second backward from completing as it is explained in the dedicated subsection.\n## Thread Initialization","__index_level_0__":3357}
+{"text":"[`execute_with_graph_task`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L1054-L1126) is in charge of initializing the threads taking care of the computation and placing the `root` node in the queue of the device that produced it.","__index_level_0__":3358}
+{"text":"```c++\nc10::intrusive_ptr<at::ivalue::Future> Engine::execute_with_graph_task(\n    const std::shared_ptr<GraphTask>& graph_task,\n    std::shared_ptr<Node> graph_root,\n    InputBuffer&& input_buffer) {","__index_level_0__":3359}
+{"text":"  initialize_device_threads_pool();\n  \/\/ Lock mutex for GraphTask.\n  std::unique_lock<std::mutex> lock(graph_task->mutex_);","__index_level_0__":3360}
+{"text":"  auto queue = ready_queue(graph_task->cpu_ready_queue_, input_buffer.device());","__index_level_0__":3361}
+{"text":"  if (worker_device == NO_DEVICE) {\n    set_device(CPU_DEVICE);\n    graph_task->owner_ = worker_device;\n    queue->push(NodeTask(graph_task, std::move(graph_root), std::move(input_buffer)));\n    lock.unlock();\n    thread_main(graph_task);\n    worker_device = NO_DEVICE;\n  } else {\n     \/\/ This deals with reentrant backwards, we will see it later.\n  }\n  return graph_task->future_result_;\n}","__index_level_0__":3362}
+{"text":"First, this function initializes several threads (one per device) calling [` initialize_device_threads_pool()`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L1046-L1052) where several things happen:\nOne `ReadyQueue` per device is created.\nOne thread per non-cpu device is created.\nA thread local `worker_device` variable is set to track the current device associated with the thread.\n`thread_main` function is called, and threads wait for tasks to be put in their queues.","__index_level_0__":3364}
+{"text":"Then it retrieves the queue to place the root node based on the device that holds the tensors present in the `input_buffer` using the `ready_queue` function. Now, the main thread (the one also executing the Python interpreter) has its `worker_device` set to `NO_DEVICE`, and it is in charge of executing functions with all its tensors living in the cpu. If `worker_device` is set to any other value, the graph execution is already started, and `.backward()` was called inside a running `Node`, creating a reentrant backward call. This is explained later. For now, \nthe main thread places the task in the queue and call `thread_main`.\n## Where the Magic Happens","__index_level_0__":3365}
+{"text":"It\u2019s been a long way, but finally, we are ready to traverse the graph and execute the nodes. Each of the spawned threads, and the main thread call [`thread_main`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L377-L464).","__index_level_0__":3366}
+{"text":"```c++\nauto Engine::thread_main(const std::shared_ptr<GraphTask>& graph_task) -> void {","__index_level_0__":3367}
+{"text":"  while (graph_task == nullptr || !graph_task->future_result_->completed()) {\n    std::shared_ptr<GraphTask> local_graph_task;\n    {\n      NodeTask task = local_ready_queue->pop();","__index_level_0__":3368}
+{"text":"      if (task.isShutdownTask_) {\n        break;\n      }","__index_level_0__":3369}
+{"text":"      if (!(local_graph_task = task.base_.lock())) {\n        \/\/ GraphTask for function is no longer valid, skipping further\n        \/\/ execution.\n        continue;\n      }","__index_level_0__":3370}
+{"text":"      if (task.fn_ && !local_graph_task->has_error_.load()) {\n        at::ThreadLocalStateGuard tls_guard(local_graph_task->thread_locals_);","__index_level_0__":3371}
+{"text":"        try {\n          GraphTaskGuard guard(local_graph_task);\n          NodeGuard ndguard(task.fn_);\n          {\n            evaluate_function(\n                local_graph_task,\n                task.fn_.get(),\n                task.inputs_,\n                local_graph_task->cpu_ready_queue_);\n          }\n        } catch (std::exception& e) {\n          thread_on_exception(local_graph_task, task.fn_, e);\n        }\n      }\n    }","__index_level_0__":3372}
+{"text":"    \/\/ Decrement the outstanding tasks.\n    --local_graph_task->outstanding_tasks_;","__index_level_0__":3373}
+{"text":"    \/\/ Check if we've completed execution.\n    if (local_graph_task->completed()) {\n      local_graph_task->mark_as_completed_and_run_post_processing();\n      auto base_owner = local_graph_task->owner_;\n      if (worker_device != base_owner) {\n        std::atomic_thread_fence(std::memory_order_release);\n        ready_queue_by_index(local_graph_task->cpu_ready_queue_, base_owner)\n            ->push(NodeTask(local_graph_task, nullptr, InputBuffer(0)));\n      }\n    }\n  }\n}","__index_level_0__":3374}
+{"text":"The code here is simple, given the `local_ready_queue` assigned to each thread in thread-local storage. The threads loop until there are no tasks left to execute in the graph. Note that for device-associated threads, the passed `graph_task` argument is [`nullptr`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L326-L327), and they block in `local_ready_queue->pop()` until a task is pushed in their queue. After some consistency checks (the task type is shutdown, or the graph is still valid). We get to the actual function invocation in `evaluate_function`.","__index_level_0__":3376}
+{"text":"```c++\n        try {\n          GraphTaskGuard guard(local_graph_task);\n          NodeGuard ndguard(task.fn_);\n          {\n            evaluate_function(\n                local_graph_task,\n                task.fn_.get(),\n                task.inputs_,\n                local_graph_task->cpu_ready_queue_);\n          }\n        } catch (std::exception& e) {\n          thread_on_exception(local_graph_task, task.fn_, e);\n        }\n      }","__index_level_0__":3377}
+{"text":"After calling `evaluate_function`, we check if the `graph_task` execution is complete by looking the `outstanding_tasks_` number. This number increases when a task is pushed to a queue and is decreased in `local_graph_task->completed()` when a task is executed. When the execution is done, we return the results that are be in the `captured_vars_` in case we called `torch.autograd.grad()` instead of `torch.autograd.backward()` as this function returns tensors instead of storing them in the `.grad` attribute of the inputs. Finally we wake up the main thread if it\u2019s waiting by sending a dummy task.","__index_level_0__":3379}
+{"text":"```c++\n   \/\/ Decrement the outstanding tasks.\n    --local_graph_task->outstanding_tasks_;","__index_level_0__":3380}
+{"text":"    \/\/ Check if we've completed execution.\n    if (local_graph_task->completed()) {\n      local_graph_task->mark_as_completed_and_run_post_processing();\n      auto base_owner = local_graph_task->owner_;\n      if (worker_device != base_owner) {\n        std::atomic_thread_fence(std::memory_order_release);\n        ready_queue_by_index(local_graph_task->cpu_ready_queue_, base_owner)\n            ->push(NodeTask(local_graph_task, nullptr, InputBuffer(0)));\n      }\n    }","__index_level_0__":3381}
+{"text":"## Calling the Function and Unlocking New Tasks","__index_level_0__":3383}
+{"text":"[`evaluate_function`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L786-L920) serves three purposes:","__index_level_0__":3384}
+{"text":"Run the function.\nAccumulate its results in the next node `InputBuffers`.\nDecrease the dependencies counter of the next nodes and enqueues the tasks reaching 0 to be executed.","__index_level_0__":3385}
+{"text":"```c++\nvoid Engine::evaluate_function(\n    std::shared_ptr<GraphTask>& graph_task,\n    Node* func,\n    InputBuffer& inputs,\n    const std::shared_ptr<ReadyQueue>& cpu_ready_queue) {","__index_level_0__":3386}
+{"text":"  \/\/ If exec_info_ is not empty, we have to instrument the execution\n  auto& exec_info_ = graph_task->exec_info_;\n  if (!exec_info_.empty()) {\n    \/\/ Checks if the function needs to be executed \n    if (!fn_info.needed_) {\n      \/\/ Skip execution if we don't need to execute the function.\n      return;\n    }\n  }","__index_level_0__":3387}
+{"text":"  auto outputs = call_function(graph_task, func, inputs);","__index_level_0__":3388}
+{"text":"  auto& fn = *func;\n  if (!graph_task->keep_graph_) {\n    fn.release_variables();\n  }","__index_level_0__":3389}
+{"text":"Initially, we check the `exec_info_` map of the `GraphTask` structure to determine if the current node needs to be executed. Remember that if this map is empty, all the nodes are executed because we are calculating the grads for all the inputs of the forward pass.","__index_level_0__":3391}
+{"text":"After this check, the function is executed by running [`call_function`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L735-L784). Its implementation is very straightforward and calls the actual derivative function and registered hooks if any.","__index_level_0__":3392}
+{"text":"```c++\n  int num_outputs = outputs.size();\n  if (num_outputs == 0) {\n    \/\/ Records leaf stream (if applicable)\n    return;\n  }","__index_level_0__":3393}
+{"text":"  if (AnomalyMode::is_enabled()) {\n    \/\/ check for nan values in result\n  }","__index_level_0__":3394}
+{"text":"Next, we check the outputs of the function after `call_function` is done. If the number of outputs is 0, there are no following nodes to be executed so we can safely return. This is the case of the `AccumulateGrad` node associated with the leaf nodes.","__index_level_0__":3396}
+{"text":" Also, the check for `NaN` values in the gradients is done here if requested.\n```c++","__index_level_0__":3397}
+{"text":"  std::lock_guard<std::mutex> lock(graph_task->mutex_);\n  for (const auto i : c10::irange(num_outputs)) {\n    auto& output = outputs[i];\n    const auto& next = fn.next_edge(i);","__index_level_0__":3398}
+{"text":"    if (!next.is_valid()) continue;","__index_level_0__":3399}
+{"text":"We have now executed a `grad_fn` that has returned one gradient per each of the associated forward pass function inputs. As we saw in the [previous blog post](https:\/\/pytorch.org\/blog\/computational-graphs-constructed-in-pytorch\/#linking-nodes-together), we have an `Edge` object per each of these input tensors, and the `grad_fn` of the function producing them in the forward pass. Essentially, Output[0] of the node in the backward pass, corresponds to the first argument of the forward pass associated function. Figure 4 shows how the outputs of a backward function are related to the inputs of the forward function. See that the outputs of `grad_fn C` are the gradients of `z` w.r.t. the inputs of `Function C`","__index_level_0__":3402}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/forward-backward-function-fig-4.png\" width=\"100%\">\n<\/p>","__index_level_0__":3403}
+{"text":"<p align = \"center\">\nFigure 4: Correspondence between forward and backward functions inputs and outputs\n<\/p>","__index_level_0__":3404}
+{"text":"We now iterate through these edges and check if the associated functions are ready to be executed.","__index_level_0__":3405}
+{"text":"```c++\n \/\/ Check if the next function is ready to be computed\n    bool is_ready = false;\n    auto& dependencies = graph_task->dependencies_;\n    auto it = dependencies.find(next.function.get());","__index_level_0__":3406}
+{"text":"    if (it == dependencies.end()) {\n      auto name = next.function->name();\n      throw std::runtime_error(std::string(\"dependency not found for \") + name);\n    } else if (--it->second == 0) {\n      dependencies.erase(it);\n      is_ready = true;\n    }","__index_level_0__":3407}
+{"text":"    auto& not_ready = graph_task->not_ready_;\n    auto not_ready_it = not_ready.find(next.function.get());","__index_level_0__":3408}
+{"text":"For this, we check the `graph_task->dependencies_` map. We decrement the counter, and if it reaches 0, we mark the function pointed by the edge ready to be executed. Following, we prepare the input buffers of the tasks indicated by the next edges.","__index_level_0__":3410}
+{"text":"```c++\n    if (not_ready_it == not_ready.end()) {\n      if (!exec_info_.empty()) {\n        \/\/ Skip functions that aren't supposed to be executed\n      }","__index_level_0__":3411}
+{"text":"      \/\/ Creates an InputBuffer and moves the output to the corresponding input position\n      InputBuffer input_buffer(next.function->num_inputs());\n      input_buffer.add(next.input_nr,\n                       std::move(output),\n                       opt_parent_stream,\n                       opt_next_stream);","__index_level_0__":3412}
+{"text":"      if (is_ready) {\n        auto queue = ready_queue(cpu_ready_queue, input_buffer.device());\n        queue->push(\n            NodeTask(graph_task, next.function, std::move(input_buffer)));\n      } else {\n        not_ready.emplace(next.function.get(), std::move(input_buffer));\n      }","__index_level_0__":3413}
+{"text":"Here, we look for the task in the `graph_task->not_ready_` map. If it is not present, we create a new `InputBuffer` object and set the current output in the `input_nr` position of the buffer associated with the edge. If the task is ready to be executed, we enqueue it in the appropriate device `ready_queue` and complete the execution. However, if the task is not ready and we have seen it before, it is present in the `not_ready_map_`.","__index_level_0__":3415}
+{"text":"```c++\n    } else {\n      \/\/ The function already has a buffer\n      auto &input_buffer = not_ready_it->second;\n      \/\/ Accumulates into buffer\n      input_buffer.add(next.input_nr,\n                       std::move(output),\n                       opt_parent_stream,\n                       opt_next_stream);\n      if (is_ready) {\n        auto queue = ready_queue(cpu_ready_queue, input_buffer.device());\n        queue->push(NodeTask(graph_task, next.function, std::move(input_buffer)));\n        not_ready.erase(not_ready_it);\n      }\n    }\n  }\n}","__index_level_0__":3416}
+{"text":"In this case, we accumulate the output in the existing `input_buffer` instead of creating a new one. Once all the tasks are processed, the worker thread exits the loop and complete.\nAll this process is summarized in the animation in Figure 5. We see how a thread peeks at the tasks in the ready queue and decrements the next nodes' dependencies, unlocking them for execution.","__index_level_0__":3418}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/computation-animation-fig-5.gif\" width=\"100%\">\n<\/p>","__index_level_0__":3419}
+{"text":"<p align = \"center\">\nFigure 5: Animation of the execution of the computational graph\n<\/p>","__index_level_0__":3420}
+{"text":"## Flow with Reentrant Backward","__index_level_0__":3421}
+{"text":"As we saw above, the reentrant backward problem is when the currently executed function does a nested call to `backward`. When this happens, the thread running this function goes all the way down to `execute_with_graph_task` as in the non-reentrant case, but here is when things are different.","__index_level_0__":3422}
+{"text":"```c++\nc10::intrusive_ptr<at::ivalue::Future> Engine::execute_with_graph_task(\n    const std::shared_ptr<GraphTask>& graph_task,\n    std::shared_ptr<Node> graph_root,\n    InputBuffer&& input_buffer) {","__index_level_0__":3423}
+{"text":"  initialize_device_threads_pool();\n  \/\/ Lock mutex for GraphTask.\n  std::unique_lock<std::mutex> lock(graph_task->mutex_);","__index_level_0__":3424}
+{"text":"  auto queue = ready_queue(graph_task->cpu_ready_queue_, input_buffer.device());","__index_level_0__":3425}
+{"text":"  if (worker_device == NO_DEVICE) {\n    \/\/Regular case\n  } else {\n    \/\/ If worker_device is any devices (i.e. CPU, CUDA): this is a re-entrant\n    \/\/    backward call from that device.\n    graph_task->owner_ = worker_device;","__index_level_0__":3426}
+{"text":"    \/\/ Now that all the non-thread safe fields of the graph_task have been populated,\n    \/\/ we can enqueue it.\n    queue->push(NodeTask(graph_task, std::move(graph_root), std::move(input_buffer)));","__index_level_0__":3427}
+{"text":"    if (current_depth >= max_recursion_depth_) {\n      \/\/ If reached the max depth, switch to a different thread\n      add_thread_pool_task(graph_task);\n    } else {\n      ++total_depth;\n      ++current_depth;\n      lock.unlock();\n      thread_main(graph_task);\n      --current_depth;\n      --total_depth;\n    }\n  }\n  return graph_task->future_result_;\n}","__index_level_0__":3428}
+{"text":"Here, `execute_with_graph_task` detects this as a reentrant call and then looks for the current number of nested calls. If it exceeds the limit, we create a new thread to take care of the execution of this graph, and if not, we execute this reentrant call regularly.\nThe limit of nested calls was originally set to avoid stack overflow due to reentrant calls creating very large call stacks. However, the number was further reduced when sanitizer tests were added because of the maximum amount of locks a thread can hold at a given moment. This can be seen in [`torch\/csrc\/autograd\/engine.h`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.h#L36-L42).","__index_level_0__":3430}
+{"text":"\nWhen this maximum depth is exceeded, a new thread is created with the [`add_thread_pool_task`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L1239-L1255) function.","__index_level_0__":3431}
+{"text":"```c++\nvoid Engine::add_thread_pool_task(const std::weak_ptr<GraphTask>& graph_task) {\n  std::unique_lock<std::mutex> lck(thread_pool_shared_->mutex_);\n  \/\/ if we have pending graph_task objects to be processed, create a worker.\n   bool create_thread = (thread_pool_shared_->num_workers_ <= thread_pool_shared_->graphtasks_queue_.size());\n  thread_pool_shared_->graphtasks_queue_.push(graph_task);","__index_level_0__":3432}
+{"text":"\n  lck.unlock();\n  if (create_thread) {\n    std::thread t(&Engine::reentrant_thread_init, this);\n    t.detach();\n  }","__index_level_0__":3433}
+{"text":"  thread_pool_shared_->work_.notify_one();\n}","__index_level_0__":3434}
+{"text":"Before going in-depth, let's look at the `thread_pool_shared_` object in the [`Engine`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.h#L421) which manages all the information related to the threads associated to the reentrant backward calls.","__index_level_0__":3437}
+{"text":"```c++\n  struct ThreadPoolShared {\n    unsigned int num_workers_;\n    std::condition_variable work_;\n    std::mutex mutex_;\n    std::queue<std::weak_ptr<GraphTask>> graphtasks_queue_;","__index_level_0__":3438}
+{"text":"    \/\/ NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)\n    ThreadPoolShared() : num_workers_(0) {}\n };","__index_level_0__":3439}
+{"text":"[`ThreadPoolShared`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.h#L398-L414) is a simple container holding a queue of `GraphTask` objects with synchronization mechanisms and the number of current workers.","__index_level_0__":3442}
+{"text":"Now it is easy to understand how `add_thread_pool_task` creates a thread when there are `graph_task` objects enqueued and insufficient workers to process them.","__index_level_0__":3443}
+{"text":"`add_thread_pool_task` initializes a thread by executing [`reentrant_thread_init`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L471-L493)","__index_level_0__":3444}
+{"text":"```c++\nvoid Engine::reentrant_thread_init() {\n  at::init_num_threads();\n  auto tp_shared = thread_pool_shared_;\n  while(true) {\n    std::unique_lock<std::mutex> lk(tp_shared->mutex_);\n    ++thread_pool_shared_->num_workers_;\n    tp_shared->work_.wait(lk, [&tp_shared]{ return !tp_shared->graphtasks_queue_.empty();});\n    --thread_pool_shared_->num_workers_;\n    auto task = tp_shared->graphtasks_queue_.front();\n    tp_shared->graphtasks_queue_.pop();\n    lk.unlock();\n    std::shared_ptr<GraphTask> graph_task;\n    if (!(graph_task = task.lock())) {\n      continue;\n    }\n    set_device(graph_task->owner_);\n    \/\/ set the local_ready_queue to the ready queue on the graph_task->owner_ device\n    local_ready_queue = ready_queue_by_index(graph_task->cpu_ready_queue_, graph_task->owner_);\n    total_depth = graph_task->reentrant_depth_;\n    thread_main(graph_task);\n  }\n}","__index_level_0__":3445}
+{"text":"The code is straightforward. The newly created thread waits on the `thread_pool_shared->graphtasks_queue_` for reentrant backward graphs to be available and executes them. Notice that this thread uses the task-ready queue associated with the device of the thread that started this call by accessing the `graph_task->owner_` field set in the [`execute_with_graph_task`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L1092) function.  ","__index_level_0__":3448}
+{"text":"## Error Handling","__index_level_0__":3449}
+{"text":"Whenever an error happens in one of the worker threads. It will be propagated to the `backward` calling thread.","__index_level_0__":3450}
+{"text":"To achieve this, there is a try\/catch block in the [`thread_main`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L415-L438) that catches any exception in the `Node` function call and sets it to the associated `GraphTask` object.","__index_level_0__":3451}
+{"text":"\n```c++\n       try {\n          \u2026\n          GraphTaskGuard guard(local_graph_task);\n          NodeGuard ndguard(task.fn_);\n          {\n            evaluate_function(\n               \u2026\n          }\n        } catch (std::exception& e) {\n          thread_on_exception(local_graph_task, task.fn_, e);\n        }\n      }\n    }","__index_level_0__":3452}
+{"text":"[`thread_on_exception`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L495-L500) and the [functions it calls](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/torch\/csrc\/autograd\/engine.cpp#L605-L621) end up setting the exception in the `local_graph_task` object.","__index_level_0__":3454}
+{"text":"```c++\nvoid Engine::thread_on_exception(\n    std::shared_ptr<GraphTask> graph_task,\n    const std::shared_ptr<Node>& fn,\n    std::exception& e) {\n  graph_task->set_exception(std::current_exception(), fn);\n}","__index_level_0__":3455}
+{"text":"void GraphTask::set_exception_without_signal(const std::shared_ptr<Node>& fn) {\n  if (!has_error_.exchange(true)) {\n    if (AnomalyMode::is_enabled() && fn) {\n      fn->metadata()->print_stack(fn->name());\n    }\n  }\n}","__index_level_0__":3456}
+{"text":"void GraphTask::set_exception(\n    std::exception_ptr eptr,\n    const std::shared_ptr<Node>& fn) {\n  set_exception_without_signal(fn);\n  if (!future_completed_.exchange(true)) {\n    \/\/ NOLINTNEXTLINE(performance-move-const-arg)\n    future_result_->setError(std::move(eptr));\n  }\n}","__index_level_0__":3457}
+{"text":"In `set_exception` it sets the `has_error_` flag to `true` and it calls the [`setError`]()\nfunction of the [`future_result_`](https:\/\/github.com\/pytorch\/pytorch\/blob\/bc2c6edaf163b1a1330e37a6e34caf8c553e4755\/aten\/src\/ATen\/core\/ivalue_inl.h#L770-L1322) object. This will make the error to be re-thrown at the caller thread when `future_result_->value()` is accessed.","__index_level_0__":3459}
+{"text":"```c++\n IValue value() {\n    std::unique_lock<std::mutex> lock(mutex_);\n    AT_ASSERT(completed());\n    if (eptr_) {\n      std::rethrow_exception(eptr_);\n    }\n    return value_;\n  }","__index_level_0__":3460}
+{"text":"# Closing Remarks","__index_level_0__":3462}
+{"text":"This has been the last post of this series covering how PyTorch does the auto differentiation. We hope you enjoyed reading it and that now you are familiar enough with PyTorch internals to start contributing in PyTorch development!\n \n source: https:\/\/pytorch.org\/blog\/how-computational-graphs-are-executed-in-pytorch\/ \n category: pytorch blogs","__index_level_0__":3463}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 1.6 released w\/ Native AMP Support, Microsoft joins as maintainers for Windows'\nauthor: Team PyTorch\n---","__index_level_0__":3464}
+{"text":"Today, we\u2019re announcing the availability of PyTorch 1.6, along with updated domain libraries. We are also excited to announce the team at [Microsoft is now maintaining Windows builds and binaries](https:\/\/pytorch.org\/blog\/microsoft-becomes-maintainer-of-the-windows-version-of-pytorch) and will also be supporting the community on GitHub as well as the PyTorch Windows discussion forums.","__index_level_0__":3465}
+{"text":"The PyTorch 1.6 release includes a number of new APIs, tools for performance improvement and profiling, as well as major updates to both distributed data parallel (DDP) and remote procedure call (RPC) based distributed training. \nA few of the highlights include: ","__index_level_0__":3466}
+{"text":"1. Automatic mixed precision (AMP) training is now natively supported and a stable feature (See [here](https:\/\/pytorch.org\/blog\/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision\/) for more details) - thanks for NVIDIA\u2019s contributions; \n2. Native TensorPipe support now added for tensor-aware, point-to-point communication primitives built specifically for machine learning; \n3. Added support for complex tensors to the frontend API surface;\n4. New profiling tools providing tensor-level memory consumption information;\n5. Numerous improvements and new features for both distributed data parallel (DDP) training and the remote procedural call (RPC) packages.","__index_level_0__":3467}
+{"text":"Additionally, from this release onward, features will be classified as Stable, Beta and Prototype. Prototype features are not included as part of the binary distribution and are instead available through either building from source, using nightlies or via compiler flag. You can learn more about what this change means in the post [here](https:\/\/pytorch.org\/blog\/pytorch-feature-classification-changes\/). You can also find the full release notes [here](https:\/\/github.com\/pytorch\/pytorch\/releases).  ","__index_level_0__":3468}
+{"text":"# Performance & Profiling","__index_level_0__":3469}
+{"text":"## [Stable] Automatic Mixed Precision (AMP) Training ","__index_level_0__":3470}
+{"text":"AMP allows users to easily enable automatic mixed precision training enabling higher performance and memory savings of up to 50% on Tensor Core GPUs. Using the natively supported `torch.cuda.amp` API, AMP provides convenience methods for mixed precision, where some operations use the `torch.float32 (float)` datatype and other operations use `torch.float16 (half)`. Some ops, like linear layers and convolutions, are much faster in `float16`. Other ops, like reductions, often require the dynamic range of `float32`. Mixed precision tries to match each op to its appropriate datatype.","__index_level_0__":3471}
+{"text":"* Design doc ([Link](https:\/\/github.com\/pytorch\/pytorch\/issues\/25081))\n* Documentation ([Link](https:\/\/pytorch.org\/docs\/stable\/amp.html))\n* Usage examples ([Link](https:\/\/pytorch.org\/docs\/stable\/notes\/amp_examples.html))","__index_level_0__":3472}
+{"text":"## [Beta] Fork\/Join Parallelism ","__index_level_0__":3473}
+{"text":"This release adds support for a language-level construct as well as runtime support for coarse-grained parallelism in TorchScript code. This support is useful for situations such as running models in an ensemble in parallel, or running bidirectional components of recurrent nets in parallel, and allows the ability to unlock the computational power of parallel architectures (e.g. many-core CPUs) for task level parallelism.","__index_level_0__":3474}
+{"text":"Parallel execution of TorchScript programs is enabled through two primitives: `torch.jit.fork` and `torch.jit.wait`. In the below example, we parallelize execution of `foo`:","__index_level_0__":3475}
+{"text":"```python\nimport torch\nfrom typing import List","__index_level_0__":3476}
+{"text":"def foo(x):\n    return torch.neg(x)","__index_level_0__":3477}
+{"text":"@torch.jit.script\ndef example(x):\n    futures = [torch.jit.fork(foo, x) for _ in range(100)]\n    results = [torch.jit.wait(future) for future in futures]\n    return torch.sum(torch.stack(results))","__index_level_0__":3478}
+{"text":"print(example(torch.ones([])))\n ```\n \n* Documentation ([Link](https:\/\/pytorch.org\/docs\/stable\/jit.html))","__index_level_0__":3479}
+{"text":"## [Beta] Memory Profiler ","__index_level_0__":3480}
+{"text":"The `torch.autograd.profiler` API now includes a memory profiler that lets you inspect the tensor memory cost of different operators inside your CPU and GPU models.","__index_level_0__":3481}
+{"text":"Here is an example usage of the API:","__index_level_0__":3482}
+{"text":"```python\nimport torch\nimport torchvision.models as models\nimport torch.autograd.profiler as profiler","__index_level_0__":3483}
+{"text":"model = models.resnet18()\ninputs = torch.randn(5, 3, 224, 224)\nwith profiler.profile(profile_memory=True, record_shapes=True) as prof:\n    model(inputs)","__index_level_0__":3484}
+{"text":"# NOTE: some columns were removed for brevity\nprint(prof.key_averages().table(sort_by=\"self_cpu_memory_usage\", row_limit=10))\n# ---------------------------  ---------------  ---------------  ---------------\n# Name                         CPU Mem          Self CPU Mem     Number of Calls\n# ---------------------------  ---------------  ---------------  ---------------\n# empty                        94.79 Mb         94.79 Mb         123\n# resize_                      11.48 Mb         11.48 Mb         2\n# addmm                        19.53 Kb         19.53 Kb         1\n# empty_strided                4 b              4 b              1\n# conv2d                       47.37 Mb         0 b              20\n# ---------------------------  ---------------  ---------------  ---------------\n ```","__index_level_0__":3485}
+{"text":"* PR ([Link](https:\/\/github.com\/pytorch\/pytorch\/pull\/37775))\n* Documentation ([Link](https:\/\/pytorch.org\/docs\/stable\/autograd.html#profiler))","__index_level_0__":3486}
+{"text":"# Distributed Training & RPC ","__index_level_0__":3487}
+{"text":"## [Beta] TensorPipe backend for RPC","__index_level_0__":3488}
+{"text":"PyTorch 1.6 introduces a new backend for the RPC module which leverages the TensorPipe library, a tensor-aware point-to-point communication primitive targeted at machine learning, intended to complement the current primitives for distributed training in PyTorch (Gloo, MPI, ...) which are collective and blocking. The pairwise and asynchronous nature of TensorPipe lends itself to new networking paradigms that go beyond data parallel: client-server approaches (e.g., parameter server for embeddings, actor-learner separation in Impala-style RL, ...) and model and pipeline parallel training (think GPipe), gossip SGD, etc.","__index_level_0__":3489}
+{"text":"```python\n# One-line change needed to opt in\ntorch.distributed.rpc.init_rpc(\n    ...\n    backend=torch.distributed.rpc.BackendType.TENSORPIPE,\n)","__index_level_0__":3490}
+{"text":"# No changes to the rest of the RPC API\ntorch.distributed.rpc.rpc_sync(...)\n```","__index_level_0__":3491}
+{"text":"* Design doc ([Link](https:\/\/github.com\/pytorch\/pytorch\/issues\/35251))\n* Documentation ([Link](https:\/\/pytorch.org\/docs\/stable\/rpc\/index.html))","__index_level_0__":3492}
+{"text":"## [Beta] DDP+RPC ","__index_level_0__":3493}
+{"text":"PyTorch Distributed supports two powerful paradigms: DDP for full sync data parallel training of models and the RPC framework which allows for distributed model parallelism. Previously, these two features worked independently and users couldn\u2019t mix and match these to try out hybrid parallelism paradigms.","__index_level_0__":3494}
+{"text":"Starting in PyTorch 1.6, we\u2019ve enabled DDP and RPC to work together seamlessly so that users can combine these two techniques to achieve both data parallelism and model parallelism. An example is where users would like to place large embedding tables on parameter servers and use the RPC framework for embedding lookups, but store smaller dense parameters on trainers and use DDP to synchronize the dense parameters. Below is a simple code snippet. ","__index_level_0__":3495}
+{"text":"```python\n\/\/ On each trainer","__index_level_0__":3496}
+{"text":"remote_emb = create_emb(on=\"ps\", ...)\nddp_model = DDP(dense_model)","__index_level_0__":3497}
+{"text":"for data in batch:\n   with torch.distributed.autograd.context():\n      res = remote_emb(data)\n      loss = ddp_model(res)\n      torch.distributed.autograd.backward([loss])\n```","__index_level_0__":3498}
+{"text":"* DDP+RPC Tutorial ([Link](https:\/\/pytorch.org\/tutorials\/advanced\/rpc_ddp_tutorial.html))\n* Documentation ([Link](https:\/\/pytorch.org\/docs\/stable\/rpc\/index.html))\n* Usage Examples ([Link](https:\/\/github.com\/pytorch\/examples\/pull\/800))","__index_level_0__":3499}
+{"text":"## [Beta] RPC - Asynchronous User Functions","__index_level_0__":3500}
+{"text":"RPC Asynchronous User Functions supports the ability to yield and resume on the server side when executing a user-defined function. Prior to this feature, when a callee processes a request, one RPC thread waits until the user function returns. If the user function contains IO (e.g., nested RPC) or signaling (e.g., waiting for another request to unblock), the corresponding RPC thread would sit idle waiting for these events. As a result, some applications have to use a very large number of threads and send additional RPC requests, which can potentially lead to performance degradation. To make a user function yield on such events, applications need to: 1) Decorate the function with the `@rpc.functions.async_execution` decorator; and 2) Let the function return a `torch.futures.Future` and install the resume logic as callbacks on the `Future` object. See below for an example:","__index_level_0__":3501}
+{"text":"\n```python\n@rpc.functions.async_execution\ndef async_add_chained(to, x, y, z):\n    return rpc.rpc_async(to, torch.add, args=(x, y)).then(\n        lambda fut: fut.wait() + z\n    )","__index_level_0__":3502}
+{"text":"ret = rpc.rpc_sync(\n    \"worker1\", \n    async_add_chained, \n    args=(\"worker2\", torch.ones(2), 1, 1)\n)\n        \nprint(ret)  # prints tensor([3., 3.])\n```","__index_level_0__":3503}
+{"text":"* Tutorial for performant batch RPC using Asynchronous User Functions ([Link](https:\/\/github.com\/pytorch\/tutorials\/blob\/release\/1.6\/intermediate_source\/rpc_async_execution.rst))\n* Documentation ([Link](https:\/\/pytorch.org\/docs\/stable\/rpc.html#torch.distributed.rpc.functions.async_execution))\n* Usage examples ([Link](https:\/\/github.com\/pytorch\/examples\/tree\/master\/distributed\/rpc\/batch))","__index_level_0__":3504}
+{"text":"# Frontend API Updates","__index_level_0__":3505}
+{"text":"## [Beta] Complex Numbers ","__index_level_0__":3506}
+{"text":"The PyTorch 1.6 release brings beta level support for complex tensors including torch.complex64 and torch.complex128 dtypes. A complex number is a number that can be expressed in the form a + bj, where a and b are real numbers, and j is a solution of the equation x^2 = \u22121. Complex numbers frequently occur in mathematics and engineering, especially in signal processing and the area of complex neural networks is an active area of research. The beta release of complex tensors will support common PyTorch and complex tensor functionality, plus functions needed by Torchaudio, ESPnet and others. While this is an early version of this feature, and we expect it to improve over time, the overall goal is provide a NumPy compatible user experience that leverages PyTorch\u2019s ability to run on accelerators and work with autograd to better support the scientific community. ","__index_level_0__":3507}
+{"text":"# Mobile Updates","__index_level_0__":3508}
+{"text":"PyTorch 1.6 brings increased performance and general stability for mobile on-device inference. We squashed a few bugs, continued maintenance and added few new features while improving fp32 and int8 performance on a large variety of ML model inference on CPU backend.","__index_level_0__":3509}
+{"text":"## [Beta] Mobile Features and Performance ","__index_level_0__":3510}
+{"text":"* Stateless and stateful XNNPACK Conv and Linear operators\n* Stateless MaxPool2d + JIT optimization passes\n* JIT pass optimizations: Conv + BatchNorm fusion, graph rewrite to replace conv2d\/linear with xnnpack ops, relu\/hardtanh fusion, dropout removal\n* QNNPACK integration removes requantization scale constraint\n* Per-channel quantization for conv, linear and dynamic linear\n* Disable tracing for mobile client to save ~600 KB on full-jit builds","__index_level_0__":3511}
+{"text":"# Updated Domain Libraries","__index_level_0__":3512}
+{"text":"## torchvision 0.7 ","__index_level_0__":3513}
+{"text":"torchvision 0.7 introduces two new pretrained semantic segmentation models, [FCN ResNet50](https:\/\/arxiv.org\/abs\/1411.4038) and [DeepLabV3 ResNet50](https:\/\/arxiv.org\/abs\/1706.05587), both trained on COCO and using smaller memory footprints than the ResNet101 backbone. We also introduced support for AMP (Automatic Mixed Precision) autocasting for torchvision models and operators, which automatically selects the floating point precision for different GPU operations to improve performance while maintaining accuracy. ","__index_level_0__":3514}
+{"text":"* Release notes ([Link](https:\/\/github.com\/pytorch\/vision\/releases))","__index_level_0__":3515}
+{"text":"## torchaudio 0.6","__index_level_0__":3516}
+{"text":"torchaudio now officially supports Windows. This release also introduces a new model module (with wav2letter included), new functionals (contrast, cvm, dcshift, overdrive, vad, phaser, flanger, biquad), datasets (GTZAN, CMU), and a new optional sox backend with support for TorchScript.","__index_level_0__":3517}
+{"text":"* Release notes ([Link](https:\/\/github.com\/pytorch\/audio\/releases))","__index_level_0__":3518}
+{"text":"# Additional updates","__index_level_0__":3519}
+{"text":"## HACKATHON","__index_level_0__":3520}
+{"text":"The Global PyTorch Summer Hackathon is back! This year, teams can compete in three categories virtually:","__index_level_0__":3521}
+{"text":"  1. **PyTorch Developer Tools:** Tools or libraries designed to improve productivity and efficiency of PyTorch for researchers and developers\n  2. **Web\/Mobile Applications powered by PyTorch:** Applications with web\/mobile interfaces and\/or embedded devices powered by PyTorch \n  3. **PyTorch Responsible AI Development Tools:** Tools, libraries, or web\/mobile apps for responsible AI development","__index_level_0__":3522}
+{"text":"This is a great opportunity to connect with the community and practice your machine learning skills. ","__index_level_0__":3523}
+{"text":"* [Join the hackathon](http:\/\/pytorch2020.devpost.com\/)\n* [Watch educational videos](https:\/\/www.youtube.com\/pytorch)","__index_level_0__":3524}
+{"text":"\n## LPCV Challenge","__index_level_0__":3525}
+{"text":"The [2020 CVPR Low-Power Vision Challenge (LPCV) - Online Track for UAV video](https:\/\/lpcv.ai\/2020CVPR\/video-track) submission deadline is coming up shortly. You have until July 31, 2020 to build a system that can discover and recognize characters in video captured by an unmanned aerial vehicle (UAV) accurately using PyTorch and Raspberry Pi 3B+. ","__index_level_0__":3526}
+{"text":"## Prototype Features","__index_level_0__":3527}
+{"text":"To reiterate, Prototype features in PyTorch are early features that we are looking to gather feedback on, gauge the usefulness of and improve ahead of graduating them to Beta or Stable. The following features are not part of the PyTorch 1.6 release and instead are available in nightlies with separate docs\/tutorials to help facilitate early usage and feedback. ","__index_level_0__":3528}
+{"text":"#### Distributed RPC\/Profiler\nAllow users to profile training jobs that use `torch.distributed.rpc` using the autograd profiler, and remotely invoke the profiler in order to collect profiling information across different nodes. The RFC can be found [here](https:\/\/github.com\/pytorch\/pytorch\/issues\/39675) and a short recipe on how to use this feature can be found [here](https:\/\/github.com\/pytorch\/tutorials\/tree\/master\/prototype_source).","__index_level_0__":3529}
+{"text":"#### TorchScript Module Freezing\nModule Freezing is the process of inlining module parameters and attributes values into the TorchScript internal representation. Parameter and attribute values are treated as final value and they cannot be modified in the frozen module. The PR for this feature can be found [here](https:\/\/github.com\/pytorch\/pytorch\/pull\/32178) and a short tutorial on how to use this feature can be found [here](https:\/\/github.com\/pytorch\/tutorials\/tree\/master\/prototype_source).","__index_level_0__":3530}
+{"text":"#### Graph Mode Quantization\nEager mode quantization requires users to make changes to their model, including explicitly quantizing activations, module fusion, rewriting use of torch ops with Functional Modules and quantization of functionals are not supported. If we can trace or script the model, then the quantization can be done automatically with graph mode quantization without any of the complexities in eager mode, and it is configurable through a `qconfig_dict`. A tutorial on how to use this feature can be found [here](https:\/\/github.com\/pytorch\/tutorials\/tree\/master\/prototype_source).","__index_level_0__":3531}
+{"text":"#### Quantization Numerical Suite\nQuantization is good when it works, but it\u2019s difficult to know what's wrong when it doesn't satisfy the expected accuracy. A prototype is now available for a Numerical Suite that measures comparison statistics between quantized modules and float modules. This is available to test using eager mode and on CPU only with more support coming. A tutorial on how to use this feature can be found [here](https:\/\/github.com\/pytorch\/tutorials\/tree\/master\/prototype_source).","__index_level_0__":3532}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.6-released\/ \n category: pytorch blogs","__index_level_0__":3534}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Accelerating Large Language Models with Accelerated Transformers\"\nauthor: Lucas Pasqualin, Driss Guessous, Christian Puhrsch, Bertrand Maher, Michael Gschwind\n---","__index_level_0__":3535}
+{"text":"**TL;DR.** We show how to use Accelerated PyTorch 2.0 Transformers and the newly introduced `torch.compile()` method to accelerate Large Language Models on the example of [nanoGPT](https:\/\/github.com\/karpathy\/nanoGPT), a compact open-source implementation of the GPT model from Andrej Karpathy. Using the new [scaled dot product attention operator](https:\/\/pytorch.org\/docs\/master\/generated\/torch.nn.functional.scaled_dot_product_attention.html) introduced with Accelerated PT2 Transformers, we select the flash_attention custom kernel and achieve faster training time per batch (measured with Nvidia A100 GPUs), going from a ~143ms\/batch baseline to ~113 ms\/batch. In addition, the enhanced implementation using the SDPA operator offers better numerical stability. Finally, further optimizations are achieved using padded inputs, which when combined with flash attention lead to ~87ms\/batch.","__index_level_0__":3536}
+{"text":"Recent times have seen exponential adoption of large language models (LLMs) and Generative AI in everyday life. Tightly coupled with these ever-growing models is the ever-growing training cost - in terms of both time and hardware utilization. The PyTorch team has tackled these challenges head on with [Accelerated PyTorch 2 Transformers](https:\/\/pytorch.org\/blog\/accelerated-pytorch-2\/) (previously known as \u201cBetter Transformer\u201d) and JIT Compilation in [PyTorch 2.0](https:\/\/pytorch.org\/blog\/pytorch-2.0-release\/).","__index_level_0__":3537}
+{"text":"In this blog post, we explore training optimizations gained by utilizing custom kernel implementations of SDPA - also known as scaled dot product attention - a critical layer in transformer models. The custom kernel for SDPA replaces several discrete sequential operations with one globally optimized kernel which avoids allocating a large amount of intermediate CUDA memory. This approach offers a number of advantages, including but not limited to:  higher performance computation of SDPA by reducing memory bandwidth bottleneck, reduced memory footprint to support larger batch sizes, and finally added numerical stability by prescaling input tensors. These optimizations are demonstrated on nanoGPT, an open-source implementation of GPT from Andrej Karpathy.","__index_level_0__":3538}
+{"text":"\n## Background ","__index_level_0__":3539}
+{"text":"Scaled dot product attention is the fundamental building block of multihead attention, as introduced in [\u201cAttention is All You Need\u201d](https:\/\/arxiv.org\/abs\/1706.03762), and has a wide range of applications in LLM and Generative AI models.","__index_level_0__":3540}
+{"text":"![The Transformer model architecture](\/assets\/images\/2023-04-18-accelerating-large-language-models\/PyTorch_Better-Transformer_Figure-1.png){:style=\"max-height:800px; width:100%\"}   ","__index_level_0__":3541}
+{"text":"<small style=\"line-height: 1.1\"><em>**Figure 1:** The Transformer model architecture based on [\u201cAttention is All You Need\u201d](https:\/\/arxiv.org\/abs\/1706.03762). With the new PyTorch SDPA operator, Multi-Head Attention is efficiently implemented by a linear layer for the in-projection, the SDPA operator, and a linear layer for the out-projection.<\/em><\/small>","__index_level_0__":3542}
+{"text":"\nWith the new scaled_dot_product_attention operator, multihead attention can be implemented in just 3 steps: in projection with a linear layer, SDPA, and out projection with a linear layer.","__index_level_0__":3543}
+{"text":"```\n# In Projection\n# variable descriptions:\n# q,k,v = Query, Key, Value tensors\n# bsz = batch size\n# num_heads = Numner of heads for Multihead Attention\n# tgt_len = Target length\n# src_len = Source Length\n# head_dim: Head Dimension\n    q, k, v = _in_projection(query, key, value, q_proj_weight, k_proj_weight, v_proj_weight, b_q, b_k, b_v)\n    q = q.view(bsz, num_heads, tgt_len, head_dim)\n    k = k.view(bsz, num_heads, src_len, head_dim)\n    v = v.view(bsz, num_heads, src_len, head_dim)","__index_level_0__":3544}
+{"text":"    # Scaled Dot Product Attention\n    attn_output = scaled_dot_product_attention(q, k, v, attn_mask, dropout_p, is_causal)","__index_level_0__":3545}
+{"text":"    # Out Projection\n    attn_output = attn_output.permute(2, 0, 1, 3).contiguous().view(bsz * tgt_len, embed_dim)\n    attn_output = linear(attn_output, out_proj_weight, out_proj_bias)\n    attn_output = attn_output.view(tgt_len, bsz, attn_output.size(1))\n```","__index_level_0__":3546}
+{"text":"PyTorch 2. supports multiple different kernels optimized for specific use cases, with specific requirements. A kernel picker picks the best kernel for a particular combination of input parameters. If no optimized \"custom kernel\" for a particular combination of input parameters can be identified, the kernel picker selects a general kernel that can handle all input combinations. ","__index_level_0__":3547}
+{"text":"While future releases may extend this set of operators, PyTorch 2.0 launches with 3 implementations for the SDPA operator:","__index_level_0__":3548}
+{"text":"1. A generic kernel which implements the mathematical equation of SDPA in the function `sdpa_math()`\n2. An optimized kernel based on the paper \u201c[Flash Attention](https:\/\/arxiv.org\/abs\/2205.14135)\u201d, which supports evaluation of SDPA with 16 bit floating point data types on compute architecture SM80 (A100).\n3. An optimized kernel based on the paper \u201c[Self-Attention Does Not Need O(n^2) Memory](https:\/\/arxiv.org\/abs\/2112.0568)\" and implemented in [xFormer](https:\/\/github.com\/facebookresearch\/xformers), which supports both 32 and 16 bit floating data types on a wider range of architectures (SM40 and later). This blog post refers to this kernel as the `mem_efficient` kernel.","__index_level_0__":3549}
+{"text":"Note that both optimized kernels (two and three listed above), support a key padding mask and limit the supported attention mask to causal attention. Accelerated PyTorch 2.0 Transformers today only support the causal mask when it is specified using the `is_causal` boolean. When a mask is specified, the general-purpose kernel will be selected because it is too expensive to analyze the contents of a provided mask to determine if it is the causal mask. Additional explanations on the constraints for each kernel can be found in the [Accelerated PT2 Transformer blog](https:\/\/pytorch.org\/blog\/accelerated-pytorch-2\/).","__index_level_0__":3550}
+{"text":"\n## Enabling Accelerated Transformers with nanoGPT","__index_level_0__":3551}
+{"text":"The SDPA operator being a critical component of the GPT model,  we identified the open source nanoGPT model as an excellent candidate for both demonstrating the ease of implementation and benefits of PyTorch 2.0\u2019s Accelerated Transformers. The following demonstrates the exact process by which Accelerated Transformers was enabled on nanoGPT. ","__index_level_0__":3552}
+{"text":"This process largely revolves around replacing the existing SDPA implementation with the newly added F.scaled_dot_product_attention operator from [functional.py](https:\/\/github.com\/pytorch\/pytorch\/blob\/df14650f0b14b80db132b0c1797dc595fbee1054\/torch\/nn\/functional.py#L4834). This process can be easily adapted to enable the operator in many other LLMs. Alternatively, users can instead choose to call F.multi_head_attention_forward() or utilize the nn.MultiHeadAttention module directly where applicable. The following code snippets are adapted from Karpathy\u2019s nanoGPT repository.","__index_level_0__":3553}
+{"text":"\n### Step 1: Identify the existing SDPA implementation","__index_level_0__":3554}
+{"text":"In the case of nanoGPT, SDPA is implemented in the model\u2019s [CausalSelfAttention](https:\/\/github.com\/karpathy\/nanoGPT\/blob\/master\/model.py#L37) class. The original implementation at time of writing is adapted below for this post.","__index_level_0__":3555}
+{"text":"![The original implementation at time of writing](\/assets\/images\/2023-04-18-accelerating-large-language-models\/causal_attention_step_1.png){:style=\"max-height:800px; width:100%\"}   ","__index_level_0__":3556}
+{"text":"\n### Step 2: Replace with Torch\u2019s _scaled_dot_product_attention_","__index_level_0__":3557}
+{"text":"At this point we can note the following:","__index_level_0__":3558}
+{"text":"* Lines 36 - 42 define the mathematical implementation of SDPA which we are replacing\n* The mask applied on line 39 is no longer relevant since we are using scaled_dot_product_attention\u2019s `is_causal` flag.\n* The dropout layer used in line 41 is also now unnecessary. ","__index_level_0__":3559}
+{"text":"Swapping out the SDPA implementation for torch\u2019s scaled_dot_product_attention and removing the now redundant code yields the following implementation.","__index_level_0__":3560}
+{"text":"![Swapping out the SDPA implementation for torch\u2019s scaled_dot_product_attention and removing the now redundant code yields the following implementation.](\/assets\/images\/2023-04-18-accelerating-large-language-models\/causal_attention_step_2.png){:style=\"max-height:800px; width:100%\"}   ","__index_level_0__":3561}
+{"text":"\nAlternatively, the original mask can be passed into the `attn_mask` field however due to the mentioned kernel constraints that would limit the implementation to only support the generic `sdpa_math` kernel.","__index_level_0__":3562}
+{"text":"\n### Step 3 (Bonus): Faster matmuls with padding","__index_level_0__":3563}
+{"text":"On top of the performance improvements from SDPA, our analysis yielded a nice ancillary win.  In Andrej's words \"The most dramatic optimization to nanoGPT so far (~25% speedup) is to simply increase the vocab size from 50257 to 50304 (nearest multiple of 64).\"","__index_level_0__":3564}
+{"text":"\n![Tweet by Andrej Karpathy](\/assets\/images\/2023-04-18-accelerating-large-language-models\/tweet.png){:style=\"max-height:800px; width:100%; max-width:600px\"}   ","__index_level_0__":3565}
+{"text":"The vocab size determines the dimensions of matmuls in the output layer of GPT, and these are so large that they were taking a _majority_ of the time for the entire training loop!  We discovered that they were achieving performance significantly below the peak throughput achievable on the A100 GPU, and guessed from [NVIDIA's matmul documentation](https:\/\/docs.nvidia.com\/deeplearning\/performance\/dl-performance-matrix-multiplication\/index.html) that 64-element alignment would yield better results.  Indeed, padding these matmuls achieves nearly a 3x speedup!  The underlying cause is that unaligned memory accesses significantly reduce efficiency.  A deeper analysis can be found in [this Twitter thread](https:\/\/twitter.com\/cHHillee\/status\/1630274804795445248).","__index_level_0__":3566}
+{"text":"With this optimization we were able to further reduce training time from ~113 ms (using flash attention) to ~87 ms per batch.","__index_level_0__":3567}
+{"text":"\n## Results","__index_level_0__":3568}
+{"text":"The figure below demonstrates the performance gained using Pytorch custom kernels. Here are the exact figures:","__index_level_0__":3569}
+{"text":"* baseline (nanoGPT implementation):  ~143ms\n* sdpa_math (generic): ~134ms (6.71% faster)\n* `mem_efficient` kernel: ~119ms (20.16% faster)\n* `flash_attention` kernel: ~113ms (26.54% faster)\n* flash_attention + padded vocab:  ~87ms (64.37% faster)","__index_level_0__":3570}
+{"text":"All code was run on an 8 x NVIDIA Corporation A100 server with 80 GB HBM [A100 SXM4 80GB], and for the purpose of this experiment dropout was set to 0.","__index_level_0__":3571}
+{"text":"\n![Using scaled dot product attention with custom kernels and torch.compile delivers significant speedups for training large language models](\/assets\/images\/2023-04-18-accelerating-large-language-models\/PyTorch_Better-Transformer_Chart-2.png){:style=\"max-height:800px; width:100%\"}   ","__index_level_0__":3572}
+{"text":"\n<small style=\"line-height: 1.1\"><em>**Figure 2:** Using scaled dot product attention with custom kernels and torch.compile delivers significant speedups for training large language models, such as for [nanoGPT](https:\/\/github.com\/karpathy\/nanoGPT) shown here.<\/em><\/small>","__index_level_0__":3573}
+{"text":"\n## Enhancing Numerical Model Stability","__index_level_0__":3574}
+{"text":"In addition to being faster, PyTorch's implementation offers increased numerical stability by avoiding loss of precision in many execution scenarios. There is a great explanation [here](https:\/\/github.com\/bigscience-workshop\/Megatron-DeepSpeed\/pull\/118), but essentially the PyTorch implementation scales the Query and Key matrices _before_ multiplication, which is said to be more stable and avoid loss of precision. Because of the merged custom kernel architecture of SDPA, this scaling does not introduce additional overhead in the computation of the attention result.  In comparison, an implementation from the individual computational components would require separate pre-scaling at additional cost. For an additional explanation, see Appendix A.","__index_level_0__":3575}
+{"text":"\n### Improved Memory Consumption","__index_level_0__":3576}
+{"text":"Yet another large advantage of using the torch SDPA kernels is the reduced memory footprint, which allows for the utilization of larger batch sizes. The following chart compares the best validation loss after one hour of training for both flash attention and the baseline implementations of causal attention. As can be seen, the maximum batch size achieved with the baseline causal attention implementation (on 8 x NVIDIA Corporation A100 server with 80 GB HBM) was 24, significantly less then the maximum achieved with flash attention, which was 39.","__index_level_0__":3577}
+{"text":"![Using Flash Attention enables the usage of larger batch sizes](\/assets\/images\/2023-04-18-accelerating-large-language-models\/chart.png){:style=\"max-height:800px; width:100%\"}   ","__index_level_0__":3578}
+{"text":"\n<small style=\"line-height: 1.1\"><em>**Figure 3:** Using Flash Attention enables the usage of larger batch sizes, allowing users to achieve lower validation loss after one hour of training (smaller is better).<\/em><\/small>","__index_level_0__":3579}
+{"text":"\n## Conclusion","__index_level_0__":3580}
+{"text":"Accelerated PyTorch 2 Transformers were designed to make the training and production deployment of state-of-the-art transformer models affordable and integrated with PyTorch 2.0 model JIT compilation.  The newly introduced PyTorch SDPA operator provides improved performance for training Transformer models and is particularly valuable for the expensive Large Language Model training. In this post we demonstrate a number of optimizations on the exemplary nanoGPT model  including:","__index_level_0__":3581}
+{"text":"* Over 26% training speedup, when compared against the baseline with constant batch size\n* An additional speedup achieved with padded vocabulary, bringing the total optimization to approximately 64% compared to the baseline\n* Additional numerical stability","__index_level_0__":3583}
+{"text":"\n## Appendix A: Analyzing Attention Numeric Stability","__index_level_0__":3584}
+{"text":"In this section we provide a more in depth explanation of the previously mentioned enhanced numerical stability which is gained by prescaling SDPA\u2019s input vectors. The following is a simplified version of nanoGPT\u2019s mathematical implementation of SDPA. The important thing to note here is that the query undergoes matrix multiplication without being scaled.","__index_level_0__":3585}
+{"text":"```\n# nanoGPT implementation of SDPA\n# notice q (our query vector) is not scaled !\natt = (q @ k.transpose(-2, -1)) * (1.0 \/ math.sqrt(k.size(-1)))\natt = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))\natt = F.softmax(att, dim=-1)","__index_level_0__":3586}
+{"text":"# Dropout is set to 0, so we can safely ignore this line in the implementation# att = self.attn_dropout(att) ","__index_level_0__":3587}
+{"text":"y_nanogpt = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)\n```","__index_level_0__":3588}
+{"text":"The following is the equivalent mathematical implementation in torch\u2019s `scaled_dot_product_attention`.","__index_level_0__":3589}
+{"text":"```\n# PyTorch implementation of SDPA\nembed_size = q.size(-1)\nscaling_factor = math.sqrt(math.sqrt(embed_size))\nq = q \/ scaling_factor \t# notice q _is_ scaled here !","__index_level_0__":3590}
+{"text":"# same as above, but with scaling factor\natt = q @ (k.transpose(-2, -1) \/ scaling_factor)\natt = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))\natt = F.softmax(att0, dim=-1)","__index_level_0__":3591}
+{"text":"# Dropout is set to 0, so we can safely ignore this line in the implementation# att = self.attn_dropout(att) ","__index_level_0__":3592}
+{"text":"y_scale_before = att @ v\n```","__index_level_0__":3593}
+{"text":"Mathematically both approaches should be equivalent, however our experimentation shows that in practice we receive different results from each approach. ","__index_level_0__":3594}
+{"text":"Using the approach above, we verified `y_scale_before` matches the expected output from using the `scaled_dot_product_attention `method while `y_nanogpt` does not.","__index_level_0__":3595}
+{"text":"The `torch.allclose` method was used to test equivalence. Specifically, we showed that:","__index_level_0__":3596}
+{"text":"```\ny_sdpa = torch.nn.functional._scaled_dot_product_attention(\n\tq,\n\tk,\n\tv,\n\tattn_mask=self.bias[:,:,:T,:T] != 0,\n\tdropout_p=0.0,\n\tneed_attn_weights=False,\n\tis_causal=False,\n)","__index_level_0__":3597}
+{"text":"torch.allclose(y_sdpa, y_nanogpt) # False, indicating fp issues\ntorch.allclose(y_sdpa, y_scale_before) # True, as expected\n```","__index_level_0__":3598}
+{"text":"## Appendix B: Reproducing Experiment Results","__index_level_0__":3599}
+{"text":"Researchers seeking to reproduce these results should start with the following commit from Andrej\u2019s nanoGPT repository - **<span style=\"text-decoration:underline;\">b3c17c6c6a363357623f223aaa4a8b1e89d0a465<\/span>**. This commit was used as the baseline when measuring the per batch speed improvements. For results which include padded vocabulary optimizations (which yielded the most significant improvements to batch speed), use the following commit - **<span style=\"text-decoration:underline;\">77e7e04c2657846ddf30c1ca2dd9f7cbb93ddeab<\/span>**. From either checkout, selecting kernels for experimentation is made trivial with the use of the [torch.backends](https:\/\/pytorch.org\/docs\/stable\/backends.html) API. ","__index_level_0__":3600}
+{"text":"The desired kernel can be selected via a context manager:","__index_level_0__":3601}
+{"text":"```\nwith torch.backends.cuda.sdp_kernel (\n    enable_math = False,\n    enable_flash = False,\n    enable_mem_efficient = True\n):\n    train(model)\n``` \n source: https:\/\/pytorch.org\/blog\/accelerating-large-language-models\/ \n category: pytorch blogs","__index_level_0__":3602}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Straggler Mitigation On PyTorch DDP By Hierarchical SGD\"\nauthor: Yi Wang (Cruise AI), Rohan Varma (Meta AI)\n---","__index_level_0__":3603}
+{"text":"[PyTorch DDP](https:\/\/pytorch.org\/docs\/stable\/notes\/ddp.html) has been widely adopted across the industry for distributed training, which by default runs synchronous SGD to synchronize gradients across model replicas at every step. The performance of this technique is critical for fast iteration during model exploration as well as resource and cost saving. The performance is critical for fast iteration and cost saving of model development and exploration. To resolve a ubiquitous performance bottleneck introduced by slow nodes in large-scale training, Cruise and Meta co-developed a solution based on the [Hierarchical SGD](https:\/\/arxiv.org\/abs\/2007.13819) algorithm to significantly accelerate training in the presence of these stragglers.","__index_level_0__":3604}
+{"text":"\n## The Need For Straggler Mitigation","__index_level_0__":3605}
+{"text":"In DDP setup, a straggler problem can occur when one or more processes run much slower (\"stragglers\") than other processes. When this happens, all the processes have to wait for the stragglers before synchronizing gradients and completing the communication, which essentially bottlenecks distributed performance to the slowest worker.As a result, even for the cases of training relatively small models, the communication cost can still be a major performance bottleneck.","__index_level_0__":3606}
+{"text":"\n### Potential Causes of Stragglers","__index_level_0__":3607}
+{"text":"Severe straggler issues are usually caused by workload imbalance before synchronization, and many factors can contribute to this imbalance. For instance, some data loader workers in the distributed environment can become stragglers, because some input examples can be outliers in terms of the data size, or the data transfer of some examples can be drastically slowed down due to unstable network I\/O, or the on-the-fly data transformation costs can have a high variance.","__index_level_0__":3608}
+{"text":"Besides data loading, other phases before gradient synchronization can also cause stragglers, such as unbalanced workloads of embedding table lookup during the forward pass in recommendation systems.","__index_level_0__":3609}
+{"text":"\n### The Appearance of Stragglers","__index_level_0__":3610}
+{"text":"If we profile DDP training jobs that have stragglers, we can find that some processes may have much higher gradient synchronization costs (a.k.a., allreducing gradients) than other processes at a certain step. As a result, the distributed performance can be dominated by the communication cost even if the model size is very small. In this case, some processes run faster than the straggler(s) at a step, and hence they have to wait for the stragglers and spend a much longer time on allreduce.","__index_level_0__":3611}
+{"text":"The below shows screenshots of two trace files output by PyTorch profiler in a use case. Each screenshot profiles 3 steps.\n* The first screenshot shows that a process has a very high allreduce cost in both the first and the third steps, because this process reaches the synchronization phase earlier than the straggler(s), and it spends more time on waiting. On the other hand, the allreduce cost is relatively small in the second step, this suggests that 1) there is no straggler at this step; or 2) this process is the straggler among all the processes, so it does not need to wait for any other process.","__index_level_0__":3612}
+{"text":"\n![chart showing allreduce cost](\/assets\/images\/straggler-mitigation\/straggler-mitigation-1.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":3613}
+{"text":"<small style=\"line-height: 1.1\"><em>Both the 1st and the 3rd Steps Are Slowed Down by Stragglers<\/em><\/small>","__index_level_0__":3614}
+{"text":"\n* The second screenshot shows a normal case without stragglers. In this case, all the gradient synchronizations are relatively short.","__index_level_0__":3615}
+{"text":"\n![chart showing normal case without stragglers](\/assets\/images\/straggler-mitigation\/straggler-mitigation-2.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":3616}
+{"text":"<small style=\"line-height: 1.1\"><em>Normal Case Without Stragglers<\/em><\/small>","__index_level_0__":3617}
+{"text":"\n## Hierarchical SGD in PyTorch","__index_level_0__":3618}
+{"text":"Recently hierarchical SGD has been proposed to optimize the communication costs by mainly reducing the total amount of data transfer in large-scale distributed training, and multiple convergence analyses have been provided ([example](https:\/\/arxiv.org\/pdf\/2010.12998.pdf)). As a main novelty of this post, at Cruise we could leverage hierarchical SGD to mitigate stragglers, which may also occur on training relatively small models. Our implementation has been upstreamed by Cruise to PyTorch in early 2022.","__index_level_0__":3619}
+{"text":"\n### How Does Hierarchical SGD Work?","__index_level_0__":3620}
+{"text":"As the name implies, hierarchical SGD organizes all the processes into groups at different levels as a hierarchy, and runs synchronization by following the rules below:","__index_level_0__":3621}
+{"text":"* All the groups at the same level have the same number of processes, and the processes in these groups synchronize at the same frequency concurrently, where the synchronization period is pre-defined by the user.\n* The higher level a group is, the larger synchronization period is used, as the synchronization becomes more expensive.\n* When multiple overlapping groups are supposed to synchronize according to their periods, to reduce redundant synchronization and avoid data race across groups, only the highest-level group runs synchronization.","__index_level_0__":3622}
+{"text":"The following figure illustrates an example of 4-level hierarchy SGD among 16 processes on 8 machines, each of which has 2 GPUs:","__index_level_0__":3623}
+{"text":"1. **Level 1:** Each process runs mini-batch SGD locally;\n2. **Level 2:** Each 4-process group across 2 machines runs synchronization every 2 steps;\n3. **Level 3:** Each 8-process group across 4 machines runs synchronization every 4 steps;\n4. **Level 4:** The global process group of all 16 processes over 8 machines runs synchronization every 8 steps.","__index_level_0__":3624}
+{"text":"Particularly, when the step number can be divided by 8, only the synchronization at 3) is executed, and when the step number can be divided by 4 but not 8, only the synchronization at 2) is executed.","__index_level_0__":3625}
+{"text":"\n![An example of 4-level hierarchy SGD among 16 processes on 8 machines, each of which has 2 GPUs](\/assets\/images\/straggler-mitigation\/straggler-mitigation-3.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":3626}
+{"text":"\nIntuitively, hierarchical SGD can be viewed as an extension of [local SGD](https:\/\/core.ac.uk\/download\/pdf\/211998087.pdf), which only has a two-level hierarchy \u2013 every process runs mini-batch SGD locally and then synchronizes globally at a certain frequency. This can also help explain that, just like local SGD, hierarchical SGD synchronizes model parameters instead of gradients. Otherwise the gradient descent will be mathematically incorrect when the frequency is greater than 1.","__index_level_0__":3627}
+{"text":"\n### Why Can Hierarchical SGD Mitigate Stragglers?","__index_level_0__":3628}
+{"text":"The key insight here is that, when there is a random straggler, it only directly slows down a relatively small group of processes instead of all the processes. Next time another random straggler is very likely to slow down a different small group, and hence a hierarchy can help smooth out the straggler effect.","__index_level_0__":3629}
+{"text":"The example below assumes that there is a random straggler among totally 8 processes at every step. After 4 steps, vanilla DDP that runs synchronous SGD will be slowed down by straggler 4 times, because it runs global synchronization at every step. In contrast, hierarchical SGD runs synchronization with the groups of 4 processes after the first two steps, and then a global synchronization after another two steps. We can see that both the first two and the last two stragglers have a large overlap, and hence the performance loss can be mitigated.","__index_level_0__":3630}
+{"text":"\n![flow diagram](\/assets\/images\/straggler-mitigation\/straggler-mitigation-4.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":3631}
+{"text":"\nEssentially, the mitigation effect of this hierarchical SGD example actually is between local SGD at a frequency of every 2 steps and every 4 steps. The main advantage of hierarchical SGD over local SGD is a better convergence efficiency of the same global synchronization frequency, because hierarchical SGD allows more low-level synchronization. Moreover, it is possible for hierarchical SGD to provide a global synchronization frequency lower than local SGD with model parity, leading to a higher training performance, especially in a large-scale distributed training.","__index_level_0__":3632}
+{"text":"\n### Ease of Use","__index_level_0__":3633}
+{"text":"Straggler mitigation is not a novel study in distributed training. Multiple approaches have been proposed, such as [gossip SGD](https:\/\/arxiv.org\/pdf\/1705.09056.pdf), [data encoding](https:\/\/proceedings.neurips.cc\/paper\/2017\/file\/663772ea088360f95bac3dc7ffb841be-Paper.pdf), [gradient coding](http:\/\/proceedings.mlr.press\/v70\/tandon17a\/tandon17a.pdf), as well as some particularly designed for parameter-server architecture, including [backup workers](https:\/\/static.googleusercontent.com\/media\/research.google.com\/en\/\/pubs\/archive\/45187.pdf) and [stale synchronous parallel](http:\/\/www.cs.cmu.edu\/~seunghak\/SSPTable_NIPS2013.pdf). However, to the best of our knowledge, before this effort we have not found a good open-source PyTorch implementation of straggler mitigation that can work like a plugin to our training system at Cruise. In contrast, our implementation only requires the minimal changes \u2013 no need to modify the existing code or tune any existing hyperparameters. This is a very appealing advantage for industry users.","__index_level_0__":3634}
+{"text":"As the code example below shows, only a few lines need to be added to the setup of DDP model, and the training loop code can keep untouched. As explained previously, hierarchical SGD is an extended form of local SGD, so the enablement can be quite similar to local SGD (see PyTorch docs of [PostLocalSGDOptimizer](https:\/\/pytorch.org\/docs\/stable\/distributed.optim.html#torch.distributed.optim.PostLocalSGDOptimizer)):","__index_level_0__":3635}
+{"text":"1. Register a post-local SGD communication hook to run a warmup stage of fully synchronous SGD and defer hierarchical SGD.\n2. Create a post-local SGD optimizer that wraps an existing local optimizer and a hierarchical SGD configuration.","__index_level_0__":3636}
+{"text":"```\nimport torch.distributed.algorithms.model_averaging.hierarchical_model_averager as hierarchicalSGD\nfrom torch.distributed.algorithms.ddp_comm_hooks.post_localSGD_hook import (\n    PostLocalSGDState,\n    post_localSGD_hook,\n)\nfrom torch.distributed.optim import PostLocalSGDOptimizer","__index_level_0__":3637}
+{"text":"ddp_model = nn.parallel.DistributedDataParallel(\n    module=model,\n    device_ids=[rank],\n)","__index_level_0__":3638}
+{"text":"# Register a post-local SGD communication hook for the warmup.\nsubgroup, _ = torch.distributed.new_subgroups()\nstate = PostLocalSGDState(subgroup=subgroup, start_localSGD_iter=1_000)\nddp_model.register_comm_hook(state, post_localSGD_hook)","__index_level_0__":3639}
+{"text":"# Wraps the existing (local) optimizer to run hierarchical model averaging.\noptim = PostLocalSGDOptimizer(\n  optim=optim,\n  averager=hierarchicalSGD.HierarchicalModelAverager(\n    # The config runs a 4-level hierarchy SGD among 128 processes:\n    # 1) Each process runs mini-batch SGD locally;\n    # 2) Each 8-process group synchronize every 2 steps;\n    # 3) Each 32-process group synchronize every 4 steps;\n    # 4) All 128 processes synchronize every 8 steps.\n    period_group_size_dict=OrderedDict([(2, 8), (4, 32), (8, 128)]),\n    # Do not run hierarchical SGD until 1K steps for model parity.\n    warmup_steps=1_000)\n)\n```","__index_level_0__":3640}
+{"text":"### Algorithm Hyperparameters","__index_level_0__":3641}
+{"text":"Hierarchical SGD has two major hyperparameters: _period_group_size_dict_ and _warmup_steps_.","__index_level_0__":3642}
+{"text":"* **period_group_size_dict** is an ordered dictionary mapping from synchronization period to process group size, used for initializing process groups of different sizes in a hierarchy to synchronize parameters concurrently. A larger group is expected to use a larger synchronization period.\n* **warmup_steps** specifies a number of steps as the warmup stage to run synchronous SGD before hierarchical SGD. Similar to [post-local SGD](https:\/\/arxiv.org\/pdf\/1808.07217.pdf) algorithm, a warmup stage is usually recommended to achieve a higher accuracy. The value should be the same as _start_localSGD_iter_ arg used in _PostLocalSGDState_ when post_localSGD_hook is registered. Typically the warmup stage should at least cover the beginning of training when the loss is decreased drastically.","__index_level_0__":3643}
+{"text":"A subtle difference between the PyTorch implementation and the initial design proposed by relevant papers is that, after the warmup stage, by default the processes within each host still run intra-host gradient synchronization at every step. This is because that:","__index_level_0__":3644}
+{"text":"1. The intra-host communication is relatively cheap, and it can usually significantly accelerate the convergence;\n2. The intra-host group (of size 4 or 8 for most industry users) can usually be a good choice of the smallest group of processes that synchronize most frequently in hierarchical SGD. If the synchronization period is 1, then gradient synchronization is faster than model parameter synchronization (a.k.a., model averaging), because DDP automatically overlaps gradient synchronization and the backward pass.","__index_level_0__":3645}
+{"text":"Such intra-host gradient synchronization can be disabled by unsetting _post_local_gradient_allreduce_ arg in _PostLocalSGDState_.","__index_level_0__":3646}
+{"text":"\n## Demonstration","__index_level_0__":3647}
+{"text":"Now we demonstrate that hierarchical SGD can accelerate distributed training by mitigating stragglers.","__index_level_0__":3648}
+{"text":"\n### Experimental Setup","__index_level_0__":3649}
+{"text":"We compared the performance of hierarchical SGD against local SGD and synchronous SGD on [ResNet18](https:\/\/pytorch.org\/vision\/main\/models\/generated\/torchvision.models.resnet18.html) (model size: 45MB). Since the model is so small, the training is not bottlenecked by data transfer cost during synchronization. To avoid the noises incurred by data loading from remote storage, the input data was randomly simulated from memory. We varied the number of GPUs used by training from 64 to 256. The batch size per worker is 32, and the number of iterations of training is 1,000. Since we don\u2019t evaluate convergence efficiency in this set of experiments, warmup is not enabled.","__index_level_0__":3650}
+{"text":"We also emulated stragglers at a rate of 1% on 128 and 256 GPUs, and 2% on 64 GPUs, to make sure at least one stragglers at every step on average. These stragglers randomly appear on different CUDA devices. Each straggler stalls for 1 second besides the normal per-step training time (~55ms in our setup). This can be perceived as a practical scenario where 1% or 2% of input data are outliers in terms of the data pre-processing cost (I\/O and\/or data transformation on the fly) during training, and such cost is 20X+ larger than the average.","__index_level_0__":3651}
+{"text":"The code snippet below shows how a straggler can be emulated in the training loop. We applied it to a ResNet model, and it can be easily applied to the other models as well.","__index_level_0__":3652}
+{"text":"```\n     loss = loss_fn(y_pred, y)\n     # Emulate a straggler that lags for 1 second at a rate of 1%.\n     if random.randint(1, 100) == 1:\n         time.sleep(1)\n     loss.backward()\n     optimizer.step()\n```","__index_level_0__":3653}
+{"text":"The experiments are conducted on us-central1 GCP cluster. Each machine has 4 NVIDIA Tesla T4 GPUs with 16 GB memory per GPU, connected through a 32 Gbit\/s ethernet network. Each instance also features 96 vCPUs, 360 GB RAM.","__index_level_0__":3654}
+{"text":"\n<table class=\"table table-bordered\" style=\"max-width: 450px;\">\n  <tr>\n   <td>Architecture\n   <\/td>\n   <td>ResNet18 (45MB)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>Workers\n   <\/td>\n   <td>64, 128, 256\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>Backend\n   <\/td>\n   <td>NCCL\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>GPU\n   <\/td>\n   <td>Tesla T4, 16 GB memory\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>Batch size\n   <\/td>\n   <td>32 x ## of workers\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>Straggler Duration\n   <\/td>\n   <td>1 sec\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>Straggler Rate\n   <\/td>\n   <td>1% on 128 and 256 GPUs, 2% on 64 GPUs\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":3655}
+{"text":"\nWe used multiple configurations for both local SGD and hierarchical SGD. Local SGD runs global synchronization every 2, 4, and 8 steps, respectively.","__index_level_0__":3656}
+{"text":"We ran hierarchical SGD with the following configurations:","__index_level_0__":3657}
+{"text":"1. On 64 GPUs:\n    1. Each 8-process group, 32-process, and the global 64-process group synchronizes every 2, 4, and 8 steps, respectively. Denoted as \"_**HSGD 2-8,4-32,8-64**_\".\n    2. Each 32-process group and the global 64-process group synchronizes every 4 and 8 steps, respectively. Denoted as \"_**HSGD 4-32,8-64**_\".\n2. On 128 GPUs:\n    3. Each 8-process group, 32-process group, and the global 128-process group synchronizes every 2, 4, and 8 steps, respectively. Denoted as \"_**HSGD 2-8,4-32,8-128**_\".\n    4. Each 32-process group and the global 128-process group synchronizes every 4 and 8 steps, respectively. Denoted as \"_**HSGD 4-32,8-128**_\".\n3. On 256 GPUs:\n    5. Each 4-process group, 16-process group, 64-process group, and the global 256-process group synchronizes every 1, 2, 4, and 8 steps, respectively. Denoted as \"_**HSGD 1-4,2-16,4-64,8-256**_\".\n    6. Each 8-process group, 64-process group, and the global 256-process group synchronizes every 2, 4, and 8 steps. Denoted as \"_**HSGD 2-8,4-64,8-256**_\".\n    7. Each 16-process group and the global 256-process group synchronizes every 4 and 8 steps, respectively. Denoted as \"_**HSGD 4-16,8-256**_\".","__index_level_0__":3659}
+{"text":"\n### Experimental Results","__index_level_0__":3660}
+{"text":"The figures below show the speedups of different communication schemes against the baseline of synchronous SGD, with the emulated stragglers. We can make the following observations:","__index_level_0__":3661}
+{"text":"1. As expected, we can see that both hierarchical SGD and local SGD can achieve a higher speedup with a lower synchronization frequency.\n2. The speedups of the hierarchical SGD schemes are **2.08X-2.45X** on 64 GPUs, **2.57X-2.68X** on 128 GPUs, and **2.63X-3.25X** on 256 GPUs, respectively. This shows that hierarchical SGD can significantly mitigate stragglers, and such mitigation can be more effective at a larger scale.\n3. The performance of local SGD with the synchronization period of 2 steps and 8 steps can be perceived as the lower bound and upper bound of the experimented hierarchical SGD schemes, respectively. This is because the hierarchical SGD schemes synchronize less frequently than every 2 steps globally, but their low-level synchronization at small groups are the extra overheads in comparison with the global synchronization every 8 steps.","__index_level_0__":3662}
+{"text":"Overall, hierarchical SGD can provide a finer-grained trade-off between communication cost and model quality than local SGD. Therefore, when local SGD at a relatively large synchronization period like 8 or 4 cannot give a satisfactory convergence efficiency, hierarchical SGD can have a much better chance to achieve both a good speedup and a model parity.","__index_level_0__":3663}
+{"text":"Since only simulated data is used in the experiments, we did not demonstrate the model parity here, which in practice can be achieved in two ways:\n1. Tuning the hyperparameters including both hierarchy and warmup steps;\n2. For some cases, hierarchical SGD could lead to a slightly lower quality than the original model for the same number of training steps (i.e., lower convergence rate), but with a speedup like 2X+ per training step, it is still possible to achieve model parity with more steps but still less total training time.","__index_level_0__":3664}
+{"text":"\n![Speedups on 64 GPUs](\/assets\/images\/straggler-mitigation\/straggler-mitigation-5.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":3665}
+{"text":"![Speedups on 128 GPUs](\/assets\/images\/straggler-mitigation\/straggler-mitigation-6.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":3666}
+{"text":"![Speedups on 256 GPUs](\/assets\/images\/straggler-mitigation\/straggler-mitigation-7.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":3667}
+{"text":"\n## Limitations","__index_level_0__":3668}
+{"text":"Before applying hierarchical SGD to straggler mitigation, the user should be aware of a few limitations of this approach:","__index_level_0__":3669}
+{"text":"1. This approach can only mitigate non-persistent stragglers, which occur to different workers at different times. However, for the case of persistent stragglers, which can be caused by hardware degradation or a network issue on a specific host, these stragglers will slow down the same low-level subgroup at every time, leading to nearly no straggler mitigation.\n2. This approach can only mitigate low-frequency stragglers. E.g., if 30% workers can randomly become stragglers at every step, then most low-level synchronizations will still be slowed down by stragglers. As a result, hierarchical SGD may not show an obvious performance advantage over synchronous SGD.\n3. Since hierarchical SGD applies model averaging that does not overlap with backward like gradient averaging used by vanilla DDP, its performance gain of straggler mitigation must outweigh the performance loss of no overlap between communication and backward pass. Therefore, if stragglers only slow down training by less than 10%, hierarchical SGD may not be able to bring much speedup. This limitation can be addressed by [overlapping optimizer step and backward pass](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.13\/torch\/distributed\/algorithms\/ddp_comm_hooks\/optimizer_overlap_hooks.py) in the future.\n4. Since hierarchical SGD is less well-studied than local SGD, there is no guarantee that hierarchical SGD with a finer-grained synchronization granularity can converge faster than certain advanced forms of local SGD, such as [SlowMo](https:\/\/openreview.net\/pdf?id=SkxJ8REYPH), which can improve convergence efficiency with slow momentum. However, to the best of our knowledge, these advanced algorithms cannot be natively supported as a PyTorch DDP plugin like hierarchical SGD yet.","__index_level_0__":3670}
+{"text":"\n## Acknowledgements","__index_level_0__":3671}
+{"text":"We would like to thank Cruise teammates **Bo Tian**, **Sergei Vorobev**, **Eugene Selivonchyk, Tsugn-Hsien Lee**, **Dan Ring**, **Ian Ackerman**, **Lei Chen**, **Maegan Chew**, **Viet Anh To**, **Xiaohui Long**, **Zeyu Chen**, **Alexander Sidorov**, **Igor Tsvetkov**, **Xin Hu**, **Manav Kataria**, **Marina Rubtsova**, and **Mohamed Fawzy**, as well as Meta teammates **Shen Li, Yanli Zhao, Suraj Subramanian, Hamid Shojanzeri, Anjali Sridhar** and **Bernard Nguyen** for the support. \n source: https:\/\/pytorch.org\/blog\/straggler-mitigation\/ \n category: pytorch blogs","__index_level_0__":3672}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Easily list and initialize models with new APIs in TorchVision\"\nauthor: Vasilis Vryniotis and Laurence Rouesnel\nfeatured-img: \"\/assets\/images\/easily-list-and-initialize-models-with-new-apis-in-torchvision-1.png\"\n---","__index_level_0__":3673}
+{"text":"TorchVision now supports listing and initializing all available built-in models and weights by name. This new API builds upon the recently introduced [Multi-weight support API](https:\/\/pytorch.org\/blog\/introducing-torchvision-new-multi-weight-support-api\/), is currently in Beta, and it addresses a long-standing [request](https:\/\/github.com\/pytorch\/vision\/issues\/1143) from the community.","__index_level_0__":3674}
+{"text":"<p align=\"center\">\n  <img src=\"\\assets\\images\\easily-list-and-initialize-models-with-new-apis-in-torchvision.gif\" width=\"100%\">\n<\/p>","__index_level_0__":3675}
+{"text":"You can try out the new API in the [latest nightly](https:\/\/pytorch.org\/get-started\/locally\/) release of TorchVision. We\u2019re looking to collect feedback ahead of finalizing the feature in TorchVision v0.14. We have created a dedicated [Github Issue](https:\/\/github.com\/pytorch\/vision\/issues\/6365) where you can post your comments, questions and suggestions!","__index_level_0__":3676}
+{"text":"## Querying and initializing available models","__index_level_0__":3677}
+{"text":"Before the new model registration API, developers had to query the ``__dict__`` attribute of the modules in order to list all available models or to fetch a specific model builder method by its name:","__index_level_0__":3678}
+{"text":"```python\n# Initialize a model by its name:\nmodel = torchvision.models.__dict__[model_name]()","__index_level_0__":3679}
+{"text":"# List available models:\navailable_models = [\n    k for k, v in torchvision.models.__dict__.items()\n    if callable(v) and k[0].islower() and k[0] != \"_\"\n]\n```","__index_level_0__":3680}
+{"text":"The above approach does not always produce the expected results and is hard to discover. For example, since the [``get_weight()``](https:\/\/pytorch.org\/vision\/main\/models.html#using-models-from-hub) method is exposed publicly under the same module, it will be included in the list despite not being a model. In general, reducing the verbosity (less imports, shorter names etc) and being able to initialize models and weights directly from their names (better support of configs, TorchHub etc) was [feedback](https:\/\/github.com\/pytorch\/vision\/issues\/5088) provided previously by the community. To solve this problem, we have developed a model registration API.","__index_level_0__":3681}
+{"text":"## A new approach","__index_level_0__":3682}
+{"text":"We\u2019ve added 4 new methods under the torchvision.models module:","__index_level_0__":3683}
+{"text":"```python\nfrom torchvision.models import get_model, get_model_weights, get_weight, list_models\n```","__index_level_0__":3684}
+{"text":"The styles and naming conventions align closely with a prototype mechanism proposed by Philip Meier for the [Datasets V2](https:\/\/github.com\/pytorch\/vision\/blob\/main\/torchvision\/prototype\/datasets\/_api.py) API, aiming to offer a similar user experience. The model registration methods are kept private on purpose as we currently focus only on supporting the built-in models of TorchVision.","__index_level_0__":3685}
+{"text":"### List models","__index_level_0__":3686}
+{"text":"Listing all available models in TorchVision can be done with a single function call:","__index_level_0__":3687}
+{"text":"```python\n>>> list_models()\n['alexnet', 'mobilenet_v3_large', 'mobilenet_v3_small', 'quantized_mobilenet_v3_large', ...]\n```","__index_level_0__":3688}
+{"text":"To list the available models of specific submodules:","__index_level_0__":3689}
+{"text":"```python\n>>> list_models(module=torchvision.models)\n['alexnet', 'mobilenet_v3_large', 'mobilenet_v3_small', ...]\n>>> list_models(module=torchvision.models.quantization)\n['quantized_mobilenet_v3_large', ...]\n```","__index_level_0__":3690}
+{"text":"### Initialize models","__index_level_0__":3691}
+{"text":"Now that you know which models are available, you can easily initialize a model with pre-trained weights:","__index_level_0__":3692}
+{"text":"```python\n>>> get_model(\"quantized_mobilenet_v3_large\", weights=\"DEFAULT\")\nQuantizableMobileNetV3(\n  (features): Sequential(\n   ....\n   )\n)\n```","__index_level_0__":3693}
+{"text":"### Get weights\nSometimes, while working with config files or using TorchHub, you might have the name of a specific weight entry and wish to get its instance. This can be easily done with the following method:","__index_level_0__":3694}
+{"text":"```python\n>>> get_weight(\"ResNet50_Weights.IMAGENET1K_V2\")\nResNet50_Weights.IMAGENET1K_V2\n```","__index_level_0__":3695}
+{"text":"To get the enum class with all available weights of a specific model you can use either its name:","__index_level_0__":3696}
+{"text":"```python\n>>> get_model_weights(\"quantized_mobilenet_v3_large\")\n<enum 'MobileNet_V3_Large_QuantizedWeights'>\n```","__index_level_0__":3697}
+{"text":"Or its model builder method:","__index_level_0__":3698}
+{"text":"```python\n>>> get_model_weights(torchvision.models.quantization.mobilenet_v3_large)\n<enum 'MobileNet_V3_Large_QuantizedWeights'>\n```","__index_level_0__":3699}
+{"text":"### TorchHub support\nThe new methods are also available via TorchHub:","__index_level_0__":3700}
+{"text":"```python\nimport torch","__index_level_0__":3701}
+{"text":"# Fetching a specific weight entry by its name:\nweights = torch.hub.load(\"pytorch\/vision\", \"get_weight\", weights=\"ResNet50_Weights.IMAGENET1K_V2\")","__index_level_0__":3702}
+{"text":"# Fetching the weights enum class to list all available entries:\nweight_enum = torch.hub.load(\"pytorch\/vision\", \"get_model_weights\", name=\"resnet50\")\nprint([weight for weight in weight_enum])\n```","__index_level_0__":3703}
+{"text":"## Putting it all together","__index_level_0__":3704}
+{"text":"For example, if you wanted to retrieve all the small-sized models with pre-trained weights and initialize one of them, it\u2019s a matter of using the above APIs:","__index_level_0__":3705}
+{"text":"```python\nimport torchvision\nfrom torchvision.models import get_model, get_model_weights, list_models","__index_level_0__":3706}
+{"text":"\nmax_params = 5000000","__index_level_0__":3707}
+{"text":"tiny_models = []\nfor model_name in list_models(module=torchvision.models):\n    weights_enum = get_model_weights(model_name)\n    if len([w for w in weights_enum if w.meta[\"num_params\"] <= max_params]) > 0:\n        tiny_models.append(model_name)","__index_level_0__":3708}
+{"text":"print(tiny_models)\n# ['mnasnet0_5', 'mnasnet0_75', 'mnasnet1_0', 'mobilenet_v2', ...]","__index_level_0__":3709}
+{"text":"model = get_model(tiny_models[0], weights=\"DEFAULT\")\nprint(sum(x.numel() for x in model.state_dict().values()))\n# 2239188\n```","__index_level_0__":3710}
+{"text":"For more technical details please see the original [RFC](https:\/\/github.com\/pytorch\/vision\/pull\/6330). Please spare a few minutes to provide your feedback on the new API, as this is crucial for graduating it from beta and including it in the next release. You can do this on the dedicated [Github Issue](https:\/\/github.com\/pytorch\/vision\/issues\/6365). We are looking forward to reading your comments! \n source: https:\/\/pytorch.org\/blog\/easily-list-and-initialize-models-with-new-apis-in-torchvision\/ \n category: pytorch blogs","__index_level_0__":3711}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Introducing native PyTorch automatic mixed precision for faster training on NVIDIA GPUs'\nauthor: Mengdi Huang, Chetan Tekur, Michael Carilli\n---","__index_level_0__":3712}
+{"text":"Most deep learning frameworks, including PyTorch, train with 32-bit floating point (FP32) arithmetic by default. However this is not essential to achieve full accuracy for many deep learning models. In 2017, NVIDIA researchers developed a methodology for [mixed-precision training](https:\/\/developer.nvidia.com\/blog\/mixed-precision-training-deep-neural-networks\/), which combined [single-precision](https:\/\/blogs.nvidia.com\/blog\/2019\/11\/15\/whats-the-difference-between-single-double-multi-and-mixed-precision-computing\/) (FP32) with half-precision (e.g. FP16) format when training a network, and achieved the same accuracy as FP32 training using the same hyperparameters, with additional performance benefits on NVIDIA GPUs:","__index_level_0__":3713}
+{"text":"* Shorter training time;\n* Lower memory requirements, enabling larger batch sizes, larger models, or larger inputs.","__index_level_0__":3714}
+{"text":"In order to streamline the user experience of training in mixed precision for researchers and practitioners, NVIDIA developed [Apex](https:\/\/developer.nvidia.com\/blog\/apex-pytorch-easy-mixed-precision-training\/) in 2018, which is a lightweight PyTorch extension with [Automatic Mixed Precision](https:\/\/developer.nvidia.com\/automatic-mixed-precision) (AMP) feature. This feature enables automatic conversion of certain GPU operations from FP32 precision to mixed precision, thus improving performance while maintaining accuracy.","__index_level_0__":3715}
+{"text":"For the PyTorch 1.6 release, developers at NVIDIA and Facebook moved mixed precision functionality into PyTorch core as the AMP package, [torch.cuda.amp](https:\/\/pytorch.org\/docs\/stable\/amp.html). `torch.cuda.amp` is more flexible and intuitive compared to `apex.amp`. Some of `apex.amp`'s known pain points that `torch.cuda.amp` has been able to fix:","__index_level_0__":3716}
+{"text":"* Guaranteed PyTorch version compatibility, because it's part of PyTorch\n* No need to build extensions\n* Windows support\n* Bitwise accurate [saving\/restoring](https:\/\/pytorch.org\/docs\/master\/amp.html#torch.cuda.amp.GradScaler.load_state_dict) of checkpoints\n* [DataParallel](https:\/\/pytorch.org\/docs\/master\/notes\/amp_examples.html#dataparallel-in-a-single-process) and intra-process model parallelism (although we still recommend [torch.nn.DistributedDataParallel](https:\/\/pytorch.org\/docs\/master\/notes\/amp_examples.html#distributeddataparallel-one-gpu-per-process) with one GPU per process as the most performant approach)\n* [Gradient penalty](https:\/\/pytorch.org\/docs\/master\/notes\/amp_examples.html#gradient-penalty) (double backward)\n* torch.cuda.amp.autocast() has no effect outside regions where it's enabled, so it should serve cases that formerly struggled with multiple calls to [apex.amp.initialize()](https:\/\/github.com\/NVIDIA\/apex\/issues\/439) (including [cross-validation)](https:\/\/github.com\/NVIDIA\/apex\/issues\/392#issuecomment-610038073) without difficulty. Multiple convergence runs in the same script should each use a fresh [GradScaler instance](https:\/\/github.com\/NVIDIA\/apex\/issues\/439#issuecomment-610028282), but GradScalers are lightweight and self-contained so that's not a problem.\n* Sparse gradient support","__index_level_0__":3717}
+{"text":"With AMP being added to PyTorch core, we have started the process of deprecating `apex.amp.` We have moved `apex.amp` to maintenance mode and will support customers using `apex.amp.` However, we highly encourage `apex.amp` customers to transition to using `torch.cuda.amp` from PyTorch Core.","__index_level_0__":3718}
+{"text":"# Example Walkthrough\nPlease see official docs for usage:\n* [https:\/\/pytorch.org\/docs\/stable\/amp.html](https:\/\/pytorch.org\/docs\/stable\/amp.html )\n* [https:\/\/pytorch.org\/docs\/stable\/notes\/amp_examples.html](https:\/\/pytorch.org\/docs\/stable\/notes\/amp_examples.html)","__index_level_0__":3719}
+{"text":"```python\nimport torch\n# Creates once at the beginning of training\nscaler = torch.cuda.amp.GradScaler()","__index_level_0__":3721}
+{"text":"for data, label in data_iter:\n   optimizer.zero_grad()\n   # Casts operations to mixed precision\n   with torch.cuda.amp.autocast():\n      loss = model(data)","__index_level_0__":3722}
+{"text":"   # Scales the loss, and calls backward()\n   # to create scaled gradients\n   scaler.scale(loss).backward()","__index_level_0__":3723}
+{"text":"   # Unscales gradients and calls\n   # or skips optimizer.step()\n   scaler.step(optimizer)","__index_level_0__":3724}
+{"text":"   # Updates the scale for next iteration\n   scaler.update()\n```","__index_level_0__":3725}
+{"text":"# Performance Benchmarks\nIn this section, we discuss the accuracy and performance of mixed precision training with AMP on the latest NVIDIA GPU A100 and also previous generation V100 GPU. The mixed precision performance is compared to FP32 performance, when running Deep Learning workloads in the [NVIDIA pytorch:20.06-py3 container](https:\/\/ngc.nvidia.com\/catalog\/containers\/nvidia:pytorch?ncid=partn-52193#cid=ngc01_partn_en-us) from NGC.","__index_level_0__":3726}
+{"text":"## Accuracy: AMP (FP16), FP32\nThe advantage of using AMP for Deep Learning training is that the models converge to the similar final accuracy while providing improved training performance. To illustrate this point, for [Resnet 50 v1.5 training](https:\/\/github.com\/NVIDIA\/DeepLearningExamples\/tree\/master\/PyTorch\/Classification\/ConvNets\/resnet50v1.5#training-accuracy-nvidia-dgx-a100-8x-a100-40gb), we see the following accuracy results where higher is better. Please note that the below accuracy numbers are sample numbers that are subject to run to run variance of up to 0.4%. Accuracy numbers for other models including BERT, Transformer, ResNeXt-101, Mask-RCNN, DLRM can be found at  [NVIDIA Deep Learning Examples Github](https:\/\/github.com\/NVIDIA\/DeepLearningExamples).","__index_level_0__":3727}
+{"text":"Training accuracy: NVIDIA DGX A100 (8x A100 40GB)","__index_level_0__":3728}
+{"text":"<table width=\"460\" border=\"0\" cellspacing=\"5\" cellpadding=\"5\">\n  <tbody>\n    <tr>\n      <td><strong>&nbsp;epochs<\/strong><\/td>\n      <td><strong>&nbsp;Mixed Precision Top 1(%)<\/strong><\/td>\n      <td>&nbsp;<strong>TF32 Top1(%)<\/strong><\/td>\n    <\/tr>\n    <tr>\n      <td>&nbsp;90<\/td>\n      <td>&nbsp;76.93<\/td>\n      <td>&nbsp;76.85<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>","__index_level_0__":3729}
+{"text":"Training accuracy: NVIDIA DGX-1 (8x V100 16GB)","__index_level_0__":3730}
+{"text":" <table width=\"460\" border=\"0\" cellspacing=\"5\" cellpadding=\"5\">\n  <tbody>\n    <tr>\n     <td><strong>&nbsp;epochs<\/strong><\/td>\n      <td><strong>&nbsp;Mixed Precision Top 1(%)<\/strong><\/td>\n      <td>&nbsp;<strong>FP32 Top1(%)<\/strong><\/td>\n    <\/tr>\n    <tr>\n      <td>50<\/td>\n      <td>76.25<\/td>\n      <td>76.26<\/td>\n    <\/tr>\n    <tr>\n      <td>90<\/td>\n      <td>77.09<\/td>\n      <td>77.01<\/td>\n    <\/tr>\n\t  <tr>\n      <td>250<\/td>\n      <td>78.42<\/td>\n      <td>78.30<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>","__index_level_0__":3731}
+{"text":"## Speedup Performance:","__index_level_0__":3732}
+{"text":"### FP16 on NVIDIA V100 vs. FP32 on V100\nAMP with FP16 is the most performant option for DL training on the V100. In Table 1, we can observe that for various models, AMP on V100 provides a speedup of 1.5x to 5.5x over FP32 on V100 while converging to the same final accuracy.","__index_level_0__":3733}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/nvidiafp32onv100.jpg\" width=\"100%\">\n<\/div>\n*Figure 2. Performance of mixed precision training on NVIDIA 8xV100 vs. FP32 training on 8xV100 GPU. Bars represent the speedup factor of V100 AMP over V100 FP32. The higher the better.*","__index_level_0__":3734}
+{"text":"## FP16 on NVIDIA A100 vs. FP16 on V100","__index_level_0__":3735}
+{"text":"AMP with FP16 remains the most performant option for DL training on the A100. In Figure 3, we can observe that for various models, AMP on A100 provides a speedup of 1.3x to 2.5x over AMP on V100 while converging to the same final accuracy.","__index_level_0__":3736}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/nvidiafp16onv100.png\" width=\"100%\">\n<\/div>\n*Figure 3. Performance of mixed precision training on NVIDIA 8xA100 vs. 8xV100 GPU. Bars represent the speedup factor of A100 over V100. The higher the better.*","__index_level_0__":3737}
+{"text":"# Call to action\nAMP provides a healthy speedup for Deep Learning training workloads on Nvidia Tensor Core GPUs, especially on the latest Ampere generation A100 GPUs.  You can start experimenting with AMP enabled models and model scripts for A100, V100, T4 and other GPUs available at NVIDIA deep learning [examples](https:\/\/github.com\/NVIDIA\/DeepLearningExamples). NVIDIA PyTorch with native AMP support is available from the [PyTorch NGC container](https:\/\/ngc.nvidia.com\/catalog\/containers\/nvidia:pytorch?ncid=partn-52193#cid=ngc01_partn_en-us) version 20.06. We highly encourage existing `apex.amp` customers to transition to using `torch.cuda.amp` from PyTorch Core available in the latest [PyTorch 1.6 release](https:\/\/pytorch.org\/blog\/pytorch-1.6-released\/).\n \n source: https:\/\/pytorch.org\/blog\/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision\/ \n category: pytorch blogs","__index_level_0__":3738}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Tensor Comprehensions in PyTorch'\nauthor: Priya Goyal (FAIR), Nicolas Vasilache (FAIR), Oleksandr Zinenko (Inria & DI ENS), Theodoros Theodoridis (ETH Z\u00fcrich), Zachary DeVito (FAIR), William S. Moses (MIT CSAIL), Sven Verdoolaege (FAIR), Andrew Adams (FAIR), Albert Cohen (Inria & DI ENS & FAIR)\nredirect_from: \/2018\/03\/05\/tensor-comprehensions.html\n---","__index_level_0__":3739}
+{"text":"Tensor Comprehensions (TC) is a tool that lowers the barrier for writing high-performance code. It generates GPU code from a simple high-level language and autotunes the code for specific input sizes.","__index_level_0__":3740}
+{"text":"**We highly recommend reading the [Tensor Comprehensions blogpost](https:\/\/research.fb.com\/announcing-tensor-comprehensions\/) first.**","__index_level_0__":3741}
+{"text":"If you ran into any of the following scenarios, TC is a useful tool for you.","__index_level_0__":3742}
+{"text":"- Your PyTorch layer is large and slow, and you contemplated writing a dedicated C++ or CUDA code for it. But you don't know how to program in CUDA or write low-level code.","__index_level_0__":3743}
+{"text":"- You wrote a CUDA layer, but it took a week to write, debug, optimize for speed. You wished you could do this in an hour.","__index_level_0__":3744}
+{"text":"- You want to fuse multiple layers like Conv-ReLU-BatchNorm or Linear-ReLU-Linear-ReLU in your network for speed, but it was quite difficult to comprehend","__index_level_0__":3745}
+{"text":"- Your research involves weird Tensor shapes that CuDNN and MKL are not optimized for. For example, you do convolutions of 13 x 24 with an input image of 143 x 55. You tried running it with CuDNN and it was slower than you wished.","__index_level_0__":3746}
+{"text":"- Your code is slowed-down by transposing Tensors constantly to fit a particular memory layout. You wish it was easy to write custom code that operates efficiently on your input layout.","__index_level_0__":3747}
+{"text":"\nTensor Comprehensions are seamless to use in PyTorch, interoperating with PyTorch Tensors and `nn` Variables.","__index_level_0__":3748}
+{"text":"Let us run through using TC with PyTorch.","__index_level_0__":3749}
+{"text":"#### 1. Install the package","__index_level_0__":3750}
+{"text":"```bash\nconda install -c pytorch -c tensorcomp tensor_comprehensions\n```","__index_level_0__":3751}
+{"text":"At this time we only provide Linux-64 binaries which have been tested on Ubuntu 16.04 and CentOS7.","__index_level_0__":3752}
+{"text":"TC depends on heavyweight C++ projects such as [Halide](http:\/\/halide-lang.org\/), [Tapir-LLVM](https:\/\/github.com\/wsmoses\/Tapir-LLVM) and [ISL](http:\/\/isl.gforge.inria.fr\/). Hence, we rely on Anaconda to distribute these dependencies reliably. For the same reason, TC is not available via PyPI.","__index_level_0__":3753}
+{"text":"#### 2. Import the python package","__index_level_0__":3754}
+{"text":"```python\nimport tensor_comprehensions as tc\n```","__index_level_0__":3755}
+{"text":"#### 3. Define the TC expression and create a python function","__index_level_0__":3756}
+{"text":"```python\nlang = \"\"\"\ndef fcrelu(float(B,M) I, float(N,M) W1, float(N) B1) -> (O1) {\n    O1(b, n) +=! I(b, m) * W1(n, m)\n    O1(b, n) = O1(b, n) + B1(n)\n    O1(b, n) = fmax(O1(b, n), 0)\n}\n\"\"\"\nfcrelu = tc.define(lang, name=\"fcrelu\")\n```","__index_level_0__":3757}
+{"text":"This `fcrelu` function takes PyTorch Tensors as input and returns a PyTorch Tensor. It takes input `I`, weight `W1`, bias `B1` and returns output `O1`.","__index_level_0__":3758}
+{"text":"#### 4. Let's create some dummy input tensors","__index_level_0__":3759}
+{"text":"```python\nB, M, N = 100, 128, 100\nI, W1, B1 = torch.randn(B, M).cuda(), torch.randn(N, M).cuda(), torch.randn(N).cuda()\n```","__index_level_0__":3760}
+{"text":"#### 5. Now autotune the function for your input sizes","__index_level_0__":3761}
+{"text":"```python\nfcrelu.autotune(I, W1, B1, cache=\"fcrelu_100_128_100.tc\")\n```","__index_level_0__":3762}
+{"text":"The autotuner is your biggest friend. You generally do not want to use a `tc` function without autotuning it first.","__index_level_0__":3763}
+{"text":"When the autotuning is running, the current best performance is displayed. If you are satisfied with the current result or you are out of time, stop the tuning procedure by pressing `Ctrl+C`.","__index_level_0__":3764}
+{"text":"![tc-autotuner](https:\/\/pytorch.org\/static\/img\/tc_autotuner.gif)","__index_level_0__":3765}
+{"text":"`cache` saves the results of the autotuned kernel search and saves it to the file `fcrelu_100_128_100.tc`. The next time you call the same line of code, it loads the results of the autotuning without recomputing it.","__index_level_0__":3766}
+{"text":"The autotuner has a few hyperparameters (just like your ConvNet has learning rate, number of layers, etc.). We pick reasonable defaults, but you can read about using advanced options [here](https:\/\/facebookresearch.github.io\/TensorComprehensions\/framework\/pytorch_integration\/writing_layers.html#specifying-mapping-options).","__index_level_0__":3767}
+{"text":"#### 6. Call the function with the inputs, to get your result","__index_level_0__":3768}
+{"text":"```python\nout = fcrelu(I, W1, B1)\n```","__index_level_0__":3769}
+{"text":"Now, let's look at how to write TC expressions.","__index_level_0__":3770}
+{"text":"## A quick primer on the TC language","__index_level_0__":3771}
+{"text":"The TC notation focuses on the mathematical nature of the layer, leaving performance considerations to it's backend code that uses Halide and polyhedral compilation techniques which accumulate decades of cutting edge Loop Nest Optimization (LNO) research.","__index_level_0__":3772}
+{"text":"TC is close to [np.einsum](https:\/\/docs.scipy.org\/doc\/numpy\/reference\/generated\/numpy.einsum.html). We shall quickly learn TC by example","__index_level_0__":3773}
+{"text":"```python\nlang = \"\"\"\ndef matmul(float(M,N) A, float(N,K) B) -> (output) {\n  output(i, j) +=! A(i, kk) * B(kk, j)\n}\n\"\"\"\n```","__index_level_0__":3774}
+{"text":"In this example, we define a function `matmul` which takes two input `A` and `B` of shapes `M x N` and `N x K` and returns a single `output`. The shape of `output` is automatically inferred by the TC language (discussed below).","__index_level_0__":3775}
+{"text":"Let's look at this line:","__index_level_0__":3776}
+{"text":"```python\noutput(i, j) +=! A(i, kk) * B(kk, j)\n```","__index_level_0__":3777}
+{"text":"- `output(i, j)` means output is 2D.\n- for each location `output(i, j)`, we add (`+=`) `A(i, kk) * B(kk, j)`.\n- `i` is well-defined as all locations in `A` dim=0, i.e. `i in range(0, M)`\n- `j` is well-defined as all locations in `B` dim=1, i.e. `j in range(0, K)`\n- `kk` is inferred as all locations from `0` to `N`","__index_level_0__":3779}
+{"text":"The shape of output is inferred from the maximum values `i` and `j` can take, which is `M` and `K`, so output is of size `M x K`.","__index_level_0__":3780}
+{"text":"The `!` symbol initializes output with `0.0`. It is equivalent to:","__index_level_0__":3781}
+{"text":"```python\noutput(i, j) = 0\noutput(i, j) += A(i, kk) * B(kk, j)\n```","__index_level_0__":3782}
+{"text":"**Scalar inputs and range constraints: implement AvgPool2d**","__index_level_0__":3783}
+{"text":"```python\n\"\"\"","__index_level_0__":3784}
+{"text":"{% raw %}def avgpool(float(B, C, H, W) input) -> (output) {{{% endraw %}\n  output(b, c, h, w) += input(b, c, h * {sH} + kh, w * {sW} + kw) where kh in 0:{kH}, kw in 0:{kW}\n{% raw %}}}{% endraw %}","__index_level_0__":3785}
+{"text":"\"\"\"\navgpool = tc.define(LANG, name=\"avgpool\", constants={\"sH\":1, \"sW\":1, \"kH\":2, \"kW\":2})\n```","__index_level_0__":3786}
+{"text":"here the `where` keyword can take ranges of values to operate on. `0:{kH}` is equivalent `range(kH)` in Python.","__index_level_0__":3787}
+{"text":"Note: the syntax for passing in scalars is subject to change in the next release.","__index_level_0__":3788}
+{"text":"## torch.nn layers","__index_level_0__":3789}
+{"text":"We added some sugar-coating around the basic PyTorch integration of TC to make it easy to integrate TC into larger `torch.nn` models by defining the forward and backward TC expressions and taking `Variable` inputs \/ outputs. Here is an [example](https:\/\/github.com\/facebookresearch\/TensorComprehensions\/blob\/master\/test_python\/layers\/test_convolution_train.py) of defining a convolution layer with TC.","__index_level_0__":3790}
+{"text":"## Some essentials that you will miss (we're working on them)","__index_level_0__":3791}
+{"text":"### Autotuning for variable-length sequences","__index_level_0__":3792}
+{"text":"The TC auto-tuner requires all input sizes to be specified before-hand. For example, if you have input `I1` which is an image batch, the autotuner wants to know the exact shape of `I1` to generate an optimized kernel. You cannot specify: `image with height between 200 and 300`. This is more essential in sequence data such as NLP, where each sentence can have a different length.","__index_level_0__":3793}
+{"text":"The reason why the autotuner is non-parametric is because it's harder and harder to auto-tune parametric constraints, this is active research. Hence, for the first release, we made a conscious decision to give you the tool in a form where we know it works well.","__index_level_0__":3794}
+{"text":"As a work-around, if you know that you have a few specific shapes of interest, you can run the autotuner with these multiple shapes.","__index_level_0__":3795}
+{"text":"```python\nrelu = tc.define(LANG, name=\"relu\")\nbatch, channels = 16, 3\ntc.autotune((batch, channels, 32, 32)) # image of size 32 x 32\ntc.autotune((batch, channels, 48, 48)) # image of size 48 x 48\ntc.autotune((batch, channels, 64, 64)) # image of size 64 x 64\n```","__index_level_0__":3796}
+{"text":"Now the autotuner is tuned for these three specific image sizes `32x32`, `48x48` and `64x64`.","__index_level_0__":3797}
+{"text":"### Lack of loops","__index_level_0__":3798}
+{"text":"If you want to write an RNN, it's easy to see it as a `for` loop over time. However, the TC language does not have loops yet. If you really want to write RNNs, you can write unrolled loops.","__index_level_0__":3799}
+{"text":"### Strided-Tensors","__index_level_0__":3800}
+{"text":"The TC backend does not support non-contiguous Tensors yet. If the inputs you give are not contiguous, they are made contiguous before passing to the TC backend.","__index_level_0__":3801}
+{"text":"### Reshaping Tensors within a TC expression","__index_level_0__":3802}
+{"text":"You cannot write this operation in TC: `torch.matmul(...).view(...).mean(...)`. Whenever there is need for a `view` to change the shape of an input, you have to get the output, `view` it at the PyTorch level.","__index_level_0__":3803}
+{"text":"## Getting Started","__index_level_0__":3804}
+{"text":"- [Walk through Tutorial](https:\/\/facebookresearch.github.io\/TensorComprehensions\/framework\/pytorch_integration\/writing_layers.html) to quickly get started with understanding and using Tensor Comprehensions PyTorch package.\n- [Over 20 examples](https:\/\/github.com\/facebookresearch\/TensorComprehensions\/tree\/master\/test_python\/layers) of various ML layers with TC, including `avgpool`, `maxpool`, `matmul`, matmul - give output buffers and `batch-matmul`, `convolution`, `strided-convolution`, `batchnorm`, `copy`, `cosine similarity`, `Linear`, `Linear + ReLU`, `group-convolutions`, strided `group-convolutions`, `indexing`, `Embedding` (lookup table), small-mobilenet, `softmax`, `tensordot`, `transpose`\n- [Detailed docs](https:\/\/facebookresearch.github.io\/TensorComprehensions\/framework\/pytorch_integration\/getting_started.html) on Tensor Comprehensions and integration with PyTorch.","__index_level_0__":3805}
+{"text":"## Communication","__index_level_0__":3806}
+{"text":"- [Slack](https:\/\/tensorcomprehensions.herokuapp.com\/): For discussion around framework integration, build support, collaboration, etc. join our slack channel.\n- Email: tensorcomp@fb.com\n- [GitHub](https:\/\/github.com\/facebookresearch\/TensorComprehensions): bug reports, feature requests, install issues, RFCs, thoughts, etc.","__index_level_0__":3807}
+{"text":"## Acknowledgements","__index_level_0__":3808}
+{"text":"We would like to thank Soumith Chintala, [Edward Yang](https:\/\/github.com\/ezyang) and [Sam Gross](https:\/\/github.com\/colesbury) for their immense guidance and help in making the integration API nice and smooth. We would also like to thank rest of the PyTorch team and our pre-release users for their helpful feedback that guided us in making the integration better.\n \n source: https:\/\/pytorch.org\/blog\/tensor-comprehensions\/ \n category: pytorch blogs","__index_level_0__":3809}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Introducing TorchVision\u2019s New Multi-Weight Support API\"\nauthor: Vasilis Vryniotis\nfeatured-img: \"assets\/images\/torchvision_featured.png\"\n---","__index_level_0__":3810}
+{"text":"TorchVision has a new backwards compatible API for building models with multi-weight support. The new API allows loading different pre-trained weights on the same model variant, keeps track of vital meta-data such as the classification labels and includes the preprocessing transforms necessary for using the models. In this blog post, we plan to review the prototype API, show-case its features and highlight key differences with the existing one.","__index_level_0__":3811}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/torchvision_gif.gif\" width=\"100%\">\n<\/div>","__index_level_0__":3812}
+{"text":"We are hoping to get your thoughts about the API prior finalizing it. To collect your feedback, we have created a [Github issue](https:\/\/github.com\/pytorch\/vision\/issues\/5088) where you can post your thoughts, questions and comments.","__index_level_0__":3813}
+{"text":"## Limitations of the current API","__index_level_0__":3814}
+{"text":"TorchVision currently provides pre-trained models which could be a starting point for transfer learning or used as-is in Computer Vision applications. The typical way to instantiate a pre-trained model and make a prediction is:","__index_level_0__":3815}
+{"text":"```Python\nimport torch","__index_level_0__":3816}
+{"text":"from PIL import Image\nfrom torchvision import models as M\nfrom torchvision.transforms import transforms as T","__index_level_0__":3817}
+{"text":"\nimg = Image.open(\"test\/assets\/encode_jpeg\/grace_hopper_517x606.jpg\")","__index_level_0__":3818}
+{"text":"# Step 1: Initialize model\nmodel = M.resnet50(pretrained=True)\nmodel.eval()","__index_level_0__":3819}
+{"text":"# Step 2: Define and initialize the inference transforms\npreprocess = T.Compose([\n    T.Resize([256, ]),\n    T.CenterCrop(224),\n    T.PILToTensor(),\n    T.ConvertImageDtype(torch.float),\n    T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n])","__index_level_0__":3820}
+{"text":"# Step 3: Apply inference preprocessing transforms\nbatch = preprocess(img).unsqueeze(0)\nprediction = model(batch).squeeze(0).softmax(0)","__index_level_0__":3821}
+{"text":"# Step 4: Use the model and print the predicted category\nclass_id = prediction.argmax().item()\nscore = prediction[class_id].item()\nwith open(\"imagenet_classes.txt\", \"r\") as f:\n    categories = [s.strip() for s in f.readlines()]\n    category_name = categories[class_id]\nprint(f\"{category_name}: {100 * score}%\")","__index_level_0__":3822}
+{"text":"There are a few limitations with the above approach:","__index_level_0__":3824}
+{"text":"1. **Inability to support multiple pre-trained weights:** Since the `pretrained` variable is boolean, we can only offer one set of weights. This poses a severe limitation when we significantly [improve the accuracy of existing models](https:\/\/pytorch.org\/blog\/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives\/) and we want to make those improvements available to the community. It also stops us from offering pre-trained weights of the same model variant on different datasets.\n2. **Missing inference\/preprocessing transforms:** The user is forced to define the necessary transforms prior using the model. The inference transforms are usually linked to the training process and dataset used to estimate the weights. Any minor discrepancies in these transforms (such as interpolation value, resize\/crop sizes etc) can lead to major reductions in accuracy or unusable models.\n3. **Lack of meta-data:** Critical pieces of information in relation to the weights are unavailable to the users. For example, one needs to look into external sources and the documentation to find things like the [category labels](https:\/\/github.com\/pytorch\/vision\/issues\/1946), the training recipe, the accuracy metrics etc.","__index_level_0__":3825}
+{"text":"The new API addresses the above limitations and reduces the amount of boilerplate code needed for standard tasks.","__index_level_0__":3826}
+{"text":"## Overview of the prototype API","__index_level_0__":3827}
+{"text":"Let\u2019s see how we can achieve exactly the same results as above using the new API:","__index_level_0__":3828}
+{"text":"```Python\nfrom PIL import Image\nfrom torchvision.prototype import models as PM","__index_level_0__":3829}
+{"text":"\nimg = Image.open(\"test\/assets\/encode_jpeg\/grace_hopper_517x606.jpg\")","__index_level_0__":3830}
+{"text":"# Step 1: Initialize model\nweights = PM.ResNet50_Weights.IMAGENET1K_V1\nmodel = PM.resnet50(weights=weights)\nmodel.eval()","__index_level_0__":3831}
+{"text":"# Step 2: Initialize the inference transforms\npreprocess = weights.transforms()","__index_level_0__":3832}
+{"text":"# Step 3: Apply inference preprocessing transforms\nbatch = preprocess(img).unsqueeze(0)\nprediction = model(batch).squeeze(0).softmax(0)","__index_level_0__":3833}
+{"text":"# Step 4: Use the model and print the predicted category\nclass_id = prediction.argmax().item()\nscore = prediction[class_id].item()\ncategory_name = weights.meta[\"categories\"][class_id]\nprint(f\"{category_name}: {100 * score}*%*\")\n```","__index_level_0__":3834}
+{"text":"As we can see the new API eliminates the aforementioned limitations. Let\u2019s explore the new features in detail.","__index_level_0__":3835}
+{"text":"### Multi-weight support","__index_level_0__":3836}
+{"text":"At the heart of the new API, we have the ability to define multiple different weights for the same model variant. Each model building method (eg `resnet50`) has an associated Enum class (eg `ResNet50_Weights`) which has as many entries as the number of pre-trained weights available. Additionally, each Enum class has a `DEFAULT` alias which points to the best available weights for the specific model. This allows the users who want to always use the best available weights to do so without modifying their code.","__index_level_0__":3837}
+{"text":"Here is an example of initializing models with different weights:","__index_level_0__":3838}
+{"text":"```python\nfrom torchvision.prototype.models import resnet50, ResNet50_Weights","__index_level_0__":3839}
+{"text":"# Legacy weights with accuracy 76.130%\nmodel = resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)","__index_level_0__":3840}
+{"text":"# New weights with accuracy 80.858%\nmodel = resnet50(weights=ResNet50_Weights.IMAGENET1K_V2)","__index_level_0__":3841}
+{"text":"# Best available weights (currently alias for IMAGENET1K_V2)\nmodel = resnet50(weights=ResNet50_Weights.DEFAULT)","__index_level_0__":3842}
+{"text":"# No weights - random initialization\nmodel = resnet50(weights=None)\n```","__index_level_0__":3843}
+{"text":"### Associated meta-data & preprocessing transforms","__index_level_0__":3844}
+{"text":"The weights of each model are associated with meta-data. The type of information we store depends on the task of the model (Classification, Detection, Segmentation etc). Typical information includes a link to the training recipe, the interpolation mode, information such as the categories and validation metrics. These values are programmatically accessible via the `meta` attribute:","__index_level_0__":3845}
+{"text":"```Python\nfrom torchvision.prototype.models import ResNet50_Weights","__index_level_0__":3846}
+{"text":"# Accessing a single record\nsize = ResNet50_Weights.IMAGENET1K_V2.meta[\"size\"]","__index_level_0__":3847}
+{"text":"# Iterating the items of the meta-data dictionary\nfor k, v in ResNet50_Weights.IMAGENET1K_V2.meta.items():\n    print(k, v)\n```","__index_level_0__":3848}
+{"text":"Additionally, each weights entry is associated with the necessary preprocessing transforms. All current preprocessing transforms are JIT-scriptable and can be accessed via the `transforms` attribute. Prior using them with the data, the transforms need to be initialized\/constructed. This lazy initialization scheme is done to ensure the solution is memory efficient. The input of the transforms can be either a `PIL.Image` or a `Tensor` read using `torchvision.io`.","__index_level_0__":3849}
+{"text":"```Python\nfrom torchvision.prototype.models import ResNet50_Weights","__index_level_0__":3850}
+{"text":"# Initializing preprocessing at standard 224x224 resolution\npreprocess = ResNet50_Weights.IMAGENET1K_V2.transforms()","__index_level_0__":3851}
+{"text":"# Initializing preprocessing at 400x400 resolution\npreprocess = ResNet50_Weights.IMAGENET1K_V2.transforms(crop_size=400, resize_size=400)","__index_level_0__":3852}
+{"text":"# Once initialized the callable can accept the image data:\n# img_preprocessed = preprocess(img)\n```","__index_level_0__":3853}
+{"text":"Associating the weights with their meta-data and preprocessing will boost transparency, improve reproducibility and make it easier to document how a set of weights was produced.","__index_level_0__":3854}
+{"text":"### Get weights by name","__index_level_0__":3855}
+{"text":"The ability to link directly the weights with their properties (meta data, preprocessing callables etc) is the reason why our implementation uses Enums instead of Strings. Nevertheless for cases when only the name of the weights is available, we offer a method capable of linking Weight names to their Enums:","__index_level_0__":3856}
+{"text":"```Python\nfrom torchvision.prototype.models import get_weight","__index_level_0__":3857}
+{"text":"# Weights can be retrieved by name:\nassert get_weight(\"ResNet50_Weights.IMAGENET1K_V1\") == ResNet50_Weights.IMAGENET1K_V1\nassert get_weight(\"ResNet50_Weights.IMAGENET1K_V2\") == ResNet50_Weights.IMAGENET1K_V2","__index_level_0__":3858}
+{"text":"# Including using the DEFAULT alias:\nassert get_weight(\"ResNet50_Weights.DEFAULT\") == ResNet50_Weights.IMAGENET1K_V2\n```","__index_level_0__":3859}
+{"text":"## Deprecations","__index_level_0__":3860}
+{"text":"In the new API the boolean `pretrained` and `pretrained_backbone` parameters, which were previously used to load weights to the full model or to its backbone, are deprecated. The current implementation is fully backwards compatible as it seamlessly maps the old parameters to the new ones. Using the old parameters to the new builders emits the following deprecation warnings:","__index_level_0__":3861}
+{"text":"```Python\n>>> model = torchvision.prototype.models.resnet50(pretrained=True)\n UserWarning: The parameter 'pretrained' is deprecated, please use 'weights' instead.\nUserWarning:\nArguments other than a weight enum or `None` for 'weights' are deprecated.\nThe current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`.\nYou can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n```","__index_level_0__":3862}
+{"text":"Additionally the builder methods require using keyword parameters. The use of positional parameter is deprecated and using them emits the following warning:","__index_level_0__":3863}
+{"text":"```Python\n>>> model = torchvision.prototype.models.resnet50(None)\nUserWarning:\nUsing 'weights' as positional parameter(s) is deprecated.\nPlease use keyword parameter(s) instead.\n```","__index_level_0__":3864}
+{"text":"## Testing the new API","__index_level_0__":3865}
+{"text":"Migrating to the new API is very straightforward. The following method calls between the 2 APIs are all equivalent:","__index_level_0__":3866}
+{"text":"```\n# Using pretrained weights:\ntorchvision.prototype.models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)\ntorchvision.models.resnet50(pretrained=True)\ntorchvision.models.resnet50(True)","__index_level_0__":3867}
+{"text":"# Using no weights:\ntorchvision.prototype.models.resnet50(weights=None)\ntorchvision.models.resnet50(pretrained=False)\ntorchvision.models.resnet50(False)\n```","__index_level_0__":3868}
+{"text":"Note that the prototype features are available only on the nightly versions of TorchVision, so to use it you need to install it as follows:","__index_level_0__":3869}
+{"text":"```\nconda install torchvision -c pytorch-nightly\n```","__index_level_0__":3870}
+{"text":"For alternative ways to install the nightly have a look on the PyTorch [download page](https:\/\/pytorch.org\/get-started\/locally\/). You can also install TorchVision from source from the latest main; for more information have a look on our [repo](https:\/\/github.com\/pytorch\/vision\/blob\/main\/CONTRIBUTING.md).","__index_level_0__":3871}
+{"text":"## Accessing state-of-the-art model weights with the new API","__index_level_0__":3872}
+{"text":"If you are still unconvinced about giving a try to the new API, here is one more reason to do so. We\u2019ve recently refreshed our [training recipe](https:\/\/pytorch.org\/blog\/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives\/) and achieved SOTA accuracy from many of our models. The improved weights can easily be accessed via the new API. Here is a quick overview of the model improvements:","__index_level_0__":3873}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/torchvision_chart1.png\" width=\"100%\">\n<\/div>","__index_level_0__":3874}
+{"text":"| Model                      | Old Acc@1 | New Acc@1 |\n| -------------------------- | --------- | --------- |\n| EfficientNet B1            | 78.642    | 79.838    |\n| MobileNetV3 Large          | 74.042    | 75.274    |\n| Quantized ResNet50         | 75.92     | 80.282    |\n| Quantized ResNeXt101 32x8d | 78.986    | 82.574    |\n| RegNet X 400mf             | 72.834    | 74.864    |\n| RegNet X 800mf             | 75.212    | 77.522    |\n| RegNet X 1 6gf             | 77.04     | 79.668    |\n| RegNet X 3 2gf             | 78.364    | 81.198    |\n| RegNet X 8gf               | 79.344    | 81.682    |\n| RegNet X 16gf              | 80.058    | 82.72     |\n| RegNet X 32gf              | 80.622    | 83.018    |\n| RegNet Y 400mf             | 74.046    | 75.806    |\n| RegNet Y 800mf             | 76.42     | 78.838    |\n| RegNet Y 1 6gf             | 77.95     | 80.882    |\n| RegNet Y 3 2gf             | 78.948    | 81.984    |\n| RegNet Y 8gf               | 80.032    | 82.828    |\n| RegNet Y 16gf              | 80.424    | 82.89     |\n| RegNet Y 32gf              | 80.878    | 83.366    |\n| ResNet50                   | 76.13     | 80.858    |\n| ResNet101                  | 77.374    | 81.886    |\n| ResNet152                  | 78.312    | 82.284    |\n| ResNeXt50 32x4d            | 77.618    | 81.198    |\n| ResNeXt101 32x8d           | 79.312    | 82.834    |\n| Wide ResNet50 2            | 78.468    | 81.602    |\n| Wide ResNet101 2           | 78.848    | 82.51     |","__index_level_0__":3875}
+{"text":"Please spare a few minutes to provide your feedback on the new API, as this is crucial for graduating it from prototype and including it in the next release. You can do this on the dedicated [Github Issue](https:\/\/github.com\/pytorch\/vision\/issues\/5088). We are looking forward to reading your comments!\n \n source: https:\/\/pytorch.org\/blog\/introducing-torchvision-new-multi-weight-support-api\/ \n category: pytorch blogs","__index_level_0__":3876}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Optimizing CUDA Recurrent Neural Networks with TorchScript\"\nauthor: \"The PyTorch Team\"\ndate: 2019-05-01 8:00:00 -0500\n---","__index_level_0__":3877}
+{"text":"This week, we officially released PyTorch 1.1, a large feature update to PyTorch 1.0. One of the new features we've added is better support for fast, custom Recurrent Neural Networks (fastrnns) with TorchScript (the PyTorch JIT) (https:\/\/pytorch.org\/docs\/stable\/jit.html). ","__index_level_0__":3878}
+{"text":"RNNs are popular models that have shown good performance on a variety of NLP tasks that come in different shapes and sizes. PyTorch implements a number of the most popular ones, the [Elman RNN](https:\/\/pytorch.org\/docs\/master\/nn.html?highlight=rnn#torch.nn.RNN), [GRU](https:\/\/pytorch.org\/docs\/master\/nn.html?highlight=gru#torch.nn.GRU), and [LSTM](https:\/\/pytorch.org\/docs\/master\/nn.html?highlight=lstm#torch.nn.LSTM) as well as multi-layered and bidirectional variants.  ","__index_level_0__":3879}
+{"text":"However, many users want to implement their own custom RNNs, taking ideas from recent literature. Applying [Layer Normalization](https:\/\/arxiv.org\/abs\/1607.06450) to LSTMs is one such use case. Because the PyTorch CUDA LSTM implementation uses a fused kernel, it is difficult to insert normalizations or even modify the base LSTM implementation. Many users have turned to writing custom implementations using standard PyTorch operators, but such code suffers from high overhead: most PyTorch operations launch at least one kernel on the GPU and RNNs generally run many operations due to their recurrent nature. However, we can apply TorchScript to fuse operations and optimize our code automatically, launching fewer, more optimized kernels on the GPU.","__index_level_0__":3880}
+{"text":"Our goal is for users to be able to write fast, custom RNNs in TorchScript without writing specialized CUDA kernels to achieve similar performance. In this post, we'll provide a tutorial for how to write your own fast RNNs with TorchScript. To better understand the optimizations TorchScript applies, we'll examine how those work on a standard LSTM implementation but most of the optimizations can be applied to general RNNs.","__index_level_0__":3881}
+{"text":"## Writing custom RNNs","__index_level_0__":3882}
+{"text":"To get started, you can use [this file](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/benchmarks\/fastrnns\/custom_lstms.py) as a template to write your own custom RNNs.","__index_level_0__":3883}
+{"text":"We are constantly improving our infrastructure on trying to make the performance better. If you want to gain the speed\/optimizations that TorchScript currently provides (like operator fusion, batch matrix multiplications, etc.), here are some guidelines to follow. The next section explains the optimizations in depth.","__index_level_0__":3884}
+{"text":"1. If the customized operations are all element-wise, that's great because you can get the benefits of the PyTorch JIT's operator fusion automatically!","__index_level_0__":3885}
+{"text":"2. If you have more complex operations (e.g. reduce ops mixed with element-wise ops), consider grouping the reduce operations and element-wise ops separately in order to fuse the element-wise operations into a single fusion group. ","__index_level_0__":3886}
+{"text":"3. If you want to know about what has been fused in your custom RNN, you can inspect the operation's optimized graph by using `graph_for` . Using `LSTMCell` as an example:","__index_level_0__":3887}
+{"text":"    ```python\n    # get inputs and states for LSTMCell","__index_level_0__":3888}
+{"text":"    inputs = get_lstm_inputs()","__index_level_0__":3889}
+{"text":"    # instantiate a ScriptModule","__index_level_0__":3890}
+{"text":"    cell = LSTMCell(input_size, hidden_size)","__index_level_0__":3891}
+{"text":"    # print the optimized graph using graph_for","__index_level_0__":3892}
+{"text":"    out = cell(inputs)\n    print(cell.graph_for(inputs))","__index_level_0__":3893}
+{"text":"    This will generate the optimized TorchScript graph (a.k.a PyTorch JIT IR) for the specialized inputs that you provides:","__index_level_0__":3895}
+{"text":"    ```\n    graph(%x : Float(*, *),\n            %hx : Float(*, *),\n            %cx : Float(*, *),\n            %w_ih : Float(*, *),\n            %w_hh : Float(*, *),\n            %b_ih : Float(*),\n            %b_hh : Float(*)):\n        %hy : Float(*, *), %cy : Float(*, *) = prim::DifferentiableGraph_0(%cx, %b_hh, %b_ih, %hx, %w_hh, %x, %w_ih)\n        %30 : (Float(*, *), Float(*, *)) = prim::TupleConstruct(%hy, %cy)\n        return (%30)\n        with prim::DifferentiableGraph_0 = graph(%13 : Float(*, *),\n            %29 : Float(*),\n            %33 : Float(*),\n            %40 : Float(*, *),\n            %43 : Float(*, *),\n            %45 : Float(*, *),\n            %48 : Float(*, *)):\n        %49 : Float(*, *) = aten::t(%48)\n        %47 : Float(*, *) = aten::mm(%45, %49)\n        %44 : Float(*, *) = aten::t(%43)\n        %42 : Float(*, *) = aten::mm(%40, %44)\n        ...some broadcast sizes operations...\n        %hy : Float(*, *), %287 : Float(*, *), %cy : Float(*, *), %outgate.1 : Float(*, *), %cellgate.1 : Float(*, *), %forgetgate.1 : Float(*, *), %ingate.1 : Float(*, *) = prim::FusionGroup_0(%13, %346, %345, %344, %343)\n        ...some broadcast sizes operations...\n        return (%hy, %cy, %49, %44, %196, %199, %340, %192, %325, %185, %ingate.1, %forgetgate.1, %cellgate.1, %outgate.1, %395, %396, %287)\n        with prim::FusionGroup_0 = graph(%13 : Float(*, *),\n            %71 : Tensor,\n            %76 : Tensor,\n            %81 : Tensor,\n            %86 : Tensor):\n        ...some chunks, constants, and add operations...\n        %ingate.1 : Float(*, *) = aten::sigmoid(%38)\n        %forgetgate.1 : Float(*, *) = aten::sigmoid(%34)\n        %cellgate.1 : Float(*, *) = aten::tanh(%30)\n        %outgate.1 : Float(*, *) = aten::sigmoid(%26)\n        %14 : Float(*, *) = aten::mul(%forgetgate.1, %13)\n        %11 : Float(*, *) = aten::mul(%ingate.1, %cellgate.1)\n        %cy : Float(*, *) = aten::add(%14, %11, %69)\n        %4 : Float(*, *) = aten::tanh(%cy)\n        %hy : Float(*, *) = aten::mul(%outgate.1, %4)\n        return (%hy, %4, %cy, %outgate.1, %cellgate.1, %forgetgate.1, %ingate.1)\n    ```","__index_level_0__":3896}
+{"text":"From the above graph we can see that it has a `prim::FusionGroup_0` subgraph that is fusing all element-wise operations in LSTMCell (transpose and matrix multiplication are not element-wise ops). Some graph nodes might be hard to understand in the first place but we will explain some of them in the optimization section, we also omitted some long verbose operators in this post that is there just for correctness. ","__index_level_0__":3897}
+{"text":"## Variable-length sequences best practices","__index_level_0__":3898}
+{"text":"TorchScript does not support PackedSequence. Generally, when one is handling variable-length sequences, it is best to pad them into a single tensor and send that tensor through a TorchScript LSTM. Here's an example:","__index_level_0__":3899}
+{"text":"```python\nsequences = [...] # List[Tensor], each Tensor is T' x C\npadded = torch.utils.rnn.pad_sequence(sequences)\nlengths = [seq.size(0) for seq in sequences]\npadded  # T x N x C, where N is batch size and T is the max of all T'","__index_level_0__":3900}
+{"text":"model = LSTM(...)\noutput, hiddens = model(padded)\noutput  # T x N x C\n```","__index_level_0__":3901}
+{"text":"Of course, `output` may have some garbage data in the padded regions; use `lengths` to keep track of which part you don't need.","__index_level_0__":3902}
+{"text":"## Optimizations","__index_level_0__":3903}
+{"text":"We will now explain the optimizations performed by the PyTorch JIT to speed up custom RNNs. We will use a simple custom LSTM model in TorchScript to illustrate the optimizations, but many of these are general and apply to other RNNs. ","__index_level_0__":3904}
+{"text":"To illustrate the optimizations we did and how we get benefits from those optimizations, we will run a simple custom LSTM model written in TorchScript (you can refer the code in the custom_lstm.py or the below code snippets) and time our changes.","__index_level_0__":3905}
+{"text":"We set up the environment in a machine equipped with 2 Intel Xeon chip and one Nvidia P100, with cuDNN v7.3, CUDA 9.2 installed. The basic set up for the LSTM model is as follows:","__index_level_0__":3906}
+{"text":"```\ninput_size = 512\nhidden_size = 512\nmini_batch = 64\nnumLayers = 1\nseq_length = 100 \n```","__index_level_0__":3907}
+{"text":"The most important thing PyTorch JIT did is to compile the python program to a PyTorch JIT IR, which is an intermediate representation used to model the program's graph structure. This IR can then benefit from whole program optimization, hardware acceleration and overall has the potential to provide large computation gains. In this example, we run the initial TorchScript model with only compiler optimization passes that are provided by the JIT, including common subexpression elimination, constant pooling, constant propagation, dead code elimination and some peephole optimizations. We run the model training for 100 times after warm up and average the training time. The initial results for model forward time is around 27ms and backward time is around 64ms, which is a bit far away from what PyTorch cuDNN LSTM provided. Next we will explain the major optimizations we did on how we improve the performance on training or inferencing, starting with LSTMCell and LSTMLayer, and some misc optimizations. ","__index_level_0__":3908}
+{"text":"### LSTM Cell (forward)","__index_level_0__":3909}
+{"text":"Almost all the computations in an LSTM happen in the LSTMCell, so it's important for us to take a look at the computations it contains and how can we improve their speed. Below is a sample LSTMCell implementation in TorchScript:","__index_level_0__":3910}
+{"text":"```python\nclass LSTMCell(jit.ScriptModule):\n    def __init__(self, input_size, hidden_size):\n        super(LSTMCell, self).__init__()\n        self.input_size = input_size\n        self.hidden_size = hidden_size\n        self.weight_ih = Parameter(torch.randn(4 * hidden_size, input_size))\n        self.weight_hh = Parameter(torch.randn(4 * hidden_size, hidden_size))\n        self.bias_ih = Parameter(torch.randn(4 * hidden_size))\n        self.bias_hh = Parameter(torch.randn(4 * hidden_size))","__index_level_0__":3911}
+{"text":"    @jit.script_method\n    def forward(self, input, state):\n        # type: (Tensor, Tuple[Tensor, Tensor]) -> Tuple[Tensor, Tuple[Tensor, Tensor]]\n        hx, cx = state\n        gates = (torch.mm(input, self.weight_ih.t()) + self.bias_ih +\n                 torch.mm(hx, self.weight_hh.t()) + self.bias_hh)\n        ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1)","__index_level_0__":3912}
+{"text":"        ingate = torch.sigmoid(ingate)\n        forgetgate = torch.sigmoid(forgetgate)\n        cellgate = torch.tanh(cellgate)\n        outgate = torch.sigmoid(outgate)","__index_level_0__":3913}
+{"text":"        cy = (forgetgate * cx) + (ingate * cellgate)\n        hy = outgate * torch.tanh(cy)","__index_level_0__":3914}
+{"text":"        return hy, (hy, cy)\n```","__index_level_0__":3915}
+{"text":"\nThis graph representation (IR) that TorchScript generated enables several optimizations and scalable computations. In addition to the typical compiler optimizations that we could do (CSE, constant propagation, etc. ) we can also run other IR transformations to make our code run faster. ","__index_level_0__":3916}
+{"text":"* Element-wise operator fusion. PyTorch JIT will automatically fuse element-wise ops, so when you have adjacent operators that are all element-wise, JIT will automatically group all those operations together into a single FusionGroup, this FusionGroup can then be launched with a single GPU\/CPU kernel and performed in one pass. This avoids expensive memory reads and writes for each operation.\n* Reordering chunks and pointwise ops to enable more fusion. An LSTM cell adds gates together (a pointwise operation), and then chunks the gates into four pieces: the ifco gates. Then, it performs pointwise operations on the ifco gates like above. This leads to two fusion groups in practice: one fusion group for the element-wise ops pre-chunk, and one group for the element-wise ops post-chunk.\n    The interesting thing to note here is that pointwise operations commute with `torch.chunk`: Instead of performing pointwise ops on some input tensors and chunking the output, we can chunk the input tensors and then perform the same pointwise ops on the output tensors. By moving the chunk to before the first fusion group, we can merge the first and second fusion groups into one big group. ","__index_level_0__":3917}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/custom-rnn-chunk.png\" width=\"40%\">\n<\/div>","__index_level_0__":3918}
+{"text":"* Tensor creation on the CPU is expensive, but there is ongoing work to make it faster. At this point, a LSTMCell runs three CUDA kernels: two `gemm` kernels and one for the single pointwise group. One of the things we noticed was that there was a large gap between the finish of the second `gemm` and the start of the single pointwise group. This gap was a period of time when the GPU was idling around and not doing anything. Looking into it more, we discovered that the problem was that `torch.chunk` constructs new tensors and that tensor construction was not as fast as it could be. Instead of constructing new Tensor objects, we taught the fusion compiler how to manipulate a data pointer and strides to do the `torch.chunk` before sending it into the fused kernel, shrinking the amount of idle time between the second gemm and the launch of the element-wise fusion group. This give us around 1.2x increase speed up on the LSTM forward pass.","__index_level_0__":3919}
+{"text":"By doing the above tricks, we are able to fuse the almost all `LSTMCell` forward graph (except the two gemm kernels) into a single fusion group, which corresponds to the `prim::FusionGroup_0` in the above IR graph. It will then be launched into a single fused kernel for execution. With these optimizations the model performance improves significantly with average forward time reduced by around 17ms (1.7x speedup) to 10ms, and average backward time reduce by 37ms to 27ms (1.37x speed up). ","__index_level_0__":3920}
+{"text":"### LSTM Layer (forward)","__index_level_0__":3921}
+{"text":"```python\nclass LSTMLayer(jit.ScriptModule):\n    def __init__(self, cell, *cell_args):\n        super(LSTMLayer, self).__init__()\n        self.cell = cell(*cell_args)","__index_level_0__":3922}
+{"text":"    @jit.script_method\n    def forward(self, input, state):\n        # type: (Tensor, Tuple[Tensor, Tensor]) -> Tuple[Tensor, Tuple[Tensor, Tensor]]\n        inputs = input.unbind(0)\n        outputs = torch.jit.annotate(List[Tensor], [])\n        for i in range(len(inputs)):\n            out, state = self.cell(inputs[i], state)\n            outputs += [out]\n        return torch.stack(outputs), state\n```","__index_level_0__":3923}
+{"text":"We did several tricks on the IR we generated for TorchScript LSTM to boost the performance, some example optimizations we did:","__index_level_0__":3924}
+{"text":"* Loop Unrolling: We automatically unroll loops in the code (for big loops, we unroll a small subset of it), which then empowers us to do further optimizations on the for loops control flow. For example, the fuser can fuse together operations across iterations of the loop body, which results in a good performance improvement for control flow intensive models like LSTMs.\n* Batch Matrix Multiplication: For RNNs where the input is pre-multiplied (i.e. the model has a lot of matrix multiplies with the same LHS or RHS), we can efficiently batch those operations together into a single matrix multiply while chunking the outputs to achieve equivalent semantics. ","__index_level_0__":3925}
+{"text":"By applying these techniques, we reduced our time in the forward pass by an additional 1.6ms to 8.4ms (1.2x speed up) and timing in backward by 7ms to around 20ms (1.35x speed up). ","__index_level_0__":3926}
+{"text":"### LSTM Layer (backward)","__index_level_0__":3927}
+{"text":"* \u201cTree\u201d Batch Matrix Muplication: It is often the case that a single weight is reused multiple times in the LSTM backward graph, forming a tree where the leaves are matrix multiplies and nodes are adds.  These nodes can be combined together by concatenating the LHSs and RHSs in different dimensions, then computed as a single matrix multiplication. The formula of equivalence can be denoted as follows:\n    \n    $L1 * R1 + L2 * R2 = torch.cat((L1, L2), dim=1) * torch.cat((R1, R2), dim=0)$\n    \n* Autograd is a critical component of what makes PyTorch such an elegant ML framework. As such, we carried this through to PyTorch JIT,  but using a new **Automatic Differentiation** (AD) mechanism that works on the IR level.  JIT automatic differentiation will slice the forward graph into symbolically differentiable subgraphs, and generate backwards nodes for those subgraphs.  Taking the above IR as an example, we group the graph nodes into a single `prim::DifferentiableGraph_0` for the operations that has AD formulas. For operations that have not been added to AD formulas, we will fall back to Autograd during execution. ","__index_level_0__":3928}
+{"text":"* Optimizing the backwards path is hard, and the implicit broadcasting semantics make the optimization of automatic differentiation harder. PyTorch makes it convenient to write tensor operations without worrying about the shapes by broadcasting the tensors for you. For performance, the painful point in backward is that we need to have a summation for such kind of broadcastable operations. This results in the derivative of every broadcastable op being followed by a summation. Since we cannot currently fuse reduce operations, this causes FusionGroups to break into multiple small groups leading to bad performance. To deal with this, refer to this great [post](http:\/\/lernapparat.de\/fast-lstm-pytorch\/) written by Thomas Viehmann.","__index_level_0__":3929}
+{"text":"### Misc Optimizations","__index_level_0__":3930}
+{"text":"* In addition to the steps laid about above, we also eliminated overhead between CUDA kernel launches and unnecessary tensor allocations. One example is when you do a tensor device look up. This can provide some poor performance initially with a lot of unnecessary allocations. When we remove these this results in a reduction from milliseconds to nanoseconds between kernel launches.\n* Lastly, there might be normalization applied in the custom LSTMCell like LayerNorm. Since LayerNorm and other normalization ops contains reduce operations, it is hard to fuse it in its entirety. Instead, we automatically decompose Layernorm to a statistics computation (reduce operations) + element-wise transformations, and then fuse those element-wise parts together. As of this post, there are some limitations on our auto differentiation and graph fuser infrastructure which limits the current support to inference mode only. We plan to add backward support in a future release. ","__index_level_0__":3931}
+{"text":"With the above optimizations on operation fusion, loop unrolling, batch matrix multiplication and some misc optimizations, we can see a clear performance increase on our custom TorchScript LSTM forward and backward from the following figure: ","__index_level_0__":3932}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/custom-rnn-improve.png\" width=\"40%\">\n<\/div>","__index_level_0__":3933}
+{"text":"\nThere are a number of additional optimizations that we did not cover in this post. In addition to the ones laid out in this post, we now see that our custom LSTM forward pass is on par with cuDNN. We are also working on optimizing backward more and expect to see improvements in future releases. Besides the speed that TorchScript provides, we introduced a much more flexible API that enable you to hand draft a lot more custom RNNs, which cuDNN could not provide. ","__index_level_0__":3934}
+{"text":" \n source: https:\/\/pytorch.org\/blog\/optimizing-cuda-rnn-with-torchscript\/ \n category: pytorch blogs","__index_level_0__":3935}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch, a year in....\"\nauthor: \"The PyTorch Team\"\ndate: 2018-01-19 12:00:00 -0500\nredirect_from: \/2018\/01\/19\/a-year-in.html\n---","__index_level_0__":3936}
+{"text":"Today marks 1 year since PyTorch was released publicly. It's been a wild ride \u2014 our quest to build a flexible deep learning research platform. Over the last year, we've seen an amazing community of people using, contributing to and evangelizing PyTorch \u2014 thank you for the love.","__index_level_0__":3937}
+{"text":"Looking back, we wanted to summarize PyTorch over the past year: the progress, the news and highlights from the community.","__index_level_0__":3938}
+{"text":"## Community","__index_level_0__":3939}
+{"text":"We've been blessed with a strong organic community of researchers and engineers who fell in love with PyTorch. The core team has engineers and researchers from multiple countries, companies and universities, and we couldn't have made PyTorch what it is without each contribution.","__index_level_0__":3940}
+{"text":"\n### Research papers, packages and Github","__index_level_0__":3941}
+{"text":"Within days of release, users from the community started to implement their favorite research papers in PyTorch and release the code on Github. Open-source code is a primary and essential tool for researchers today.","__index_level_0__":3942}
+{"text":"Folks came together to create [torchtext](https:\/\/github.com\/pytorch\/text), [torchvision](https:\/\/github.com\/pytorch\/vision) and [torchaudio](https:\/\/github.com\/pytorch\/audio) packages to help facilitate and democratize research in different domains.","__index_level_0__":3943}
+{"text":"The first community package based on PyTorch came from Brandon Amos, [titled Block](https:\/\/twitter.com\/brandondamos\/status\/828652480573607937), and helped with easier manipulation of block matrices. The Locus Lab at **CMU** subsequently went on to [publish PyTorch packages](https:\/\/github.com\/locuslab) and implementations for most of their research. The first research paper code came from Sergey Zagoruyko titled [Paying more attention to attention](https:\/\/twitter.com\/PyTorch\/status\/822561885744726016).","__index_level_0__":3944}
+{"text":"Jun-Yan Zhu, Taesung Park, Phillip Isola, Alyosha Efros and team from **U.C.Berkeley** released the hugely popular [Cycle-GAN and pix2pix](https:\/\/github.com\/junyanz\/pytorch-CycleGAN-and-pix2pix) which does image to image transforms.","__index_level_0__":3945}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/horse2zebra.gif\">\n<\/div>","__index_level_0__":3946}
+{"text":"The researchers at **HarvardNLP** and **Systran** started developing and improving [OpenNMT in PyTorch](https:\/\/github.com\/OpenNMT\/OpenNMT-py), seeded by initial reimplementation of the [Lua]Torch code from Adam Lerer at Facebook.","__index_level_0__":3947}
+{"text":"The MagicPony team at **Twitter** contributed implementations of their [Super-resolution work early on into PyTorch's examples](https:\/\/twitter.com\/Rob_Bishop\/status\/821793080877588480).","__index_level_0__":3948}
+{"text":"**Salesforce Research** released several packages, including their highlight release of [PyTorch-QRNN](https:\/\/twitter.com\/Smerity\/status\/917472260851560448), a type of RNN that is 2x to 17x faster than standard LSTMs optimized by CuDNN. James Bradbury and team form one of the most active and engaging forces in the PyTorch community.","__index_level_0__":3949}
+{"text":"<blockquote class=\"twitter-tweet\" data-lang=\"en\"><p lang=\"en\" dir=\"ltr\">We&#39;re releasing <a href=\"https:\/\/twitter.com\/PyTorch?ref_src=twsrc%5Etfw\">@PyTorch<\/a>-QRNN, 2-17x faster than NVIDIA&#39;s cuDNN LSTM.<br>Speed thanks to 50 lines of CUDA via CuPy.<a href=\"https:\/\/t.co\/KaWhN4yDZd\">https:\/\/t.co\/KaWhN4yDZd<\/a> <a href=\"https:\/\/t.co\/yoLYj3pMI0\">pic.twitter.com\/yoLYj3pMI0<\/a><\/p>&mdash; Smerity (@Smerity) <a href=\"https:\/\/twitter.com\/Smerity\/status\/917472260851560448?ref_src=twsrc%5Etfw\">October 9, 2017<\/a><\/blockquote>\n<script async src=\"https:\/\/platform.twitter.com\/widgets.js\" charset=\"utf-8\"><\/script>","__index_level_0__":3950}
+{"text":"Researchers from **Uber**, **Northeastern** and **Stanford** came together to form an active probabilistic programming community around their packages [Pyro](http:\/\/pyro.ai\/) and [ProbTorch](https:\/\/github.com\/probtorch\/probtorch). They are actively developing the torch.distributions core package. This community is so active and fast-moving, we had our first pytorch-probabilistic-programming meetup at NIPS 2017 with Fritz Obermeyer, Noah Goodman, Jan-Willem van de Meent, Brooks Paige, Dustin Tran and 22 additional attendees discussing how to make the world bayesian.","__index_level_0__":3951}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/probpackages.png\" width=\"40%\">\n<\/div>","__index_level_0__":3952}
+{"text":"**NVIDIA** Researchers released three high-quality repositories that implemented [pix2pix-HD](https:\/\/github.com\/NVIDIA\/pix2pixHD), [Sentiment Neuron](https:\/\/github.com\/NVIDIA\/sentiment-discovery) and [FlowNet2](https:\/\/github.com\/NVIDIA\/flownet2-pytorch) papers. Their analysis of scalability of different [Data Parallel models in PyTorch](https:\/\/github.com\/NVIDIA\/sentiment-discovery\/blob\/master\/analysis\/scale.md) was helpful to the community.","__index_level_0__":3953}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/sentiment.png\" width=\"40%\">\n<\/div>","__index_level_0__":3954}
+{"text":"The Allen Institute for AI released [AllenNLP](http:\/\/allennlp.org\/) which includes several state-of-the-art models in NLP \u2014 reference implementations and easy to use [web demos](http:\/\/demo.allennlp.org\/machine-comprehension) for standard NLP tasks.","__index_level_0__":3955}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/allennlp.png\" width=\"40%\">\n<\/div>","__index_level_0__":3956}
+{"text":"We also had our first Kaggle winning team grt123 in July. They won the DataScience Bowl 2017 on Lung Cancer detection and [subsequently released their PyTorch implementations](https:\/\/twitter.com\/PyTorch\/status\/881573658166267904).","__index_level_0__":3957}
+{"text":"On the visualization front, Tzu-Wei Huang implemented a [TensorBoard-PyTorch plugin](https:\/\/github.com\/lanpa\/tensorboard-pytorch) and Facebook AI Research released PyTorch compatibility for their [visdom](https:\/\/github.com\/facebookresearch\/visdom) visualization package.","__index_level_0__":3958}
+{"text":"<div class=\"text-center\">\n  <img src='{{ site.url }}\/assets\/images\/tensorboard_model.png' width='40%'\/>\n  <img src='{{ site.url }}\/assets\/images\/visdom.png' width='40%'\/>\n<\/div>","__index_level_0__":3959}
+{"text":"Lastly, **Facebook AI Research** released several projects such as [ParlAI, fairseq-py, VoiceLoop and FaderNetworks](https:\/\/github.com\/facebookresearch\/) that implemented cutting-edge models and interfaced datasets in multiple domains.","__index_level_0__":3960}
+{"text":"There are countless good projects that we haven't highlighted for the lack of space, you can find a curated list [here](https:\/\/github.com\/soumith?tab=stars).","__index_level_0__":3961}
+{"text":"We would also like to give a huge shout-out to folks who actively help others out on the Forums, especially [ptrblck](https:\/\/discuss.pytorch.org\/u\/ptrblck\/summary), [jpeg729](https:\/\/discuss.pytorch.org\/u\/jpeg729\/summary), [QuantScientist](https:\/\/discuss.pytorch.org\/u\/quantscientist\/summary), [albanD](https:\/\/discuss.pytorch.org\/u\/alband\/summary), [Thomas Viehmann](https:\/\/discuss.pytorch.org\/u\/tom\/summary) and [chenyuntc](https:\/\/discuss.pytorch.org\/u\/chenyuntc\/summary). You are providing an invaluable service, thank you so much!","__index_level_0__":3962}
+{"text":"In terms of sheer numbers,","__index_level_0__":3964}
+{"text":"* 87,769 lines of Python code on github that [import torch](https:\/\/github.com\/search?l=Python&q=import+torch&type=Code)\n* [3,983 repositories on Github that mention PyTorch in their name or description](https:\/\/github.com\/search?q=pytorch&type=Repositories)\n* More than half a million downloads of PyTorch binaries. 651,916 to be precise.\n* **5,400 users** wrote **21,500 posts** discussing 5,200 topics on our forums discuss.pytorch.org (http:\/\/discuss.pytorch.org\/)\n* 131 mentions of PyTorch on Reddit's \/r\/machinelearning since the day of release. In the same period, TensorFlow was mentioned 255 times.","__index_level_0__":3965}
+{"text":"\n### Research Metrics","__index_level_0__":3966}
+{"text":"PyTorch is a research-focused framework. So one of the metrics of interest is to see the usage of PyTorch in machine learning research papers.","__index_level_0__":3967}
+{"text":"\n* In the recent ICLR2018 conference submissions, PyTorch was mentioned in **87 papers**, compared to TensorFlow at 228 papers, Keras at 42 papers, Theano and Matlab at 32 papers.","__index_level_0__":3968}
+{"text":"* [Monthly arxiv.org mentions for frameworks](https:\/\/twitter.com\/fchollet\/status\/951828914103402497) had PyTorch at 72 mentions, with TensorFlow at 273 mentions, Keras at 100 mentions, Caffe at 94 mentions and Theano at 53 mentions.","__index_level_0__":3969}
+{"text":"## Courses, Tutorials and Books","__index_level_0__":3970}
+{"text":"When we released PyTorch, we had good API documentation, but our tutorials were limited to a few ipython notebooks \u2014 helpful, but not good enough.","__index_level_0__":3971}
+{"text":"[Sasank Chilamkurthy](https:\/\/github.com\/chsasank) took it upon himself to revamp the tutorials into the [beautiful website](https:\/\/pytorch.org\/tutorials\/) that it is today.","__index_level_0__":3972}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/blog_combined_tutorials.png\" width=\"40%\">\n<\/div>","__index_level_0__":3973}
+{"text":"[Sean Robertson](https:\/\/github.com\/spro\/practical-pytorch) and [Justin Johnson](https:\/\/github.com\/jcjohnson\/pytorch-examples) wrote great new tutorials \u2014 in NLP, and to learn by example. [Yunjey Choi](https:\/\/github.com\/yunjey\/pytorch-tutorial) wrote a beautiful tutorial where most models were implemented in 30 lines or less.\nEach new tutorial helped users find their way faster, with different approaches to learning.","__index_level_0__":3974}
+{"text":"[Goku Mohandas and Delip Rao](https:\/\/twitter.com\/PyTorch\/status\/888500355943641088) switched the code content of their book-in-progress to use PyTorch.","__index_level_0__":3975}
+{"text":"We've seen quite a few university machine learning courses being taught with PyTorch as the primary tool, such as Harvard's [CS287](https:\/\/harvard-ml-courses.github.io\/cs287-web\/). Taking it one step further and democratizing learning, we had three online courses pop up that teach using PyTorch.","__index_level_0__":3976}
+{"text":"- **Fast.ai's** \u201cDeep Learning for Coders\u201d is a popular online course. In September, Jeremy and Rachel [announced that the next fast.ai courses will be nearly entirely based on PyTorch](http:\/\/www.fast.ai\/2017\/09\/08\/introducing-pytorch-for-fastai\/).\n- Ritchie Ng, a researcher with ties to NUS Singapore and Tsinghua released [a Udemy course](https:\/\/www.udemy.com\/practical-deep-learning-with-pytorch\/) titled Practical Deep Learning with PyTorch.\n- Sung Kim from HKUST released an [online course on Youtube](https:\/\/www.youtube.com\/playlist?list=PLlMkM4tgfjnJ3I-dbhO9JTw7gNty6o_2m) that was aimed towards a general audience, titled: \u201cPyTorch Zero to All\u201d.","__index_level_0__":3977}
+{"text":"\n## Engineering","__index_level_0__":3978}
+{"text":"Over the last year we implemented multiple features, improved performance across the board and fixed lots of bugs. A full list of the work we've done is found in our [release notes](https:\/\/github.com\/pytorch\/pytorch\/releases).\nHere are highlights from our work over the last year:","__index_level_0__":3979}
+{"text":"## Higher-order gradients","__index_level_0__":3980}
+{"text":" With the release of several papers that implement penalties of gradients and with ongoing research in 2nd order gradient methods, this was an essential and sought-after feature. In August, we implemented a generalized interface that can take n-th order derivatives and increased the coverage of functions that support higher-order gradients over time, such that at the moment of writing almost all ops support this.","__index_level_0__":3981}
+{"text":"\n## Distributed PyTorch","__index_level_0__":3982}
+{"text":"In August, we released a small distributed package that followed the highly popular MPI-collective approach. The package has multiple backends such as TCP, MPI, Gloo and NCCL2 to support various types of CPU\/GPU collective operations and use-cases, and integrates distributed technologies such as Infiniband and RoCE. Distributed is hard, and we had bugs in the initial iteration. Over subsequent releases, we made the package more stable and improved performance.","__index_level_0__":3983}
+{"text":"## Closer to NumPy","__index_level_0__":3984}
+{"text":"One of the biggest demands from users were NumPy features that they were familiar with. Features such as Broadcasting and Advanced Indexing are convenient and save users a lot of verbosity. We implemented these features and started to align our API to be closer to NumPy. Over time, we expect to get closer and closer to NumPy's API where appropriate.","__index_level_0__":3985}
+{"text":"## Sparse Tensors","__index_level_0__":3986}
+{"text":"In March, we released a small package supporting sparse Tensors and in May we released CUDA support for the sparse package. The package is small and limited in functionality, and is used for implementing Sparse Embeddings and commonly used sparse paradigms in deep learning. This package is still small in scope and there's demand to expand it \u2014 if you are interested in working on expanding the sparse package, reach out to us on our [Discussion Boards](https:\/\/discuss.pytorch.org\/)","__index_level_0__":3987}
+{"text":"\n## Performance","__index_level_0__":3988}
+{"text":"Performance is always an ongoing battle, especially for PyTorch which is a dynamic framework that wants to maximize flexibility. Over the last year, we've improved performance across board, from our core Tensor library to the neural network operators, writing faster micro-optimized across board.","__index_level_0__":3989}
+{"text":"* We've added specialized AVX and AVX2 intrinsics for Tensor operations\n* Wrote faster GPU kernels for frequent workloads like concatenation and Softmax (among many other things)\n* Rewrote the code for several neural network operators (too many to list), but notably nn.Embedding and group convolutions.","__index_level_0__":3990}
+{"text":"**Reducing framework overhead by 10x across board**","__index_level_0__":3991}
+{"text":"Since PyTorch is a dynamic graph framework, we create a new graph on the fly at every iteration of a training loop. Hence, the framework overhead has to be low, or the workload has to be large enough that the framework overhead is hidden. In August, the authors of DyNet (Graham Neubig and team) showcased that it's much faster than PyTorch on small NLP models. This was an interesting challenge, we didn't realize that models of those sizes were being trained. In a multi-month (and ongoing) effort, we embarked upon a significant rewrite of PyTorch internals that reduced the framework overhead from more than 10 microseconds per operator execution to as little as 1 microsecond.","__index_level_0__":3992}
+{"text":"As we embarked upon a redesign of the PyTorch internals, we built the [ATen C++11](https:\/\/github.com\/pytorch\/pytorch\/tree\/master\/aten) library that now powers all of the PyTorch backend. ATen has an API that mirrors PyTorch's Python API, which makes it a convenient C++ library for Tensor computation. ATen can be built and used independently of PyTorch.","__index_level_0__":3994}
+{"text":"## Exporting models to production \u2014 ONNX Support and the JIT compiler","__index_level_0__":3995}
+{"text":"One of the common requests we've received was to export PyTorch models to another framework. Users engaged in a rapid research cycle in PyTorch and when they were done, they wanted to ship it to larger projects with C++ only requirements.","__index_level_0__":3996}
+{"text":"With this in mind, we built a tracer for PyTorch \u2014 which can export PyTorch models into an intermediate representation.\nThe subsequent trace can be either used to run the current PyTorch model more efficiently (by running optimization passes on it), or be converted to the [ONNX](http:\/\/onnx.ai\/) format to be shipped to other frameworks such as Caffe2, MXNet, TensorFlow and others or directly to the hardware accelerated libraries like CoreML or TensorRT. Over the next year, you will hear more about the JIT compiler for performance improvements.","__index_level_0__":3997}
+{"text":"\n## Users being funny :)","__index_level_0__":3998}
+{"text":"Our users express their support in funny ways, made us laugh, thanks for this :)","__index_level_0__":3999}
+{"text":"<blockquote class=\"twitter-tweet\" data-lang=\"en\"><p lang=\"en\" dir=\"ltr\">I&#39;ve been using PyTorch a few months now and I&#39;ve never felt better. I have more energy. My skin is clearer. My eye sight has improved.<\/p>&mdash; Andrej Karpathy (@karpathy) <a href=\"https:\/\/twitter.com\/karpathy\/status\/868178954032513024?ref_src=twsrc%5Etfw\">May 26, 2017<\/a><\/blockquote>\n<script async src=\"https:\/\/platform.twitter.com\/widgets.js\" charset=\"utf-8\"><\/script>","__index_level_0__":4000}
+{"text":"<blockquote class=\"twitter-tweet\" data-lang=\"en\"><p lang=\"en\" dir=\"ltr\">Talk to your doctor to find out if PyTorch is right for you.<\/p>&mdash; Sean Robertson (@sprobertson) <a href=\"https:\/\/twitter.com\/sprobertson\/status\/868180795000750080?ref_src=twsrc%5Etfw\">May 26, 2017<\/a><\/blockquote>\n<script async src=\"https:\/\/platform.twitter.com\/widgets.js\" charset=\"utf-8\"><\/script>","__index_level_0__":4001}
+{"text":"<blockquote class=\"twitter-tweet\" data-lang=\"en\"><p lang=\"en\" dir=\"ltr\">PyTorch gave me so much life that my skin got cleared, my grades are up, my bills are paid and my crops are watered.<\/p>&mdash; Adam Will \u00f0\ufe0f\u200d\u00f0 (@adam_will_do_it) <a href=\"https:\/\/twitter.com\/adam_will_do_it\/status\/868179679483764736?ref_src=twsrc%5Etfw\">May 26, 2017<\/a><\/blockquote>\n<script async src=\"https:\/\/platform.twitter.com\/widgets.js\" charset=\"utf-8\"><\/script>","__index_level_0__":4002}
+{"text":"<blockquote class=\"twitter-tweet\" data-lang=\"en\"><p lang=\"en\" dir=\"ltr\">So have I! But my hair is also shiner and I&#39;ve lost weight. <a href=\"https:\/\/twitter.com\/PyTorch?ref_src=twsrc%5Etfw\">@PyTorch<\/a> for the win. <a href=\"https:\/\/t.co\/qgU4oIOB4K\">https:\/\/t.co\/qgU4oIOB4K<\/a><\/p>&mdash; Mariya (@thinkmariya) <a href=\"https:\/\/twitter.com\/thinkmariya\/status\/868181991212044288?ref_src=twsrc%5Etfw\">May 26, 2017<\/a><\/blockquote>\n<script async src=\"https:\/\/platform.twitter.com\/widgets.js\" charset=\"utf-8\"><\/script>\n \n source: https:\/\/pytorch.org\/blog\/a-year-in\/ \n category: pytorch blogs","__index_level_0__":4003}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch for AMD ROCm\u2122 Platform now available as Python package'\nauthor: Niles Burbank \u2013 Director PM at AMD, Mayank Daga \u2013 Director, Deep Learning Software at AMD\n---","__index_level_0__":4004}
+{"text":"With the PyTorch 1.8 release, we are delighted to announce a new installation option for users of\nPyTorch on the ROCm\u2122 open software platform. An installable Python package is now hosted on\npytorch.org, along with instructions for local installation in the same simple, selectable format as\nPyTorch packages for CPU-only configurations and other GPU platforms. PyTorch on ROCm includes full\ncapability for mixed-precision and large-scale training using AMD\u2019s MIOpen & RCCL libraries. This\nprovides a new option for data scientists, researchers, students, and others in the community to get\nstarted with accelerated PyTorch using AMD GPUs.","__index_level_0__":4005}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/amd_rocm_blog.png\" width=\"100%\">\n<\/div>","__index_level_0__":4006}
+{"text":"## The ROCm Ecosystem","__index_level_0__":4007}
+{"text":"ROCm is AMD\u2019s open source software platform for GPU-accelerated high performance computing and\nmachine learning. Since the original ROCm release in 2016, the ROCm platform has evolved to support\nadditional libraries and tools, a wider set of Linux\u00ae distributions, and a range of new GPUs. This includes\nthe AMD Instinct\u2122 MI100, the first GPU based on AMD CDNA\u2122 architecture. \n \nThe ROCm ecosystem has an established history of support for PyTorch, which was initially implemented\nas a fork of the PyTorch project, and more recently through ROCm support in the upstream PyTorch\ncode. PyTorch users can install PyTorch for ROCm using AMD\u2019s public PyTorch docker image, and can of\ncourse build PyTorch for ROCm from source. With PyTorch 1.8, these existing installation options are\nnow complemented by the availability of an installable Python package. ","__index_level_0__":4008}
+{"text":"The primary focus of ROCm has always been high performance computing at scale. The combined\ncapabilities of ROCm and AMD\u2019s Instinct family of data center GPUs are particularly suited to the\nchallenges of HPC at data center scale. PyTorch is a natural fit for this environment, as HPC and ML\nworkflows become more intertwined.","__index_level_0__":4009}
+{"text":"### Getting started with PyTorch for ROCm","__index_level_0__":4010}
+{"text":"The scope for this build of PyTorch is AMD GPUs with ROCm support, running on Linux. The GPUs\nsupported by ROCm include all of AMD\u2019s Instinct family of compute-focused data center GPUs, along\nwith some other select GPUs. A current list of supported GPUs can be found in the [ROCm Github\nrepository](https:\/\/github.com\/RadeonOpenCompute\/ROCm#supported-gpus). After confirming that the target system includes supported GPUs and the current 4.0.1\nrelease of ROCm, installation of PyTorch follows the same simple Pip-based installation as any other\nPython package. As with PyTorch builds for other platforms, the configurator at [https:\/\/pytorch.org\/get-started\/locally\/](https:\/\/pytorch.org\/get-started\/locally\/) provides the specific command line to be run.","__index_level_0__":4011}
+{"text":"PyTorch for ROCm is built from the upstream PyTorch repository, and is a full featured implementation.\nNotably, it includes support for distributed training across multiple GPUs and supports accelerated\nmixed precision training.","__index_level_0__":4012}
+{"text":"### More information","__index_level_0__":4013}
+{"text":"A list of ROCm supported GPUs and operating systems can be found at\n[https:\/\/github.com\/RadeonOpenCompute\/ROCm](https:\/\/github.com\/RadeonOpenCompute\/ROCm)\nGeneral documentation on the ROCm platform is available at [https:\/\/rocmdocs.amd.com\/en\/latest\/](https:\/\/rocmdocs.amd.com\/en\/latest\/)\nROCm Learning Center at [https:\/\/developer.amd.com\/resources\/rocm-resources\/rocm-learning-center\/](https:\/\/developer.amd.com\/resources\/rocm-resources\/rocm-learning-center\/) General information on AMD\u2019s offerings for HPC and ML can be found at [https:\/\/amd.com\/hpc](https:\/\/amd.com\/hpc)","__index_level_0__":4014}
+{"text":"### Feedback\nAn engaged user base is a tremendously important part of the PyTorch ecosystem. We would be deeply\nappreciative of feedback on the PyTorch for ROCm experience in the [PyTorch discussion forum](https:\/\/discuss.pytorch.org\/) and, where appropriate, reporting any issues via [Github](https:\/\/github.com\/pytorch\/pytorch).\n \n source: https:\/\/pytorch.org\/blog\/pytorch-for-amd-rocm-platform-now-available-as-python-package\/ \n category: pytorch blogs","__index_level_0__":4015}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"A Tour of PyTorch Internals (Part I)\"\nauthor: \"Trevor Killeen\"\ndate: 2017-05-11 12:00:00 -0500\nredirect_from: \/2017\/05\/11\/Internals.html\n---","__index_level_0__":4016}
+{"text":"The fundamental unit in PyTorch is the Tensor. This post will serve as an overview for how we implement Tensors in PyTorch, such that the user can interact with it from the Python shell. In particular, we want to answer four main questions:","__index_level_0__":4017}
+{"text":"-  How does PyTorch extend the Python interpreter to define a Tensor type that can be manipulated from Python code?\n-  How does PyTorch wrap the C libraries that actually define the Tensor's properties and methods?\n-  How does PyTorch cwrap work to generate code for Tensor methods?\n-  How does PyTorch's build system take all of these components to compile and generate a workable application?","__index_level_0__":4018}
+{"text":"## Extending the Python Interpreter","__index_level_0__":4019}
+{"text":"PyTorch defines a new package `torch`. In this post we will consider the `._C` module. This module is known as an \"extension module\" - a Python module written in C. Such modules allow us to define new built-in object types (e.g. the `Tensor`) and to call C\/C++ functions.","__index_level_0__":4020}
+{"text":"The `._C` module is defined in `torch\/csrc\/Module.cpp`. The `init_C()` \/ `PyInit__C()` function creates the module and adds the method definitions as appropriate. This module is passed around to a number of different `__init()` functions that add further objects to the module, register new types, etc.","__index_level_0__":4021}
+{"text":"One collection of these `__init()` calls is the following:","__index_level_0__":4022}
+{"text":"```cpp\nASSERT_TRUE(THPDoubleTensor_init(module));\nASSERT_TRUE(THPFloatTensor_init(module));\nASSERT_TRUE(THPHalfTensor_init(module));\nASSERT_TRUE(THPLongTensor_init(module));\nASSERT_TRUE(THPIntTensor_init(module));\nASSERT_TRUE(THPShortTensor_init(module));\nASSERT_TRUE(THPCharTensor_init(module));\nASSERT_TRUE(THPByteTensor_init(module));\n```","__index_level_0__":4023}
+{"text":"These `__init()` functions add the Tensor object for each type to the `._C` module so that they can be used in the module. Let's learn how these methods work.","__index_level_0__":4024}
+{"text":"## The THPTensor Type","__index_level_0__":4025}
+{"text":"Much like the underlying `TH` and `THC` libraries, PyTorch defines a \"generic\" Tensor which is then specialized to a number of different types. Before considering how this specialization works, let's first consider how defining a new type in Python works, and how we create the generic `THPTensor` type.","__index_level_0__":4026}
+{"text":"The Python runtime sees all Python objects as variables of type `PyObject *`, which serves as a \"base type\" for all Python objects. Every Python type contains the refcount for the object, and a pointer to the object's *type object*. The type object determines the properties of the type. For example, it might contain a list of methods associated with the type, and which C functions get called to implement those methods. The object also contains any fields necessary to represent its state.","__index_level_0__":4027}
+{"text":"The formula for defining a new type is as follows:","__index_level_0__":4028}
+{"text":"- Create a struct that defines what the new object will contain\n- Define the type object for the type","__index_level_0__":4029}
+{"text":"The struct itself could be very simple. Inn Python, all floating point types are actually objects on the heap. The Python float struct is defined as:\n```cpp\ntypedef struct {\n    PyObject_HEAD\n    double ob_fval;\n} PyFloatObject;\n```\nThe `PyObject_HEAD` is a macro that brings in the code that implements an object's reference counting, and a pointer to the corresponding type object. So in this case, to implement a float, the only other \"state\" needed is the floating point value itself.","__index_level_0__":4030}
+{"text":"Now, let's see the struct for our `THPTensor` type:\n```cpp\nstruct THPTensor {\n    PyObject_HEAD\n    THTensor *cdata;\n};\n```\nPretty simple, right? We are just wrapping the underlying `TH` tensor by storing a pointer to it.","__index_level_0__":4031}
+{"text":"The key part is defining the \"type object\" for a new type. An example definition of a type object for our Python float takes the form:\n```cpp\nstatic PyTypeObject py_FloatType = {\n    PyVarObject_HEAD_INIT(NULL, 0)\n    \"py.FloatObject\",          \/* tp_name *\/\n    sizeof(PyFloatObject),     \/* tp_basicsize *\/\n    0,                         \/* tp_itemsize *\/\n    0,                         \/* tp_dealloc *\/\n    0,                         \/* tp_print *\/\n    0,                         \/* tp_getattr *\/\n    0,                         \/* tp_setattr *\/\n    0,                         \/* tp_as_async *\/\n    0,                         \/* tp_repr *\/\n    0,                         \/* tp_as_number *\/\n    0,                         \/* tp_as_sequence *\/\n    0,                         \/* tp_as_mapping *\/\n    0,                         \/* tp_hash  *\/\n    0,                         \/* tp_call *\/\n    0,                         \/* tp_str *\/\n    0,                         \/* tp_getattro *\/\n    0,                         \/* tp_setattro *\/\n    0,                         \/* tp_as_buffer *\/\n    Py_TPFLAGS_DEFAULT,        \/* tp_flags *\/\n    \"A floating point number\", \/* tp_doc *\/\n};\n```\nThe easiest way to think of a *type object* is as a set of fields which define the properties of the object. For example, the `tp_basicsize` field is set to `sizeof(PyFloatObject)`. This is so that Python knows how much memory to allocate when calling `PyObject_New()` for a `PyFloatObject.` The full list of fields you can set is defined in `object.h` in the CPython backend:\nhttps:\/\/github.com\/python\/cpython\/blob\/master\/Include\/object.h.","__index_level_0__":4032}
+{"text":"The type object for our `THPTensor` is `THPTensorType`, defined in `csrc\/generic\/Tensor.cpp`. This object defines the name, size, mapping methods, etc. for a `THPTensor`.","__index_level_0__":4033}
+{"text":"As an example, let's take a look at the `tp_new` function we set in the `PyTypeObject`:","__index_level_0__":4034}
+{"text":"```cpp\nPyTypeObject THPTensorType = {\n  PyVarObject_HEAD_INIT(NULL, 0)\n  ...\n  THPTensor_(pynew), \/* tp_new *\/\n};\n```\nThe `tp_new` function enables object creation. It is responsible for creating (as opposed to initializing) objects of that type and is equivalent to the `__new__()` method at the Python level. The C implementation is a static method that is passed the type being instantiated and any arguments, and returns a newly created object.","__index_level_0__":4035}
+{"text":"```cpp\nstatic PyObject * THPTensor_(pynew)(PyTypeObject *type, PyObject *args, PyObject *kwargs)\n{\n  HANDLE_TH_ERRORS\n  Py_ssize_t num_args = args ? PyTuple_Size(args) : 0;","__index_level_0__":4036}
+{"text":"  THPTensorPtr self = (THPTensor *)type->tp_alloc(type, 0);\n\/\/ more code below\n```\nThe first thing our new function does is allocate the `THPTensor`. It then runs through a series of initializations based off of the args passed to the function. For example, when creating a `THPTensor` *x* from another `THPTensor` *y*, we set the newly created `THPTensor`'s `cdata` field to be the result of calling `THTensor_(newWithTensor)` with the *y*'s underlying `TH` Tensor as an argument. Similar constructors exist for sizes, storages, NumPy arrays, and sequences.","__index_level_0__":4037}
+{"text":"** Note that we solely use `tp_new`, and not a combination of `tp_new` and `tp_init` (which corresponds to the `__init__()` function).","__index_level_0__":4038}
+{"text":"The other important thing defined in Tensor.cpp is how indexing works. PyTorch Tensors support Python's **Mapping Protocol**. This allows us to do things like:\n```python\nx = torch.Tensor(10).fill_(1)\ny = x[3] \/\/ y == 1\nx[4] = 2\n\/\/ etc.\n```\n** Note that this indexing extends to Tensor with more than one dimension","__index_level_0__":4039}
+{"text":"We are able to use the `[]`-style notation by defining the three mapping methods described [here.](https:\/\/docs.python.org\/3.7\/c-api\/typeobj.html#c.PyMappingMethods)","__index_level_0__":4040}
+{"text":"The most important methods are `THPTensor_(getValue)` and `THPTensor_(setValue)` which describe how to index a Tensor, for returning a new Tensor\/Scalar, or updating the values of an existing Tensor in place. Read through these implementations to better understand how PyTorch supports basic tensor indexing.","__index_level_0__":4041}
+{"text":"### Generic Builds (Part One)","__index_level_0__":4042}
+{"text":"We could spend a ton of time exploring various aspects of the `THPTensor` and how it relates to defining a new Python object. But we still need to see how the `THPTensor_(init)()` function is translated to the `THPIntTensor_init()` we used in our module initialization. How do we take our `Tensor.cpp` file that defines a \"generic\" Tensor and use it to generate Python objects for all the permutations of types? To put it another way, `Tensor.cpp` is littered with lines of code like:\n```cpp\nreturn THPTensor_(New)(THTensor_(new)(LIBRARY_STATE_NOARGS));\n```\nThis illustrates both cases we need to make type-specific:","__index_level_0__":4043}
+{"text":"* Our output code will call `THP<Type>Tensor_New(...)` in place of `THPTensor_(New)`\n* Our output code will call `TH<Type>Tensor_new(...)` in place of `THTensor_(new)`","__index_level_0__":4044}
+{"text":"In other words, for all supported Tensor types, we need to \"generate\" source code that has done the above substitutions. This is part of the \"build\" process for PyTorch. PyTorch relies on Setuptools (https:\/\/setuptools.readthedocs.io\/en\/latest\/) for building the package, and we define a `setup.py` file in the top-level directory to customize the build process.","__index_level_0__":4045}
+{"text":"One component building an Extension module using Setuptools is to list the source files involved in the compilation. However, our `csrc\/generic\/Tensor.cpp` file is not listed! So how does the code in this file end up being a part of the end product?","__index_level_0__":4046}
+{"text":"Recall that we are calling the `THPTensor*` functions (such as `init`) from the directory above `generic`. If we take a look in this directory, there is another file `Tensor.cpp` defined. The last line of this file is important:\n```cpp\n\/\/generic_include TH torch\/csrc\/generic\/Tensor.cpp\n```\nNote that this `Tensor.cpp` file is included in `setup.py`, but it is wrapped in a call to a Python helper function called `split_types`. This function takes as input a file, and looks for the \"\/\/generic_include\" string in the file contents. If it is found, it generates a new output file for each Tensor type, with the following changes:","__index_level_0__":4047}
+{"text":"- The output file is renamed to `Tensor<Type>.cpp`\n- The output file is slightly modified as follows:","__index_level_0__":4048}
+{"text":"```cpp\n# Before:\n\/\/generic_include TH torch\/csrc\/generic\/Tensor.cpp","__index_level_0__":4049}
+{"text":"# After:\n#define TH_GENERIC_FILE \"torch\/src\/generic\/Tensor.cpp\"\n#include \"TH\/THGenerate<Type>Type.h\"\n```\nIncluding the header file on the second line has the side effect of including the source code in `Tensor.cpp` with some additional context defined. Let's take a look at one of the headers:","__index_level_0__":4050}
+{"text":"```cpp\n#ifndef TH_GENERIC_FILE\n#error \"You must define TH_GENERIC_FILE before including THGenerateFloatType.h\"\n#endif","__index_level_0__":4051}
+{"text":"#define real float\n#define accreal double\n#define TH_CONVERT_REAL_TO_ACCREAL(_val) (accreal)(_val)\n#define TH_CONVERT_ACCREAL_TO_REAL(_val) (real)(_val)\n#define Real Float\n#define THInf FLT_MAX\n#define TH_REAL_IS_FLOAT\n#line 1 TH_GENERIC_FILE\n#include TH_GENERIC_FILE\n#undef accreal\n#undef real\n#undef Real\n#undef THInf\n#undef TH_REAL_IS_FLOAT\n#undef TH_CONVERT_REAL_TO_ACCREAL\n#undef TH_CONVERT_ACCREAL_TO_REAL","__index_level_0__":4052}
+{"text":"#ifndef THGenerateManyTypes\n#undef TH_GENERIC_FILE\n#endif\n```","__index_level_0__":4053}
+{"text":"What this is doing is bringing in the code from the generic `Tensor.cpp` file and surrounding it with the following macro definitions. For example, we define real as a float, so any code in the generic Tensor implementation that refers to something as a real will have that real replaced with a float. In the corresponding file `THGenerateIntType.h`, the same macro would replace `real` with `int`.","__index_level_0__":4054}
+{"text":"These output files are returned from `split_types` and added to the list of source files, so we can see how the `.cpp` code for different types is created.","__index_level_0__":4055}
+{"text":"There are a few things to note here: First, the `split_types` function is not strictly necessary. We could wrap the code in `Tensor.cpp` in a single file, repeating it for each type. The reason we split the code into separate files is to speed up compilation. Second, what we mean when we talk about the type replacement (e.g. replace real with a float) is that the C preprocessor will perform these substitutions during compilation. Merely surrounding the source code with these macros has no side effects until preprocessing.","__index_level_0__":4056}
+{"text":"### Generic Builds (Part Two)","__index_level_0__":4057}
+{"text":"Now that we have source files for all the Tensor types, we need to consider how the corresponding header declarations are created, and also how the conversions from `THTensor_(method)` and `THPTensor_(method)` to `TH<Type>Tensor_method` and `THP<Type>Tensor_method` work. For example, `csrc\/generic\/Tensor.h` has declarations like:\n```cpp\nTHP_API PyObject * THPTensor_(New)(THTensor *ptr);\n```\nWe use the same strategy for generating code in the source files for the headers. In `csrc\/Tensor.h`, we do the following:\n```cpp\n#include \"generic\/Tensor.h\"\n#include <TH\/THGenerateAllTypes.h>","__index_level_0__":4058}
+{"text":"#include \"generic\/Tensor.h\"\n#include <TH\/THGenerateHalfType.h>\n```\nThis has the same effect, where we draw in the code from the generic header, wrapped with the same macro definitions, for each type. The only difference is that the resulting code is contained all within the same header file, as opposed to being split into multiple source files.","__index_level_0__":4059}
+{"text":"Lastly, we need to consider how we \"convert\" or \"substitute\" the function types. If we look in the same header file, we see a bunch of `#define` statements, including:\n```cpp\n#define THPTensor_(NAME)            TH_CONCAT_4(THP,Real,Tensor_,NAME)\n```\nThis macro says that any string in the source code matching the format `THPTensor_(NAME)` should be replaced with `THPRealTensor_NAME`, where Real is derived from whatever the symbol Real is `#define`'d to be at the time. Because our header code and source code is surrounded by macro definitions for all the types as seen above, after the preprocessor has run, the resulting code is what we would expect. The code in the `TH` library defines the same macro for `THTensor_(NAME)`, supporting the translation of those functions as well. In this way, we end up with header and source files with specialized code.","__index_level_0__":4060}
+{"text":"#### Module Objects and Type Methods","__index_level_0__":4061}
+{"text":"Now we have seen how we have wrapped `TH`'s Tensor definition in `THP`, and generated THP methods such as `THPFloatTensor_init(...)`. Now we can explore what the above code actually does in terms of the module we are creating. The key line in `THPTensor_(init)` is:\n```cpp\n# THPTensorBaseStr, THPTensorType are also macros that are specific\n# to each type\nPyModule_AddObject(module, THPTensorBaseStr, (PyObject *)&THPTensorType);\n```\nThis function registers our Tensor objects to the extension module, so we can use THPFloatTensor, THPIntTensor, etc. in our Python code.","__index_level_0__":4062}
+{"text":"Just being able to create Tensors isn't very useful - we need to be able to call all the methods that `TH` defines. A simple example shows calling the in-place `zero_` method on a Tensor.\n```python\nx = torch.FloatTensor(10)\nx.zero_()\n```\nLet's start by seeing how we add methods to newly defined types. One of the fields in the \"type object\" is `tp_methods`. This field holds an array of method definitions (`PyMethodDef`s) and is used to associate methods (and their underlying C\/C++ implementations) with a type. Suppose we wanted to define a new method on our `PyFloatObject` that replaces the value. We could implement this as follows:\n```cpp\nstatic PyObject * replace(PyFloatObject *self, PyObject *args) {\n\tdouble val;\n\tif (!PyArg_ParseTuple(args, \"d\", &val))\n\t\treturn NULL;\n\tself->ob_fval = val;\n\tPy_RETURN_NONE\n}\n```\nThis is equivalent to the Python method:\n```python\ndef replace(self, val):\n\tself.ob_fval = val\n```\nIt is instructive to read more about how defining methods works in CPython. In general, methods take as the first parameter the instance of the object, and optionally parameters for the positional arguments and keyword arguments. This static function is registered as a method on our float:\n```cpp\nstatic PyMethodDef float_methods[] = {\n\t{\"replace\", (PyCFunction)replace, METH_VARARGS,\n\t\"replace the value in the float\"\n\t},\n\t{NULL} \/* Sentinel *\/\n}\n```\nThis registers a method called replace, which is implemented by the C function of the same name. The `METH_VARARGS` flag indicates that the method takes a tuple of arguments representing all the arguments to the function. This array is set to the `tp_methods` field of the type object, and then we can use the `replace` method on objects of that type.","__index_level_0__":4063}
+{"text":"We would like to be able to call all of the methods for `TH` tensors on our `THP` tensor equivalents. However, writing wrappers for all of the `TH` methods would be time-consuming and error prone. We need a better way to do this.","__index_level_0__":4064}
+{"text":"### PyTorch cwrap","__index_level_0__":4065}
+{"text":"PyTorch implements its own cwrap tool to wrap the `TH` Tensor methods for use in the Python backend. We define a `.cwrap` file containing a series of C method declarations in our custom [YAML format](http:\/\/yaml.org). The cwrap tool takes this file and outputs `.cpp` source files containing the wrapped methods in a format that is compatible with our `THPTensor` Python object and the Python C extension method calling format. This tool is used to generate code to wrap not only `TH`, but also `CuDNN`. It is defined to be extensible.","__index_level_0__":4066}
+{"text":"An example YAML \"declaration\" for the in-place `addmv_` function is as follows:\n```\n[[\n  name: addmv_\n  cname: addmv\n  return: self\n  arguments:\n    - THTensor* self\n    - arg: real beta\n      default: AS_REAL(1)\n    - THTensor* self\n    - arg: real alpha\n      default: AS_REAL(1)\n    - THTensor* mat\n    - THTensor* vec\n]]\n```\nThe architecture of the cwrap tool is very simple. It reads in a file, and then processes it with a series of **plugins.** See `tools\/cwrap\/plugins\/__init__.py` for documentation on all the ways a plugin can alter the code.","__index_level_0__":4067}
+{"text":"The source code generation occurs in a series of passes. First, the YAML \"declaration\" is parsed and processed. Then the source code is generated piece-by-piece - adding things like argument checks and extractions, defining the method header, and the actual call to the underlying library such as `TH`. Finally, the cwrap tool allows for processing the entire file at a time. The resulting output for `addmv_` can be [explored here](https:\/\/gist.github.com\/killeent\/c00de46c2a896335a52552604cc4d74b).","__index_level_0__":4068}
+{"text":"In order to interface with the CPython backend, the tool generates an array of `PyMethodDef`s that can be stored or appended to the `THPTensor`'s `tp_methods` field.","__index_level_0__":4069}
+{"text":"In the specific case of wrapping Tensor methods, the build process first generates the output source file from `TensorMethods.cwrap`. This source file is `#include`'d in the generic Tensor source file. This all occurs before the preprocessor does its magic. As a result, all of the method wrappers that are generated undergo the same pass as the `THPTensor` code above. Thus a single generic declaration and definition is specialized for each type as well.","__index_level_0__":4070}
+{"text":"### Putting It All Together","__index_level_0__":4071}
+{"text":"So far, we have shown how we extend the Python interpreter to create a new extension module, how such a module defines our new `THPTensor` type, and how we can generate source code for Tensors of all types that interface with `TH`. Briefly, we will touch on compilation.","__index_level_0__":4072}
+{"text":"Setuptools allows us to define an Extension for compilation. The entire `torch._C` extension is compiled by collecting all of the source files, header files, libraries, etc. and creating a setuptools `Extension`. Then setuptools handles building the extension itself. I will explore the build process more in a subsequent post.","__index_level_0__":4073}
+{"text":"To summarize, let's revisit our four questions:","__index_level_0__":4074}
+{"text":"- **How does PyTorch extend the Python interpreter to define a Tensor type that can be manipulated from Python code?**","__index_level_0__":4075}
+{"text":"It uses CPython's framework for extending the Python interpreter and defining new types, while taking special care to generate code for all types.","__index_level_0__":4076}
+{"text":"- **How does PyTorch wrap the C libraries that actually define the Tensor's properties and methods?**","__index_level_0__":4077}
+{"text":"It does so by defining a new type, `THPTensor`, that is backed by a `TH` Tensor. Function calls are forwarded to this tensor via the CPython backend's conventions.","__index_level_0__":4078}
+{"text":"- **How does PyTorch cwrap work to generate code for Tensor methods?**","__index_level_0__":4079}
+{"text":"It takes our custom YAML-formatted code and generates source code for each method by processing it through a series of steps using a number of plugins.","__index_level_0__":4080}
+{"text":"- **How does PyTorch's build system take all of these components to compile and generate a workable application?**","__index_level_0__":4081}
+{"text":"It takes a bunch of source\/header files, libraries, and compilation directives to build an extension using Setuptools.","__index_level_0__":4082}
+{"text":"This is just a snapshot of parts of the build system for PyTorch. There is more nuance, and detail, but I hope this serves as a gentle introduction to a lot of the components of our Tensor library.","__index_level_0__":4083}
+{"text":"### Resources:","__index_level_0__":4084}
+{"text":" - <https:\/\/docs.python.org\/3.7\/extending\/index.html> is invaluable for understanding how to write C\/C++ Extension to Python\n \n source: https:\/\/pytorch.org\/blog\/a-tour-of-pytorch-internals-1\/ \n category: pytorch blogs","__index_level_0__":4085}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch 1.12: TorchArrow, Functional API for Modules and nvFuser, are now available\"\nauthor: Team PyTorch\nfeatured-img: ''\n---","__index_level_0__":4086}
+{"text":"We are excited to announce the release of PyTorch 1.12 ([release note](https:\/\/github.com\/pytorch\/pytorch\/releases\/tag\/v1.12.0))! This release is composed of over 3124 commits, 433 contributors. Along with 1.12, we are releasing beta versions of AWS S3 Integration, PyTorch Vision Models on Channels Last on CPU, Empowering PyTorch on Intel\u00ae Xeon\u00ae Scalable processors with Bfloat16 and FSDP API. We want to sincerely thank our dedicated community for your contributions.","__index_level_0__":4087}
+{"text":"Summary:\n- Functional APIs to functionally apply module computation with a given set of parameters\n- Complex32 and Complex Convolutions in PyTorch\n- DataPipes from TorchData fully backward compatible with DataLoader \n- functorch with improved coverage for APIs\n- nvFuser a deep learning compiler for PyTorch\n- Changes to float32 matrix multiplication precision on Ampere and later CUDA hardware\n- TorchArrow, a new beta library for machine learning preprocessing over batch data","__index_level_0__":4088}
+{"text":"## Frontend APIs","__index_level_0__":4089}
+{"text":"### Introducing TorchArrow","__index_level_0__":4090}
+{"text":"We\u2019ve got a new Beta release ready for you to try and use: TorchArrow. This is a library for machine learning preprocessing over batch data. It features a performant and Pandas-style, easy-to-use API in order to speed up your preprocessing workflows and development.","__index_level_0__":4091}
+{"text":"Currently, it provides a Python DataFrame interface with the following features:\n- High-performance CPU backend, vectorized and extensible User-Defined Functions (UDFs) with [Velox](https:\/\/github.com\/facebookincubator\/velox)\n- Seamless handoff with PyTorch or other model authoring, such as Tensor collation and easily plugging into PyTorch DataLoader and DataPipes\n- Zero copy for external readers via Arrow in-memory columnar format","__index_level_0__":4092}
+{"text":"For more details, please find our [10-min tutorial](https:\/\/github.com\/pytorch\/torcharrow\/blob\/main\/tutorial\/tutorial.ipynb), installation [instructions](https:\/\/github.com\/pytorch\/torcharrow#installation), API [documentation](https:\/\/pytorch.org\/torcharrow\/beta\/), and a [prototype](https:\/\/github.com\/pytorch\/torchrec\/tree\/main\/examples\/torcharrow) for data preprocessing in TorchRec.","__index_level_0__":4093}
+{"text":"### (Beta) Functional API for Modules","__index_level_0__":4094}
+{"text":"PyTorch 1.12 introduces a new beta feature to functionally apply Module computation with a given set of parameters. Sometimes, the traditional PyTorch Module usage pattern that maintains a static set of parameters internally is too restrictive. This is often the case when implementing algorithms for meta-learning, where multiple sets of parameters may need to be maintained across optimizer steps. ","__index_level_0__":4095}
+{"text":"The new ``torch.nn.utils.stateless.functional_call()`` API allows for:   \n- Module computation with full flexibility over the set of parameters used\n- No need to reimplement your module in a functional way\n- Any parameter or buffer present in the module can be swapped with an externally-defined value for use in the call. Naming for referencing parameters \/ buffers follows the fully-qualified form in the module\u2019s ``state_dict()``","__index_level_0__":4096}
+{"text":"Example:\n```python\nimport torch\nfrom torch import nn\nfrom torch.nn.utils.stateless import functional_call","__index_level_0__":4097}
+{"text":"class MyModule(nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.fc1 = nn.Linear(3, 3)\n        self.bn = nn.BatchNorm1d(3)\n        self.fc2 = nn.Linear(3, 3)","__index_level_0__":4098}
+{"text":"    def forward(self, x):\n        return self.fc2(self.bn(self.fc1(x)))","__index_level_0__":4099}
+{"text":"m = MyModule()","__index_level_0__":4100}
+{"text":"# Define parameter \/ buffer values to use during module computation.\nmy_weight = torch.randn(3, 3, requires_grad=True)\nmy_bias = torch.tensor([1., 2., 3.], requires_grad=True)\nparams_and_buffers = {\n    'fc1.weight': my_weight,\n    'fc1.bias': my_bias,\n    # Custom buffer values can be used too.\n    'bn.running_mean': torch.randn(3),\n}","__index_level_0__":4101}
+{"text":"# Apply module computation to the input with the specified parameters \/ buffers.\ninp = torch.randn(5, 3)\noutput = functional_call(m, params_and_buffers, inp)\n```","__index_level_0__":4102}
+{"text":"### (Beta) Complex32 and Complex Convolutions in PyTorch","__index_level_0__":4103}
+{"text":"PyTorch today natively supports complex numbers, complex autograd, complex modules, and numerous complex operations, including linear algebra and Fast Fourier Transform (FFT) operators. Many libraries, including torchaudio and ESPNet, already make use of complex numbers in PyTorch, and PyTorch 1.12 further extends complex functionality with complex convolutions and the experimental complex32 (\u201ccomplex half\u201d) data type that enables half precision FFT operations. Due to the bugs in CUDA 11.3 package, we recommend using CUDA 11.6 package from wheels if you are using complex numbers.","__index_level_0__":4104}
+{"text":"### (Beta) Forward-mode Automatic Differentiation","__index_level_0__":4105}
+{"text":"Forward-mode AD allows the computation of directional derivatives (or equivalently, Jacobian-vector products) eagerly in the forward pass. PyTorch 1.12 significantly improves the operator coverage for forward-mode AD. See our [tutorial](https:\/\/pytorch.org\/tutorials\/search.html?q=forward-mode+automatic+differentiation+%28beta%29&check_keywords=yes&area=default#) for more information.","__index_level_0__":4106}
+{"text":"### TorchData ","__index_level_0__":4107}
+{"text":"#### BC DataLoader + DataPipe","__index_level_0__":4108}
+{"text":"\\`DataPipe\\` from TorchData becomes fully backward compatible with the existing \\`DataLoader\\` regarding shuffle determinism and dynamic sharding in both multiprocessing and distributed environments. For more details, please check out the [tutorial](https:\/\/pytorch.org\/data\/0.4.0\/tutorial.html#working-with-dataloader).","__index_level_0__":4109}
+{"text":"#### (Beta) AWS S3 Integration","__index_level_0__":4110}
+{"text":"DataPipes based on [AWSSDK](https:\/\/github.com\/aws\/aws-sdk-cpp) have been integrated into TorchData. It provides the following features backed by native AWSSDK:\n- Retrieve list of urls from each S3 bucket based on prefix\n\t- Support timeout to prevent hanging indefinitely\n\t- Support to specify S3 bucket region\n\t\t\n- Load data from S3 urls\n\t- Support buffered and multi-part download\n\t- Support to specify S3 bucket region","__index_level_0__":4111}
+{"text":"AWS native DataPipes are still in the beta phase. And, we will keep tuning them to improve their performance.","__index_level_0__":4112}
+{"text":"#### (Prototype) DataLoader2","__index_level_0__":4113}
+{"text":"DataLoader2 became available in prototype mode. We are introducing new ways to interact between DataPipes, DataLoading API, and backends (aka ReadingServices). Feature is stable in terms of API, but functionally not complete yet. We welcome early adopters and feedback, as well as potential contributors.","__index_level_0__":4114}
+{"text":"For more details, please checkout the [link](https:\/\/github.com\/pytorch\/data\/tree\/main\/torchdata\/dataloader2).","__index_level_0__":4115}
+{"text":"### functorch","__index_level_0__":4116}
+{"text":"Inspired by [Google JAX](https:\/\/github.com\/google\/jax), functorch is a library that offers composable vmap (vectorization) and autodiff transforms. It enables advanced autodiff use cases that would otherwise be tricky to express in PyTorch. Examples of these include:\n- [running ensembles of models on a single machine](https:\/\/pytorch.org\/functorch\/stable\/notebooks\/ensembling.html)\n- [efficiently computing Jacobians and Hessians](https:\/\/pytorch.org\/functorch\/stable\/notebooks\/jacobians_hessians.html)\n- [computing per-sample-gradients (or other per-sample quantities)](https:\/\/pytorch.org\/functorch\/stable\/notebooks\/per_sample_grads.html)","__index_level_0__":4117}
+{"text":"We\u2019re excited to announce functorch 0.2.0 with a number of improvements and new experimental features.","__index_level_0__":4118}
+{"text":"#### Significantly improved coverage","__index_level_0__":4119}
+{"text":"We significantly improved coverage for ``functorch.jvp`` (our forward-mode autodiff API) and other APIs that rely on it (``functorch.{jacfwd, hessian}``).","__index_level_0__":4120}
+{"text":"#### (Prototype) functorch.experimental.functionalize ","__index_level_0__":4121}
+{"text":"Given a function f, ``functionalize(f)`` returns a new function without mutations (with caveats). This is useful for constructing traces of PyTorch functions without in-place operations. For example, you can use ``make_fx(functionalize(f))`` to construct a mutation-free trace of a pytorch function. To learn more, please see the [documentation](https:\/\/pytorch.org\/functorch\/stable\/generated\/functorch.experimental.functionalize.html#functorch.experimental.functionalize).","__index_level_0__":4122}
+{"text":"For more details, please see our [installation instructions](https:\/\/pytorch.org\/functorch\/stable\/install.html), [documentation](https:\/\/pytorch.org\/functorch\/), [tutorials](https:\/\/pytorch.org\/functorch), and [release notes](https:\/\/github.com\/pytorch\/functorch\/releases).","__index_level_0__":4123}
+{"text":"## Performance Improvements","__index_level_0__":4124}
+{"text":"### Introducing nvFuser, a deep learning compiler for PyTorch","__index_level_0__":4125}
+{"text":"In PyTorch 1.12, Torchscript is updating its default fuser  (for Volta and later CUDA accelerators) to nvFuser, which supports a wider range of operations and is faster than NNC, the previous fuser for CUDA devices. A soon to be published blog post will elaborate on nvFuser and show how it speeds up training on a variety of networks. ","__index_level_0__":4126}
+{"text":"See [the nvFuser documentation](https:\/\/github.com\/pytorch\/pytorch\/blob\/release\/1.12\/torch\/csrc\/jit\/codegen\/cuda\/README.md) for more details on usage and debugging.","__index_level_0__":4127}
+{"text":"### Changes to float32 matrix multiplication precision on Ampere and later CUDA hardware","__index_level_0__":4128}
+{"text":"PyTorch supports a variety of \u201cmixed precision\u201d techniques, like the torch.amp (Automated Mixed Precision) module and performing float32 matrix multiplications using the TensorFloat32 datatype on Ampere and later CUDA hardware for faster internal computations. In PyTorch 1.12 we\u2019re changing the default behavior of float32 matrix multiplications to always use full IEEE fp32 precision, which is more precise but slower than using the TensorFloat32 datatype for internal computation. For devices with a particularly high ratio of TensorFloat32 to float32 throughput such as A100, this change in defaults can result in a large slowdown.","__index_level_0__":4129}
+{"text":"If you\u2019ve been using TensorFloat32 matrix multiplications then you can continue to do so by setting ``torch.backends.cuda.matmul.allow_tf32 = True``","__index_level_0__":4130}
+{"text":"which is supported since PyTorch 1.7. Starting in PyTorch 1.12 the new matmul precision API can be used, too: ``torch.set_float32_matmul_precision(\u201chighest\u201d|\u201dhigh\u201d|\u201dmedium\u201d)``","__index_level_0__":4131}
+{"text":"To reiterate, PyTorch\u2019s new default is \u201chighest\u201d precision for all device types. We think this provides better consistency across device types for matrix multiplications. Documentation for the new precision API can be found [here](https:\/\/pytorch.org\/docs\/master\/generated\/torch.set_float32_matmul_precision.html?highlight=precision#torch.set_float32_matmul_precision). Setting the \u201chigh\u201d or \u201cmedium\u201d precision types will enable TensorFloat32 on Ampere and later CUDA devices. If you\u2019re updating to PyTorch 1.12 then to preserve the current behavior and faster performance of matrix multiplications on Ampere devices, set precision to \u201chigh\u201d.","__index_level_0__":4132}
+{"text":"Using mixed precision techniques is essential for training many modern deep learning networks efficiently, and if you\u2019re already using torch.amp this change is unlikely to affect you. If you\u2019re not familiar with mixed precision training then see our soon to be published \u201cWhat Every User Should Know About Mixed Precision Training in PyTorch\u201d blogpost.","__index_level_0__":4133}
+{"text":"### (Beta) Accelerating PyTorch Vision Models with Channels Last on CPU","__index_level_0__":4134}
+{"text":"Memory formats have a significant impact on performance when running vision models, generally Channels Last is more favorable from a performance perspective due to better data locality. 1.12 includes fundamental concepts of memory formats and demonstrates performance benefits using Channels Last on popular PyTorch vision models on Intel\u00ae Xeon\u00ae Scalable processors.\n- Enables Channels Last memory format support for the commonly used operators in CV domain on CPU, applicable for both inference and training\n- Provides native level optimization on Channels Last kernels from ATen, applicable for both AVX2 and AVX512\n- Delivers 1.3x to 1.8x inference performance gain over Channels First for TorchVision models on Intel\u00ae Xeon\u00ae Ice Lake (or newer) CPUs","__index_level_0__":4135}
+{"text":"### (Beta) Empowering PyTorch on Intel\u00ae Xeon\u00ae Scalable processors with Bfloat16","__index_level_0__":4136}
+{"text":"Reduced precision numeric formats like bfloat16 improves PyTorch performance across multiple deep learning training workloads. PyTorch 1.12 includes the latest software enhancements on bfloat16 which applies to a broader scope of user scenarios and showcases even higher performance gains. The main improvements include:\n- 2x hardware compute throughput vs. float32 with the new bfloat16 native instruction VDPBF16PS, introduced on Intel\u00ae Xeon\u00ae Cooper Lake CPUs\n- 1\/2 memory footprint of float32, faster speed for memory bandwidth intensive operators\n- 1.4x to 2.2x inference performance gain over float32 for TorchVision models on Intel\u00ae Xeon\u00ae Cooper Lake (or newer) CPUs","__index_level_0__":4137}
+{"text":"### (Prototype) Introducing Accelerated PyTorch Training on Mac","__index_level_0__":4138}
+{"text":"With the PyTorch 1.12 release, developers and researchers can now take advantage of Apple silicon GPUs for significantly faster model training. This unlocks the ability to perform machine learning workflows like prototyping and fine-tuning locally, right on Mac. Accelerated GPU training is enabled using Apple\u2019s Metal Performance Shaders (MPS) as a backend. The benefits include performance speedup from accelerated GPU training and the ability to train larger networks or batch sizes locally. Learn more [here](https:\/\/pytorch.org\/blog\/introducing-accelerated-pytorch-training-on-mac\/). ","__index_level_0__":4139}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/apple_m1_eval.png\" width=\"80%\">\n<\/p>","__index_level_0__":4140}
+{"text":"<p align=\"center\">\n Accelerated GPU training and evaluation speedups over CPU-only (times faster)\n<\/p>","__index_level_0__":4141}
+{"text":"Alongside the new MPS device support, the M1 binaries for Core and Domain libraries that have been available for the last few releases are now an official prototype feature. These binaries can be used to run PyTorch natively on Apple Silicon.","__index_level_0__":4142}
+{"text":"### (Prototype) BetterTransformer: Fastpath execution for Transformer Encoder Inference","__index_level_0__":4143}
+{"text":"PyTorch now supports CPU and GPU fastpath implementations (\u201cBetterTransformer\u201d) for several Transformer Encoder modules including TransformerEncoder, TransformerEncoderLayer, and MultiHeadAttention (MHA). The BetterTransformer fastpath architecture Better Transformer is consistently faster \u2013  2x for many common execution scenarios, depending on model and input characteristics. The new BetterTransformer-enabled modules are API compatible with previous releases of the PyTorch Transformer API and will accelerate existing models if they meet fastpath execution requirements, as well as read models trained with previous versions of PyTorch. PyTorch 1.12 includes: \n- BetterTransformer integration for Torchtext\u2019s pretrained RoBERTa and XLM-R models\n- Torchtext which builds on the PyTorch Transformer API\n- Fastpath execution for improved performance by reducing execution overheads with fused kernels which combines multiple operators into a single kernel\n- Option to achieve additional speedups by taking advantage of data sparsity during the processing of padding tokens in natural-language processing (by setting enable_nested_tensor=True when creating a TransformerEncoder)\n- Diagnostics to help users understand why fastpath execution did not occur\n ","__index_level_0__":4144}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/transformer_fastpath.png\" width=\"80%\">\n<\/p>","__index_level_0__":4145}
+{"text":"## Distributed","__index_level_0__":4146}
+{"text":"### (Beta) Fully Sharded Data Parallel (FSDP) API","__index_level_0__":4147}
+{"text":"[FSDP API](https:\/\/pytorch.org\/blog\/introducing-pytorch-fully-sharded-data-parallel-api\/) helps easily scale large model training by sharding a model\u2019s parameters, gradients and optimizer states across data parallel workers while maintaining the simplicity of data parallelism. The prototype version was released in PyTorch 1.11 with a minimum set of features that helped [scaling tests of models with up to 1T parameters](https:\/\/medium.com\/pytorch\/training-a-1-trillion-parameter-model-with-pytorch-fully-sharded-data-parallel-on-aws-3ac13aa96cff). ","__index_level_0__":4148}
+{"text":"In this beta release, FSDP API added the following features to support various production workloads. Highlights of the the newly added features in this beta release include: \n1. Universal sharding strategy API - Users can easily change between sharding strategies with a single line change, and thus compare and use DDP (only data sharding), FSDP (full model and data sharding), or Zero2 (only sharding of optimizer and gradients) to optimize memory and performance for their specific training needs\n2. Fine grained mixed precision policies - Users can specify a mix of half and full data types (bfloat16, fp16 or fp32) for model parameters, gradient communication, and buffers via mixed precision policies.  Models are automatically saved in fp32 to allow for maximum portability\n3. Transformer auto wrapping policy - allows for optimal wrapping of Transformer based models by registering the models layer class, and thus accelerated training performance\n4. Faster model initialization using device_id init - initialization is performed in a streaming fashion to avoid OOM issues and optimize init performance vs CPU init \n5. Rank0 streaming for full model saving of larger models - Fully sharded models can be saved by all GPU\u2019s streaming their shards to the rank 0 GPU, and the model is built in full state on the rank 0 CPU for saving","__index_level_0__":4149}
+{"text":"For more details and example code, please checkout the [documentation](https:\/\/pytorch.org\/docs\/1.11\/fsdp.html?highlight=fsdp#module-torch.distributed.fsdp) and the [tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/FSDP_tutorial.html). ","__index_level_0__":4150}
+{"text":"\nThanks for reading, If you\u2019re interested in these updates and want to join the PyTorch community, we encourage you to join the [discussion forums](https:\/\/discuss.pytorch.org\/) and [open GitHub issues](https:\/\/github.com\/pytorch\/pytorch\/issues). To get the latest news from PyTorch, follow us on [Twitter](https:\/\/twitter.com\/PyTorch), [Medium](https:\/\/medium.com\/pytorch), [YouTube](https:\/\/www.youtube.com\/pytorch), and [LinkedIn](https:\/\/www.linkedin.com\/company\/pytorch).","__index_level_0__":4151}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.12-released\/ \n category: pytorch blogs","__index_level_0__":4153}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 1.4 released, domain libraries updated'\nauthor: Team PyTorch\n---","__index_level_0__":4154}
+{"text":"Today, we\u2019re announcing the availability of PyTorch 1.4, along with updates to the PyTorch domain libraries. These releases build on top of the announcements from [NeurIPS 2019](https:\/\/pytorch.org\/blog\/pytorch-adds-new-tools-and-libraries-welcomes-preferred-networks-to-its-community\/), where we shared the availability of PyTorch Elastic, a new classification framework for image and video, and the addition of Preferred Networks to the PyTorch community. For those that attended the workshops at NeurIPS, the content can be found [here](https:\/\/research.fb.com\/neurips-2019-expo-workshops\/).","__index_level_0__":4155}
+{"text":"## PyTorch 1.4","__index_level_0__":4156}
+{"text":"The 1.4 release of PyTorch adds new capabilities, including the ability to do fine grain build level customization for PyTorch Mobile, and new experimental features including support for model parallel training and Java language bindings.","__index_level_0__":4157}
+{"text":"### PyTorch Mobile - Build level customization","__index_level_0__":4158}
+{"text":"Following the open sourcing of [PyTorch Mobile in the 1.3 release](https:\/\/pytorch.org\/blog\/pytorch-1-dot-3-adds-mobile-privacy-quantization-and-named-tensors\/), PyTorch 1.4 adds additional mobile support including the ability to customize build scripts at a fine-grain level. This allows mobile developers to optimize library size by only including the operators used by their models and, in the process, reduce their on device footprint significantly. Initial results show that, for example, a customized MobileNetV2 is 40% to 50% smaller than the prebuilt PyTorch mobile library. You can learn more [here](https:\/\/pytorch.org\/mobile\/home\/) about how to create your own custom builds and, as always, please engage with the community on the [PyTorch forums](https:\/\/discuss.pytorch.org\/c\/mobile) to provide any feedback you have.","__index_level_0__":4159}
+{"text":"Example code snippet for selectively compiling only the operators needed for MobileNetV2:","__index_level_0__":4160}
+{"text":"```python\n# Dump list of operators used by MobileNetV2:\nimport torch, yaml\nmodel = torch.jit.load('MobileNetV2.pt')\nops = torch.jit.export_opnames(model)\nwith open('MobileNetV2.yaml', 'w') as output:\n    yaml.dump(ops, output)\n```","__index_level_0__":4161}
+{"text":"```console\n# Build PyTorch Android library customized for MobileNetV2:\nSELECTED_OP_LIST=MobileNetV2.yaml scripts\/build_pytorch_android.sh arm64-v8a","__index_level_0__":4162}
+{"text":"# Build PyTorch iOS library customized for MobileNetV2:\nSELECTED_OP_LIST=MobileNetV2.yaml BUILD_PYTORCH_MOBILE=1 IOS_ARCH=arm64 scripts\/build_ios.sh\n```","__index_level_0__":4163}
+{"text":"### Distributed model parallel training (Experimental)","__index_level_0__":4164}
+{"text":"With the scale of models, such as RoBERTa, continuing to increase into the billions of parameters, model parallel training has become ever more important to help researchers push the limits. This release provides a distributed RPC framework to support distributed model parallel training. It allows for running functions remotely and referencing remote objects without copying the real data around, and provides autograd and optimizer APIs to transparently run backwards and update parameters across RPC boundaries.","__index_level_0__":4165}
+{"text":"To learn more about the APIs and the design of this feature, see the links below:","__index_level_0__":4166}
+{"text":"* [API documentation](https:\/\/pytorch.org\/docs\/stable\/rpc.html)\n* [Distributed Autograd design doc](https:\/\/pytorch.org\/docs\/stable\/notes\/distributed_autograd.html)\n* [Remote Reference design doc](https:\/\/pytorch.org\/docs\/stable\/notes\/rref.html)","__index_level_0__":4167}
+{"text":"For the full tutorials, see the links below:  ","__index_level_0__":4168}
+{"text":"* [A full RPC tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/rpc_tutorial.html)\n* [Examples using model parallel training for reinforcement learning and with an LSTM](https:\/\/github.com\/pytorch\/examples\/tree\/master\/distributed\/rpc)","__index_level_0__":4169}
+{"text":"As always, you can connect with community members and discuss more on the [forums](https:\/\/discuss.pytorch.org\/c\/distributed\/distributed-rpc).","__index_level_0__":4170}
+{"text":"### Java bindings (Experimental)","__index_level_0__":4171}
+{"text":"In addition to supporting Python and C++, this release adds experimental support for Java bindings. Based on the interface developed for Android in PyTorch Mobile, the new bindings allow you to invoke TorchScript models from any Java program. Note that the Java bindings are only available for Linux for this release, and for inference only. We expect support to expand in subsequent releases. See the code snippet below for how to use PyTorch within Java:","__index_level_0__":4172}
+{"text":"```java\nModule mod = Module.load(\"demo-model.pt1\");\nTensor data =\n    Tensor.fromBlob(\n        new int[] {1, 2, 3, 4, 5, 6}, \/\/ data\n        new long[] {2, 3} \/\/ shape\n        );\nIValue result = mod.forward(IValue.from(data), IValue.from(3.0));\nTensor output = result.toTensor();\nSystem.out.println(\"shape: \" + Arrays.toString(output.shape()));\nSystem.out.println(\"data: \" + Arrays.toString(output.getDataAsFloatArray()));\n```","__index_level_0__":4173}
+{"text":"Learn more about how to use PyTorch from Java [here](https:\/\/github.com\/pytorch\/java-demo), and see the full Javadocs API documentation [here](https:\/\/pytorch.org\/javadoc\/1.4.0\/).","__index_level_0__":4174}
+{"text":"For the full 1.4 release notes, see [here](https:\/\/github.com\/pytorch\/pytorch\/releases).","__index_level_0__":4175}
+{"text":"## Domain Libraries","__index_level_0__":4176}
+{"text":"PyTorch domain libraries like torchvision, torchtext, and torchaudio complement PyTorch with common datasets, models, and transforms. We\u2019re excited to share new releases for all three domain libraries alongside the PyTorch 1.4 core release.","__index_level_0__":4177}
+{"text":"### torchvision 0.5","__index_level_0__":4178}
+{"text":"The improvements to torchvision 0.5 mainly focus on adding support for production deployment including quantization, TorchScript, and ONNX. Some of the highlights include:","__index_level_0__":4179}
+{"text":"* All models in torchvision are now torchscriptable making them easier to ship into non-Python production environments\n* ResNets, MobileNet, ShuffleNet, GoogleNet and InceptionV3 now have quantized counterparts with pre-trained models, and also include scripts for quantization-aware training.\n* In partnership with the Microsoft team, we\u2019ve added ONNX support for all models including Mask R-CNN.","__index_level_0__":4180}
+{"text":"Learn more about torchvision 0.5 [here](https:\/\/github.com\/pytorch\/vision\/releases).","__index_level_0__":4181}
+{"text":"### torchaudio 0.4","__index_level_0__":4182}
+{"text":"Improvements in torchaudio 0.4 focus on enhancing the currently available transformations, datasets, and backend support. Highlights include:","__index_level_0__":4183}
+{"text":"* SoX is now optional, and a new extensible backend dispatch mechanism exposes SoundFile as an alternative to SoX.\n* The interface for datasets has been unified. This enables the addition of two large datasets: LibriSpeech and Common Voice.\n* New filters such as biquad, data augmentation such as time and frequency masking, transforms such as MFCC, gain and dither, and new feature computation such as deltas, are now available.\n* Transformations now support batches and are jitable.\n* An interactive speech recognition demo with voice activity detection is available for experimentation.","__index_level_0__":4184}
+{"text":"Learn more about torchaudio 0.4 [here](https:\/\/github.com\/pytorch\/audio\/releases).","__index_level_0__":4185}
+{"text":"### torchtext 0.5","__index_level_0__":4186}
+{"text":"torchtext 0.5 focuses mainly on improvements to the dataset loader APIs, including compatibility with core PyTorch APIs, but also adds support for unsupervised text tokenization. Highlights include:","__index_level_0__":4187}
+{"text":"* Added bindings for SentencePiece for unsupervised text tokenization .\n* Added a new unsupervised learning dataset - enwik9.\n* Made revisions to PennTreebank, WikiText103, WikiText2, IMDb to make them compatible with torch.utils.data. Those datasets are in an experimental folder and we welcome your feedback.","__index_level_0__":4188}
+{"text":"Learn more about torchtext 0.5 [here](https:\/\/github.com\/pytorch\/text\/releases).","__index_level_0__":4189}
+{"text":"*We\u2019d like to thank the entire PyTorch team and the community for all their contributions to this work.*","__index_level_0__":4190}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1-dot-4-released-and-domain-libraries-updated\/ \n category: pytorch blogs","__index_level_0__":4192}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Stochastic Weight Averaging in PyTorch'\nauthor: Pavel Izmailov and Andrew Gordon Wilson\nredirect_from: \/2019\/04\/29\/road-to-1.0.html\n---","__index_level_0__":4193}
+{"text":"In this blogpost we describe the recently proposed Stochastic Weight Averaging (SWA) technique [1, 2], and its new implementation in [`torchcontrib`](https:\/\/github.com\/pytorch\/contrib).  SWA is a simple procedure that improves generalization in deep learning over Stochastic Gradient Descent (SGD) at no additional cost, and can be used as a drop-in replacement for any other optimizer in PyTorch. SWA has a wide range of applications and features:","__index_level_0__":4194}
+{"text":"1. SWA has been shown to significantly improve generalization in computer vision tasks, including VGG, ResNets, Wide ResNets and DenseNets on ImageNet and CIFAR benchmarks [1, 2].\n2. SWA provides state-of-the-art performance on key benchmarks in semi-supervised learning and domain adaptation [2].\n3. SWA is shown to improve the stability of training as well as the final average rewards of policy-gradient methods in deep reinforcement learning [3].\n4. An extension of SWA can obtain efficient Bayesian model averaging, as well as high quality uncertainty estimates and calibration in deep learning [4].\n5. SWA for low precision training, SWALP, can match the performance of full-precision SGD even with all numbers quantized down to 8 bits, including gradient accumulators [5].","__index_level_0__":4195}
+{"text":"In short, SWA performs an equal average of the weights traversed by SGD with a modified learning rate schedule (see the left panel of Figure 1.). SWA solutions end up in the center of a wide flat region of loss, while SGD tends to converge to the boundary of the low-loss region, making it susceptible to the shift between train and test error surfaces (see the middle and right panels of Figure 1).","__index_level_0__":4196}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swa\/Figure1.png\" width=\"100%\">\n<\/div>","__index_level_0__":4197}
+{"text":"**Figure 1.** Illustrations of SWA and SGD with a Preactivation ResNet-164 on CIFAR-100 [1]. **Left:** test error surface for three FGE samples and the corresponding SWA solution (averaging in weight space). **Middle** and **Right:** test error and train loss surfaces showing the weights proposed by SGD (at convergence) and SWA, starting from the same initialization of SGD after 125 training epochs. Please see [1] for details on how these figures were constructed.","__index_level_0__":4198}
+{"text":"**With our new implementation in [torchcontrib](https:\/\/github.com\/pytorch\/contrib) using SWA is as easy as using any other optimizer in PyTorch:**","__index_level_0__":4199}
+{"text":"```python\nfrom torchcontrib.optim import SWA","__index_level_0__":4200}
+{"text":"# training loop\nbase_opt = torch.optim.SGD(model.parameters(), lr=0.1)\nopt = torchcontrib.optim.SWA(base_opt, swa_start=10, swa_freq=5, swa_lr=0.05)\nfor _ in range(100):\n     opt.zero_grad()\n     loss_fn(model(input), target).backward()\n     opt.step()\nopt.swap_swa_sgd()\n```","__index_level_0__":4202}
+{"text":"You can wrap any optimizer from `torch.optim` using the `SWA` class, and then train your model as usual. When training is complete you simply call `swap_swa_sgd()` to set the weights of your model to their SWA averages. Below we explain the SWA procedure and the parameters of the `SWA` class in detail. We emphasize that SWA can be combined with *any* optimization procedure, such as Adam, in the same way that it can be combined with SGD.","__index_level_0__":4203}
+{"text":"## Is this just Averaged SGD?","__index_level_0__":4204}
+{"text":"At a high level, averaging SGD iterates dates back several decades in convex optimization [6, 7], where it is sometimes referred to as Polyak-Ruppert averaging, or *averaged* SGD. **But the details matter**. *Averaged SGD* is often employed in conjunction with a decaying learning rate, and an exponentially moving average, typically for convex optimization. In convex optimization, the focus has been on improved rates of convergence. In deep learning, this form of averaged SGD smooths the trajectory of SGD iterates, but does not perform very differently.","__index_level_0__":4205}
+{"text":"By contrast, SWA is focused on an **equal average** of SGD iterates with a modified **cyclical or high constant learning rate**, and exploits the flatness of training objectives [8] specific to **deep learning** for **improved generalization**.","__index_level_0__":4206}
+{"text":"## Stochastic Weight Averaging","__index_level_0__":4207}
+{"text":"There are two important ingredients that make SWA work. First, SWA uses a modified learning rate schedule so that SGD continues to explore the set of high-performing networks instead of simply converging to a single solution. For example, we can use the standard decaying learning rate strategy for the first 75% of training time, and then set the learning rate to a reasonably high constant value for the remaining 25% of the time (see the Figure 2 below). The second ingredient is to average the weights of the networks traversed by SGD. For example, we can maintain a running average of the weights obtained in the end of every epoch within the last 25% of training time (see Figure 2).\n<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swa\/figure2-highres.png\" width=\"70%\">\n<\/div>","__index_level_0__":4208}
+{"text":"**Figure 2.** Illustration of the learning rate schedule adopted by SWA. Standard decaying schedule is used for the first 75% of the training and then a high constant value is used for the remaining 25%. The SWA averages are formed during the last 25% of training.","__index_level_0__":4209}
+{"text":"In our implementation the auto mode of the `SWA` optimizer allows us to run the procedure described above. To run SWA in auto mode you just need to wrap your optimizer `base_opt` of choice (can be SGD, Adam, or any other `torch.optim.Optimizer`) with `SWA(base_opt, swa_start, swa_freq, swa_lr)`. After `swa_start` optimization steps the learning rate will be switched to a constant value `swa_lr`, and in the end of every `swa_freq` optimization steps a snapshot of the weights will be added to the SWA running average. Once you run `opt.swap_swa_sgd()`, the weights of your model are replaced with their SWA running averages.","__index_level_0__":4210}
+{"text":"## Batch Normalization","__index_level_0__":4211}
+{"text":"One important detail to keep in mind is batch normalization. Batch normalization layers compute running statistics of activations during training. Note that the SWA averages of the weights are never used to make predictions during training, and so the batch normalization layers do not have the activation statistics computed after you reset the weights of your model with `opt.swap_swa_sgd()`. To compute the activation statistics you can just make a forward pass on your training data using the SWA model once the training is finished. In the `SWA` class we provide a helper function `opt.bn_update(train_loader, model)`. It updates the activation statistics for every batch normalization layer in the model by making a forward pass on the `train_loader` data loader. You only need to call this function once in the end of training.","__index_level_0__":4212}
+{"text":"## Advanced Learning-Rate Schedules","__index_level_0__":4213}
+{"text":"SWA can be used with any learning rate schedule that encourages exploration of the flat region of solutions. For example, you can use cyclical learning rates in the last 25% of the training time instead of a constant value, and average the weights of the networks corresponding to the lowest values of the learning rate within each cycle (see Figure 3).","__index_level_0__":4214}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swa\/figure3-highres.png\" width=\"70%\">\n<\/div>","__index_level_0__":4215}
+{"text":"**Figure 3.** Illustration of SWA with an alternative learning rate schedule. Cyclical learning rates are adopted in the last 25% of training, and models for averaging are collected in the end of each cycle.","__index_level_0__":4216}
+{"text":"In our implementation you can implement custom learning rate and weight averaging strategies by using `SWA` in the manual mode. The following code is equivalent to the auto mode code presented in the beginning of this blogpost.","__index_level_0__":4217}
+{"text":"```python\nopt = torchcontrib.optim.SWA(base_opt)\nfor i in range(100):\n    opt.zero_grad()\n    loss_fn(model(input), target).backward()\n    opt.step()\n    if i > 10 and i % 5 == 0:\n        opt.update_swa()\nopt.swap_swa_sgd()\n```","__index_level_0__":4218}
+{"text":"In manual mode you don\u2019t specify `swa_start`, `swa_lr` and `swa_freq`, and just call `opt.update_swa()` whenever you want to update the SWA running averages (for example in the end of each learning rate cycle). In manual mode `SWA` doesn\u2019t change the learning rate, so you can use any schedule you want as you would normally do with any other `torch.optim.Optimizer`.","__index_level_0__":4219}
+{"text":"## Why does it work?","__index_level_0__":4220}
+{"text":"SGD converges to a solution within a wide flat region of loss. The weight space is extremely high-dimensional, and most of the volume of the flat region is concentrated near the boundary, so SGD solutions will always be found near the boundary of the flat region of the loss. SWA on the other hand averages multiple SGD solutions, which allows it to move towards the center of the flat region.","__index_level_0__":4221}
+{"text":"We expect solutions that are centered in the flat region of the loss to generalize better than those near the boundary. Indeed, train and test error surfaces are not perfectly aligned in the weight space. Solutions that are centered in the flat region are not as susceptible to the shifts between train and test error surfaces as those near the boundary. In Figure 4 below we show the train loss and test error surfaces along the direction connecting the SWA and SGD solutions. As you can see, while SWA solution has a higher train loss compared to the SGD solution, it is centered in the region of low loss, and has a substantially better test error.","__index_level_0__":4222}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/swa\/Figure4.png\" width=\"90%\">\n<\/div>","__index_level_0__":4223}
+{"text":"**Figure 4.** Train loss and test error along the line connecting the SWA solution (circle) and SGD solution (square). SWA solution is centered in a wide region of low train loss while the SGD solution lies near the boundary. Because of the shift between train loss and test error surfaces, SWA solution leads to much better generalization.","__index_level_0__":4224}
+{"text":"## Examples and Results","__index_level_0__":4225}
+{"text":"We released a GitHub repo [here](https:\/\/github.com\/izmailovpavel\/contrib_swa_examples) with examples of using the `torchcontrib` implementation of SWA for training DNNs. For example, these examples can be used to achieve the following results on CIFAR-100:","__index_level_0__":4226}
+{"text":"| DNN (Budget)              |  SGD         | SWA 1 Budget | SWA 1.25 Budgets | SWA 1.5 Budgets |\n| ------------------------- |:------------:|:------------:|:----------------:|:---------------:|\n| VGG16 (200)               | 72.55 \u00b1 0.10 | 73.91 \u00b1 0.12 | 74.17 \u00b1 0.15     | 74.27 \u00b1 0.25    |\n| PreResNet110 (150)        | 76.77 \u00b1 0.38 | 78.75 \u00b1 0.16 | 78.91 \u00b1 0.29     | 79.10 \u00b1 0.21    |\n| PreResNet164 (150)        | 78.49 \u00b1 0.36 | 79.77 \u00b1 0.17 | 80.18 \u00b1 0.23     | 80.35 \u00b1 0.16    |\n| WideResNet28x10 (200)     | 80.82 \u00b1 0.23 | 81.46 \u00b1 0.23 | 81.91 \u00b1 0.27     | 82.15 \u00b1 0.27    |","__index_level_0__":4227}
+{"text":"## Semi-Supervised Learning","__index_level_0__":4228}
+{"text":"In a follow-up [paper](https:\/\/arxiv.org\/abs\/1806.05594) SWA was applied to semi-supervised learning, where it illustrated  improvements beyond the best reported results in multiple settings. For example, with SWA you can get 95% accuracy on CIFAR-10 if you only have the training labels for 4k training data points (the previous best reported result on this problem was 93.7%). This paper also explores averaging multiple times within epochs, which can accelerate convergence and find still flatter solutions in a given time.\n<div class=\"text-center\">\n<img src=\"{{ site.url }}\/assets\/images\/swa\/Figure5.png\" width=\"90%\">\n<\/div>","__index_level_0__":4229}
+{"text":"**Figure 5.** Performance of fast-SWA on semi-supervised learning with CIFAR-10. fast-SWA achieves record results in every setting considered.","__index_level_0__":4230}
+{"text":"## Calibration and Uncertainty Estimates\n[SWA-Gaussian](https:\/\/arxiv.org\/abs\/1902.02476) (SWAG) is a simple, scalable and convenient approach to uncertainty estimation and calibration in Bayesian deep learning. Similarly to SWA, which maintains a running average of SGD iterates, SWAG estimates the first and second moments of the iterates to construct a Gaussian distribution over weights. SWAG distribution approximates the shape of the true posterior: Figure 6 below shows the SWAG distribution on top of the posterior log-density for PreResNet-164 on CIFAR-100.\n<div class=\"text-center\">\n<img src=\"{{ site.url }}\/assets\/images\/swa\/Figure6.png\" width=\"90%\">\n<\/div>\n**Figure 6.** SWAG distribution on top of posterior log-density for PreResNet-164 on CIFAR-100. The shape of SWAG distribution is aligned with the posterior.","__index_level_0__":4231}
+{"text":"Empirically, SWAG performs on par or better than popular alternatives including MC dropout, KFAC Laplace, and temperature scaling on uncertainty quantification, out-of-distribution detection, calibration and transfer learning in computer vision tasks. Code for SWAG is available [here](https:\/\/github.com\/wjmaddox\/swa_gaussian).","__index_level_0__":4232}
+{"text":"## Reinforcement Learning","__index_level_0__":4233}
+{"text":"In another follow-up [paper](http:\/\/www.gatsby.ucl.ac.uk\/~balaji\/udl-camera-ready\/UDL-24.pdf) SWA was shown to improve the performance of policy gradient methods A2C and DDPG on several Atari games and MuJoCo environments.","__index_level_0__":4234}
+{"text":"| Environment   | A2C            | A2C + SWA      |\n|---------------|:----------------:|:----------------:|\n| Breakout      | 522 \u00b1 34       | 703 \u00b1 60       |\n| Qbert         | 18777 \u00b1 778    | 21272 \u00b1 655    |\n| SpaceInvaders | 7727 \u00b1 1121    | 21676 \u00b1 8897   |\n| Seaquest      | 1779 \u00b1 4       | 1795 \u00b1 4       |\n| CrazyClimber  | 147030 \u00b1 10239 | 139752 \u00b1 11618 |\n| BeamRider     | 9999 \u00b1 402     | 11321 \u00b1 1065   |","__index_level_0__":4235}
+{"text":"## Low Precision Training\nWe can filter through quantization noise by combining weights that have been rounded down with weights that have been rounded up. Moreover, by averaging weights to find a flat region of the loss surface, large perturbations of the weights will not affect the quality of the solution (Figures 7 and 8). Recent work shows that by adapting SWA to the low precision setting, in a method called SWALP, one can *match the performance of full-precision SGD even with all training in 8 bits* [5]. This is quite a practically important result, given that (1) SGD training in 8 bits performs notably worse than full precision SGD, and (2) low precision training is significantly harder than predictions in low precision after training (the usual setting). For example, a ResNet-164 trained on CIFAR-100 with float (16-bit) SGD achieves 22.2% error, while 8-bit SGD achieves 24.0% error. By contrast, SWALP with 8 bit training achieves 21.8% error.\n<div class=\"text-center\">\n<img src=\"{{ site.url }}\/assets\/images\/swa\/Figure7.png\" width=\"90%\">\n<\/div>","__index_level_0__":4236}
+{"text":"**Figure 7.** Quantizing in a flat region can still provide solutions with low loss.","__index_level_0__":4237}
+{"text":"<div class=\"text-center\">\n<img src=\"{{ site.url }}\/assets\/images\/swa\/Figure8.png\" width=\"90%\">\n<\/div>","__index_level_0__":4238}
+{"text":"**Figure 8.** Low precision SGD training (with a modified learning rate schedule) and SWALP.","__index_level_0__":4239}
+{"text":"## Conclusion","__index_level_0__":4240}
+{"text":"One of the greatest open questions in deep learning is why SGD manages to find good solutions, given that the training objectives are highly multimodal, and there are in principle many settings of parameters that achieve no training loss but poor generalization. By understanding geometric features such as flatness, which relate to generalization, we can begin to resolve these questions and build optimizers that provide even better generalization, and many other useful features, such as uncertainty representation. We have presented SWA, a simple drop-in replacement for standard SGD, which can in principle benefit anyone training a deep neural network. SWA has been demonstrated to have strong performance in a number of areas, including computer vision, semi-supervised learning, reinforcement learning, uncertainty representation, calibration, Bayesian model averaging, and low precision training.","__index_level_0__":4241}
+{"text":"We encourage you try out SWA! Using SWA is now as easy as using any other optimizer in PyTorch. And even if you have already trained your model with SGD (or any other optimizer), it\u2019s very easy to realize the benefits of SWA by running SWA for a small number of epochs starting with a pre-trained model.","__index_level_0__":4242}
+{"text":"- [1] Averaging Weights Leads to Wider Optima and Better Generalization; Pavel Izmailov, Dmitry Podoprikhin, Timur Garipov, Dmitry Vetrov, Andrew Gordon Wilson; Uncertainty in Artificial Intelligence (UAI), 2018\n- [2] There Are Many Consistent Explanations of Unlabeled Data: Why You Should Average; Ben Athiwaratkun, Marc Finzi, Pavel Izmailov, Andrew Gordon Wilson; International Conference on Learning Representations (ICLR), 2019\n- [3] Improving Stability in Deep Reinforcement Learning with Weight Averaging; Evgenii Nikishin, Pavel Izmailov, Ben Athiwaratkun, Dmitrii Podoprikhin, Timur Garipov, Pavel Shvechikov, Dmitry Vetrov, Andrew Gordon Wilson, UAI 2018 Workshop: Uncertainty in Deep Learning, 2018\n- [4]  A Simple Baseline for Bayesian Uncertainty in Deep Learning, Wesley Maddox, Timur Garipov, Pavel Izmailov, Andrew Gordon Wilson, arXiv pre-print, 2019: [https:\/\/arxiv.org\/abs\/1902.02476](https:\/\/arxiv.org\/abs\/1902.02476)\n- [5] SWALP : Stochastic Weight Averaging in Low Precision Training, Guandao Yang, Tianyi Zhang, Polina Kirichenko, Junwen Bai, Andrew Gordon Wilson, Christopher De Sa, To appear at the International Conference on Machine Learning  (ICML), 2019.\n- [6] David Ruppert. Efficient estimations from a slowly convergent Robbins-Monro process. Technical report, Cornell University Operations Research and Industrial Engineering, 1988.\n- [7] Acceleration of stochastic approximation by averaging. Boris T Polyak and Anatoli B Juditsky. SIAM Journal on Control and Optimization, 30(4):838\u2013855, 1992.\n- [8] Loss Surfaces, Mode Connectivity, and Fast Ensembling of DNNs, Timur Garipov, Pavel Izmailov, Dmitrii Podoprikhin, Dmitry Vetrov, Andrew Gordon Wilson. Neural Information Processing Systems (NeurIPS), 2018\n \n source: https:\/\/pytorch.org\/blog\/stochastic-weight-averaging-in-pytorch\/ \n category: pytorch blogs","__index_level_0__":4243}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Introducing the PlayTorch app: Rapidly Create Mobile AI Experiences\"\nauthor: PlayTorch Team\nfeatured-img: \"\"\n---","__index_level_0__":4244}
+{"text":"<p align=\"center\">\n  <video width=\"100%\" controls>\n    <source src=\"\/assets\/videos\/PlayTorch-video.mp4\" type=\"video\/mp4\">\n  <\/video>\n<\/p>","__index_level_0__":4245}
+{"text":"In December, we announced PyTorch Live, a toolkit for building AI-powered mobile prototypes in minutes. The initial release included a command-line interface to set up a development environment and an SDK for building AI-powered experiences in React Native. Today, we're excited to share that PyTorch Live will now be known as PlayTorch. This new release provides an improved and simplified developer experience. PlayTorch development is independent from the PyTorch project and the PlayTorch code repository is moving into the Meta Research GitHub organization.","__index_level_0__":4246}
+{"text":"## A New Workflow: The PlayTorch App","__index_level_0__":4247}
+{"text":"The PlayTorch team is excited to announce that we have partnered with [Expo](https:\/\/expo.dev) to change the way AI powered mobile experiences are built. Our new release simplifies the process of building mobile AI experiences by eliminating the need for a complicated development environment. You will now be able to build cross platform AI powered prototypes from the very browser you are using to read this blog.","__index_level_0__":4248}
+{"text":"In order to make this happen, we are releasing the [PlayTorch app](https:\/\/playtorch.dev\/) which is able to run AI-powered experiences built in the [Expo Snack](https:\/\/snack.expo.dev\/@playtorch\/playtorch-starter?supportedPlatforms=my-device) web based code editor.","__index_level_0__":4249}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-introducing-the-playtorch-app-1.gif\" width=\"100%\">\n<\/p>","__index_level_0__":4250}
+{"text":"The PlayTorch app can be downloaded from the Apple App Store and Google Play Store. With the app installed, you can head over to [playtorch.dev\/snack](https:\/\/playtorch.dev\/snack) and write the code for your AI-powered PlayTorch Snack. When you want to try what you\u2019ve built, you can use the PlayTorch app\u2019s QR code scanner to scan the QR code on the Snack page and load the code to your device.","__index_level_0__":4251}
+{"text":"NOTE: PlayTorch Snacks will not work in the Expo Go app.","__index_level_0__":4252}
+{"text":"## More to Explore in the PlayTorch App","__index_level_0__":4253}
+{"text":"### AI Demos","__index_level_0__":4254}
+{"text":"The PlayTorch app comes with several examples of how you can build AI powered experiences with a variety of different machine learning models from object detection to natural language processing. See what can be built with the PlayTorch SDK and be inspired to make something of your own as you play with the examples.","__index_level_0__":4255}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-introducing-the-playtorch-app-2.jpg\" width=\"100%\">\n<\/p>","__index_level_0__":4256}
+{"text":"### Sharing Your Creations","__index_level_0__":4257}
+{"text":"Any PlayTorch Snack that you run in the PlayTorch app can be shared with others in an instant. When they open the link on their device, the PlayTorch app will instantly load what you\u2019ve built from the cloud so they can experience it first hand.","__index_level_0__":4258}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-introducing-the-playtorch-app-3.jpg\" width=\"100%\">\n<\/p>","__index_level_0__":4259}
+{"text":"When you have something you want to share, let us know on [Discord](https:\/\/discord.gg\/sQkXTqEt33) or [Twitter](https:\/\/twitter.com\/PlayTorch) or embed the PlayTorch Snack on your own webpage.","__index_level_0__":4260}
+{"text":"## SDK Overhaul","__index_level_0__":4261}
+{"text":"We learned a lot from the community after our initial launch in December and have been hard at work over the past several months to make the PlayTorch SDK (formerly known as PyTorch Live) simple, performant, and robust. In our initial version, the SDK relied on config files to define how a model ingested and output data.","__index_level_0__":4262}
+{"text":"Today, we are happy to announce the next version of our SDK can handle data processing in JavaScript for your prototypes with the new PlayTorch API that leverages the JavaScript Interface (JSI) to directly call C++ code. Not only have we completely redone the way you can interact with models, but we have also greatly expanded the variety of supported model architectures.","__index_level_0__":4263}
+{"text":"## A New Data Processing API for Prototyping","__index_level_0__":4264}
+{"text":"With this JSI API, we now allow users direct access to tensors (data format for machine learning). Instead of only having access to predefined transformations, you can now manipulate tensors however you would like for your prototypes.","__index_level_0__":4265}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-introducing-the-playtorch-app-4.gif\" width=\"100%\">\n<\/p>","__index_level_0__":4266}
+{"text":"No more switching back and forth between code and config. You will now be able to write everything in JavaScript and have access to all of the type annotations and autocomplete features available to you in those languages.","__index_level_0__":4267}
+{"text":"Check out our [tutorials](https:\/\/playtorch.dev\/tutorials) to see the new Data Processing API in action, take a deeper dive in the [API docs](https:\/\/playtorch.dev\/docs\/api\/core\/), or inspect the code yourself on [GitHub](https:\/\/github.com\/facebookresearch\/playtorch).","__index_level_0__":4268}
+{"text":"### Expanded Use Cases","__index_level_0__":4269}
+{"text":"With the new version of the SDK, we have added support for several cutting edge models.","__index_level_0__":4270}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-introducing-the-playtorch-app-5.jpg\" width=\"100%\">\n<\/p>","__index_level_0__":4271}
+{"text":"Image-to-image transformations are now supported thanks to our robust JSI API, so you can see what your world would look like if it were an anime.","__index_level_0__":4272}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-introducing-the-playtorch-app-6.jpg\" width=\"100%\">\n<\/p>","__index_level_0__":4273}
+{"text":"Translate French to English with an AI powered translator using the Seq2Seq model.","__index_level_0__":4274}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-introducing-the-playtorch-app-7.jpg\" width=\"100%\">\n<\/p>","__index_level_0__":4275}
+{"text":"Use DeepLab V3 to segment images!","__index_level_0__":4276}
+{"text":"## Start Playing","__index_level_0__":4277}
+{"text":"If you want to start creating AI experiences yourself, head over to [playtorch.dev](https:\/\/playtorch.dev) and try out our [tutorials](https:\/\/playtorch.dev\/tutorials\/). Each tutorial will guide you through building a simple AI powered experience that you can instantly run on your phone and share with others.","__index_level_0__":4278}
+{"text":"## How to Get Support","__index_level_0__":4279}
+{"text":"Join us on [Discord](https:\/\/discord.gg\/sQkXTqEt33), collaborate with us on [GitHub](https:\/\/github.com\/facebookresearch\/playtorch), or follow us on [Twitter](https:\/\/twitter.com\/playtorch). Got questions or feedback? We\u2019d love to hear from you!\n \n source: https:\/\/pytorch.org\/blog\/introducing-the-playtorch-app\/ \n category: pytorch blogs","__index_level_0__":4280}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Overview of PyTorch Autograd Engine'\nauthor: Preferred Networks, Inc.\n---","__index_level_0__":4281}
+{"text":"This blog post is based on PyTorch version 1.8, although it should apply for older versions too, since most of the mechanics have remained constant.","__index_level_0__":4282}
+{"text":"To help understand the concepts explained here, it is recommended that you read the awesome blog post by [@ezyang](https:\/\/twitter.com\/ezyang): [PyTorch internals](http:\/\/blog.ezyang.com\/2019\/05\/pytorch-internals\/) if you are not familiar with PyTorch architecture components such as ATen or c10d.","__index_level_0__":4283}
+{"text":"### What is autograd?","__index_level_0__":4284}
+{"text":"**Background**","__index_level_0__":4285}
+{"text":"PyTorch computes the gradient of a function with respect to the inputs by using automatic differentiation. Automatic differentiation is a technique that, given a computational graph, calculates the gradients of the inputs. Automatic differentiation can be performed in two different ways; forward and reverse mode. Forward mode means that we calculate the gradients along with the result of the function, while reverse mode requires us to evaluate the function first, and then we calculate the gradients starting from the output. While both modes have their pros and cons, the reverse mode is the de-facto choice since the number of outputs is smaller than the number of inputs, which allows a much more efficient computation. Check [3] to learn more about this.","__index_level_0__":4286}
+{"text":"Automatic differentiation relies on a classic calculus formula known as the chain-rule. The chain rule allows us to calculate very complex derivatives by splitting them and recombining them later.","__index_level_0__":4287}
+{"text":"Formally speaking, given a composite function <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=f(g(x))\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?f(g(x))\" title=\"f(g(x))\" \/><\/a>, we can calculate its derivative as <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial}{\\partial&space;x}&space;f(g(x))&space;=&space;f'(g(x))g'(x)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial}{\\partial&space;x}&space;f(g(x))&space;=&space;f'(g(x))g'(x)\" title=\"\\frac{\\partial}{\\partial x} f(g(x)) = f'(g(x))g'(x)\" \/><\/a>. This result is what makes automatic differentiation work.\nBy combining the derivatives of the simpler functions that compose a larger one, such as a neural network, it is possible to compute the exact value of the gradient at a given point rather than relying on the numerical approximation, which would require multiple perturbations in the input to obtain a value.","__index_level_0__":4288}
+{"text":"To get the intuition of how the reverse mode works, let\u2019s look at a simple function <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=f(x,&space;y)&space;=&space;log(x*y)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?f(x,&space;y)&space;=&space;log(x*y)\" title=\"f(x, y) = log(x*y)\" \/><\/a>. Figure 1 shows its computational graph where the inputs x, y in the left, flow through a series of operations to generate the output z.","__index_level_0__":4289}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/f_x_y_graph.png\" width=\"100%\">\n  <p>Figure 1: Computational graph of f(x, y) = log(x*y)<\/p>\n<\/div>","__index_level_0__":4290}
+{"text":"The automatic differentiation engine will normally execute this graph. It will also extend it to calculate the derivatives of w with respect to the inputs x, y, and the intermediate result v.","__index_level_0__":4291}
+{"text":"The example function can be decomposed in f and g, where <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=f(x,&space;y)&space;=&space;log(g(x,&space;y))\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?f(x,&space;y)&space;=&space;log(g(x,&space;y))\" title=\"f(x, y) = log(g(x, y))\" \/><\/a> and <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=g(x,&space;y)&space;=&space;xy\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?g(x,&space;y)&space;=&space;xy\" title=\"g(x, y) = xy\" \/><\/a>.  Every time the engine executes an operation in the graph, the derivative of that operation is added to the graph to be executed later in the backward pass. Note, that the engine knows the derivatives of the basic functions.","__index_level_0__":4292}
+{"text":"In the example above, when multiplying x and y to obtain v, the engine will extend the graph to calculate the partial derivatives of the multiplication by using the multiplication derivative definition that it already knows. <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial}{\\partial&space;x}&space;g(x,&space;y)&space;=&space;y\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial}{\\partial&space;x}&space;g(x,&space;y)&space;=&space;y\" title=\"\\frac{\\partial}{\\partial x} g(x, y) = y\" \/><\/a> and <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial}{\\partial&space;y}&space;g(x,&space;y)&space;=&space;x\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial}{\\partial&space;y}&space;g(x,&space;y)&space;=&space;x\" title=\"\\frac{\\partial}{\\partial y} g(x, y) = x\" \/><\/a> . The resulting extended graph is shown in Figure 2, where the *MultDerivative* node also calculates the product of the resulting gradients by an input gradient to apply the chain rule; this will be explicitly seen in the following operations. Note that the backward graph (green nodes) will not be executed until all the forward steps are completed.","__index_level_0__":4293}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/multi_derivative_graph.png\" width=\"100%\">\n  <p>Figure 2: Computational graph extended after executing the logarithm<\/p>\n<\/div>","__index_level_0__":4294}
+{"text":"Continuing, the engine now calculates the <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=log(v)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?log(v)\" title=\"log(v)\" \/><\/a> operation and extends the graph again with the log derivative that it knows to be <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{1}{v}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{1}{v}\" title=\"\\frac{1}{v}\" \/><\/a>. This is shown in figure 3. This operation generates the result <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;w}{\\partial&space;v}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;w}{\\partial&space;v}\" title=\"\\frac{\\partial w}{\\partial v}\" \/><\/a> that when propagated backward and multiplied by the multiplication derivative as in the chain rule, generates the derivatives <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;w}{\\partial&space;x}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;w}{\\partial&space;x}\" title=\"\\frac{\\partial w}{\\partial x}\" \/><\/a>, <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;w}{\\partial&space;x}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;w}{\\partial&space;x}\" title=\"\\frac{\\partial w}{\\partial x}\" \/><\/a>.","__index_level_0__":4295}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/extended_computational_graph.png\" width=\"100%\">\n  <p>Figure 3: Computational graph extended after executing the logarithm<\/p>\n<\/div>","__index_level_0__":4296}
+{"text":"The original computation graph is extended with a new dummy variable z that is the same w. The derivative of z with respect to w is 1 as they are the same variable, this trick allows us to apply the chain rule to calculate the derivatives of the inputs. After the forward pass is complete, we start the backward pass, by supplying the initial value of 1.0 for <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{\\partial&space;w}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{\\partial&space;w}\" title=\"\\frac{\\partial z}{\\partial w}\" \/><\/a>. This is shown in Figure 4.","__index_level_0__":4297}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/computational_graph_reverse_auto_differentiation.png\" width=\"100%\">\n  <p>Figure 4: Computational graph extended for reverse auto differentiation<\/p>\n<\/div>","__index_level_0__":4298}
+{"text":"Then following the green graph we execute the LogDerivative operation <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{1}{v}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{1}{v}\" title=\"\\frac{1}{v}\" \/><\/a> that the auto differentiation engine introduced, and multiply its result by <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{\\partial&space;w}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{\\partial&space;w}\" title=\"\\frac{\\partial z}{\\partial w}\" \/><\/a> to obtain the gradient <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{\\partial&space;v}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{\\partial&space;v}\" title=\"\\frac{\\partial z}{\\partial v}\" \/><\/a> as per the chain rule states. Next, the multiplication derivative is executed in the same way, and the desired derivatives <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{\\partial&space;x}&space;\\frac{\\partial&space;z}{\\partial&space;y}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{\\partial&space;x}&space;\\frac{\\partial&space;z}{\\partial&space;y}\" title=\"\\frac{\\partial z}{\\partial x} \\frac{\\partial z}{\\partial y}\" \/><\/a> are finally obtained.","__index_level_0__":4299}
+{"text":"Formally, what we are doing here, and PyTorch autograd engine also does, is computing a Jacobian-vector product (Jvp) to calculate the gradients of the model parameters, since the model parameters and inputs are vectors.","__index_level_0__":4300}
+{"text":"**The Jacobian-vector product**","__index_level_0__":4301}
+{"text":"When we calculate the gradient of a vector-valued function <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=f(\\overline{x})&space;=&space;\\overline{y}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?f(\\overline{x})&space;=&space;\\overline{y}\" title=\"f(\\overline{x}) = \\overline{y}\" \/><\/a> (a function whose inputs and outputs are vectors), we are essentially constructing a Jacobian matrix .","__index_level_0__":4302}
+{"text":"Thanks to the chain rule, multiplying the Jacobian matrix of a function <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=f(\\overline{x})&space;=&space;\\overline{y}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?f(\\overline{x})&space;=&space;\\overline{y}\" title=\"f(\\overline{x}) = \\overline{y}\" \/><\/a> by a vector <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=v\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?v\" title=\"v\" \/><\/a> with the previously calculated gradients of a scalar function <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=z&space;=&space;g(\\overline{y})\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?z&space;=&space;g(\\overline{y})\" title=\"z = g(\\overline{y})\" \/><\/a> results in the gradients <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{\\partial&space;x_1}&space;\\cdots&space;\\frac{\\partial&space;z}{\\partial&space;x_n}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{\\partial&space;x_1}&space;\\cdots&space;\\frac{\\partial&space;z}{\\partial&space;x_n}\" title=\"\\frac{\\partial z}{\\partial x_1} \\cdots \\frac{\\partial z}{\\partial x_n}\" \/><\/a> of the scalar output with respect to the vector-valued function inputs.","__index_level_0__":4303}
+{"text":"As an example, let\u2019s look at some functions in python notation to show how the chain rule applies.\n<div class=\"outlined-code-block\">\n  <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=f(x_1,&space;x_2)&space;=&space;(log(x_1&space;x_2),&space;sin(x_2))\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?f(x_1,&space;x_2)&space;=&space;(log(x_1&space;x_2),&space;sin(x_2))\" title=\"f(x_1, x_2) = (log(x_1 x_2), sin(x_2))\" \/><\/a>","__index_level_0__":4304}
+{"text":"  <pre>def f(x1, x2):\n      a = x1 * x2\n      y1 = log(a)\n      y2 = sin(x2)\n      return (y1, y2)\n  <\/pre>","__index_level_0__":4305}
+{"text":"  <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=g(y_1,&space;y_2)&space;=&space;y_1&space;y_2\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?g(y_1,&space;y_2)&space;=&space;y_1&space;y_2\" title=\"g(y_1, y_2) = y_1 y_2\" \/><\/a>","__index_level_0__":4306}
+{"text":"  <pre>def g(y1, y2):\n      return y1 * y2\n  <\/pre>","__index_level_0__":4307}
+{"text":"Now, if we derive this by hand using the chain rule and the definition of the derivatives, we obtain the following set of identities that we can directly plug into the Jacobian matrix of <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=f(x_1,&space;x_2)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?f(x_1,&space;x_2)\" title=\"f(x_1, x_2)\" \/><\/a>","__index_level_0__":4309}
+{"text":"<div class=\"outlined-code-block\">\n  <p><a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;y_1}{\\partial&space;x_1}&space;=&space;\\frac{\\partial&space;y_1}{\\partial&space;a}\\frac{\\partial&space;a}{\\partial&space;x_1}&space;=&space;\\frac{1}{x_1}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;y_1}{\\partial&space;x_1}&space;=&space;\\frac{\\partial&space;y_1}{\\partial&space;a}\\frac{\\partial&space;a}{\\partial&space;x_1}&space;=&space;\\frac{1}{x_1}\" title=\"\\frac{\\partial y_1}{\\partial x_1} = \\frac{\\partial y_1}{\\partial a}\\frac{\\partial a}{\\partial x_1} = \\frac{1}{x_1}\" \/><\/a><\/p>\n  <p><a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;y_1}{\\partial&space;x_2}&space;=&space;\\frac{\\partial&space;y_1}{\\partial&space;a}\\frac{\\partial&space;a}{\\partial&space;x_2}&space;=&space;\\frac{1}{x_2}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;y_1}{\\partial&space;x_2}&space;=&space;\\frac{\\partial&space;y_1}{\\partial&space;a}\\frac{\\partial&space;a}{\\partial&space;x_2}&space;=&space;\\frac{1}{x_2}\" title=\"\\frac{\\partial y_1}{\\partial x_2} = \\frac{\\partial y_1}{\\partial a}\\frac{\\partial a}{\\partial x_2} = \\frac{1}{x_2}\" \/><\/a><\/p>\n  <p><a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;y_2}{\\partial&space;x_1}&space;=&space;0\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;y_2}{\\partial&space;x_1}&space;=&space;0\" title=\"\\frac{\\partial y_2}{\\partial x_1} = 0\" \/><\/a><\/p>\n  <p><a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;y_2}{\\partial&space;x_2}&space;=&space;cos(x_2)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;y_2}{\\partial&space;x_2}&space;=&space;cos(x_2)\" title=\"\\frac{\\partial y_2}{\\partial x_2} = cos(x_2)\" \/><\/a><\/p>\n<\/div>","__index_level_0__":4310}
+{"text":"Next, let\u2019s consider the gradients for the scalar function <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=z&space;=&space;g(y_1,&space;y_2)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?z&space;=&space;g(y_1,&space;y_2)\" title=\"z = g(y_1, y_2)\" \/><\/a>","__index_level_0__":4311}
+{"text":"<div class=\"outlined-code-block\">\n  <p><a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{y_1}&space;=&space;y_2\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{y_1}&space;=&space;y_2\" title=\"\\frac{\\partial z}{y_1} = y_2\" \/><\/a><\/p>\n  <p><a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{y_2}&space;=&space;y_1\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{y_2}&space;=&space;y_1\" title=\"\\frac{\\partial z}{y_2} = y_1\" \/><\/a><\/p>\n<\/div>","__index_level_0__":4312}
+{"text":"If we now calculate the transpose-Jacobian vector product obeying the chain rule, we obtain the following expression:\n<div style=\"overflow:scroll\">\n  <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\begin{pmatrix}\\frac{\\partial&space;y_1}{\\partial&space;x_1}&space;&&space;\\frac{\\partial&space;y_1}{\\partial&space;x_2}&space;\\\\\\\\&space;\\frac{\\partial&space;y_2}{\\partial&space;x_1}&space;&&space;\\frac{\\partial&space;y_2}{\\partial&space;x_2}&space;\\end{pmatrix}^{t}&space;\\begin{pmatrix}&space;y_2\\\\y_1&space;\\end{pmatrix}&space;=&space;\\begin{pmatrix}\\frac{1}{x_1}&space;&&space;\\frac{1}{x_2}&space;\\\\\\\\&space;0&space;&&space;cos(x_2))&space;\\end{pmatrix}^{t}&space;\\begin{pmatrix}&space;y_2\\\\y_1&space;\\end{pmatrix}&space;=&space;\\begin{pmatrix}&space;\\frac{1}{x_1}y_2\\\\\\frac{1}{x_2}y_2&plus;cos(x_2)y_1&space;\\end{pmatrix}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\begin{pmatrix}\\frac{\\partial&space;y_1}{\\partial&space;x_1}&space;&&space;\\frac{\\partial&space;y_1}{\\partial&space;x_2}&space;\\\\\\\\&space;\\frac{\\partial&space;y_2}{\\partial&space;x_1}&space;&&space;\\frac{\\partial&space;y_2}{\\partial&space;x_2}&space;\\end{pmatrix}^{t}&space;\\begin{pmatrix}&space;y_2\\\\y_1&space;\\end{pmatrix}&space;=&space;\\begin{pmatrix}\\frac{1}{x_1}&space;&&space;\\frac{1}{x_2}&space;\\\\\\\\&space;0&space;&&space;cos(x_2))&space;\\end{pmatrix}^{t}&space;\\begin{pmatrix}&space;y_2\\\\y_1&space;\\end{pmatrix}&space;=&space;\\begin{pmatrix}&space;\\frac{1}{x_1}y_2\\\\\\frac{1}{x_2}y_2&plus;cos(x_2)y_1&space;\\end{pmatrix}\" title=\"\\begin{pmatrix}\\frac{\\partial y_1}{\\partial x_1} & \\frac{\\partial y_1}{\\partial x_2} \\\\\\\\ \\frac{\\partial y_2}{\\partial x_1} & \\frac{\\partial y_2}{\\partial x_2} \\end{pmatrix}^{t} \\begin{pmatrix} y_2\\\\y_1 \\end{pmatrix} = \\begin{pmatrix}\\frac{1}{x_1} & \\frac{1}{x_2} \\\\\\\\ 0 & cos(x_2)) \\end{pmatrix}^{t} \\begin{pmatrix} y_2\\\\y_1 \\end{pmatrix} = \\begin{pmatrix} \\frac{1}{x_1}y_2\\\\\\frac{1}{x_2}y_2+cos(x_2)y_1 \\end{pmatrix}\" \/><\/a>\n<\/div>","__index_level_0__":4313}
+{"text":"Evaluating the Jvp for <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=(x_1,&space;x_2)&space;=&space;(0.5,&space;0.75)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?(x_1,&space;x_2)&space;=&space;(0.5,&space;0.75)\" title=\"(x_1, x_2) = (0.5, 0.75)\" \/><\/a> yields the result:\n<a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=(\\frac{dy}{x_1},&space;\\frac{dy}{x_2})&space;=&space;(1.3633,&space;0.1912)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?(\\frac{dy}{x_1},&space;\\frac{dy}{x_2})&space;=&space;(1.3633,&space;0.1912)\" title=\"(\\frac{dy}{x_1}, \\frac{dy}{x_2}) = (1.3633, 0.1912)\" \/><\/a>\nWe can execute the same expression in PyTorch and calculate the gradient of the input:\n<div class=\"outlined-code-block\">\n  <pre>>>> import torch<\/pre>\n  <pre>>>> x = torch.tensor([0.5, 0.75], requires_grad=True)<\/pre>\n  <pre>>>> y = torch.log(x[0] * x[1]) * torch.sin(x[1])<\/pre>\n  <pre>>>> y.backward(1.0)<\/pre>\n  <pre>>>> x.grad<\/pre>\n  tensor([1.3633,\n          0.1912])<\/pre>\n<\/div>","__index_level_0__":4314}
+{"text":"The result is the same as our hand-calculated Jacobian-vector product!\nHowever, PyTorch never constructed the matrix as it could grow prohibitively large but instead, created a graph of operations that traversed backward while applying the Jacobian-vector products defined in [tools\/autograd\/derivatives.yaml](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/tools\/autograd\/derivatives.yaml).","__index_level_0__":4315}
+{"text":"**Going through the graph**","__index_level_0__":4316}
+{"text":"Every time PyTorch executes an operation, the autograd engine constructs the graph to be traversed backward.\nThe reverse mode auto differentiation starts by adding a scalar variable at the end <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=z&space;=&space;w\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?z&space;=&space;w\" title=\"z = w\" \/><\/a> so that <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{\\partial&space;w}&space;=&space;1\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{\\partial&space;w}&space;=&space;1\" title=\"\\frac{\\partial z}{\\partial w} = 1\" \/><\/a> as we saw in the introduction. This is the initial gradient value that is supplied to the Jvp engine calculation as we saw in the section above.","__index_level_0__":4317}
+{"text":"In PyTorch, the initial gradient is explicitly set by the user when he calls the backward method.","__index_level_0__":4318}
+{"text":"Then, the Jvp calculation starts but it never constructs the matrix. Instead, when PyTorch records the computational graph, the derivatives of the executed forward operations are added (Backward Nodes). Figure 5 shows a backward graph generated by the execution of the functions <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=f(x_1,&space;x_2)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?f(x_1,&space;x_2)\" title=\"f(x_1, x_2)\" \/><\/a> and <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=g(y_1,&space;y_2)\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?g(y_1,&space;y_2)\" title=\"g(y_1, y_2)\" \/><\/a> seen before.","__index_level_0__":4319}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/computational_graph_backward_pass.png\" width=\"100%\">\n  <p>Figure 5: Computational Graph extended with the backward pass<\/p>\n<\/div>","__index_level_0__":4320}
+{"text":"Once the forward pass is done, the results are used in the backward pass where the derivatives in the computational graph are executed. The basic derivatives are stored in the [tools\/autograd\/derivatives.yaml](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/tools\/autograd\/derivatives.yaml) file and they are not regular derivatives but the Jvp versions of them [3]. They take their primitive function inputs and outputs as parameters along with the gradient of the function outputs with respect to the final outputs. By repeatedly multiplying the resulting gradients by the next Jvp derivatives in the graph, the gradients up to the inputs will be generated following the chain rule.","__index_level_0__":4321}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/chain_rule_backward_differentiation.png\" width=\"100%\">\n  <p>Figure 6: How the chain rule is applied in backward differentiation<\/p>\n<\/div>","__index_level_0__":4322}
+{"text":"Figure 6 represents the process by showing the chain rule. We started with a value of 1.0 as detailed before which is the already calculated gradient <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;y}{\\partial&space;u}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;y}{\\partial&space;u}\" title=\"\\frac{\\partial y}{\\partial u}\" \/><\/a> highlighted in green. And we move to the next node in the graph. The *backward* function registered in [derivatives.yaml](https:\/\/github.com\/pytorch\/pytorch\/blob\/a0a7a2d648f05b0192e6943c9684406cdf404fbf\/tools\/autograd\/derivatives.yaml#L635-L636) will calculate the associated\n<a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;u}{\\partial&space;v}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;u}{\\partial&space;v}\" title=\"\\frac{\\partial u}{\\partial v}\" \/><\/a> value highlighted in red and multiply it by <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;y}{\\partial&space;u}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;y}{\\partial&space;u}\" title=\"\\frac{\\partial y}{\\partial u}\" \/><\/a>. By the chain rule this results in <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;y}{\\partial&space;v}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;y}{\\partial&space;v}\" title=\"\\frac{\\partial y}{\\partial v}\" \/><\/a> which will be the already calculated gradient (green) when we process the next backward node in the graph.","__index_level_0__":4323}
+{"text":"You may also have noticed that in Figure 5 there is a gradient generated from two different sources. When two different functions share an input, the gradients with respect to the output are aggregated for that input, and calculations using that gradient can\u2019t proceed unless all the paths have been aggregated together.","__index_level_0__":4324}
+{"text":"Let\u2019s see an example of how the derivatives are stored in PyTorch.","__index_level_0__":4325}
+{"text":"Suppose that we are currently processing the backward propagation of the <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=log\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?log\" title=\"log\" \/><\/a> function, in the *LogBackward* node in Figure 2.  The derivative of <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=log\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?log\" title=\"log\" \/><\/a> in [`derivatives.yaml`](https:\/\/github.com\/pytorch\/pytorch\/blob\/a0a7a2d648f05b0192e6943c9684406cdf404fbf\/tools\/autograd\/derivatives.yaml#L635-L636) is specified as `grad.div(self.conj())`. `grad` is the already calculated gradient <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{\\partial&space;y1}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{\\partial&space;y1}\" title=\"\\frac{\\partial z}{\\partial y1}\" \/><\/a> and `self.conj()` is the complex conjugate of the input vector. For complex numbers PyTorch calculates a special derivative called the conjugate Wirtinger derivative [6]. This derivative takes the complex number and its conjugate and by operating some magic that is described in [6], they are the direction of steepest descent when plugged into optimizers.","__index_level_0__":4326}
+{"text":"This code translates to <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=(\\frac{\\partial&space;z}{\\partial&space;y1}&space;\\frac{1}{v})\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?(\\frac{\\partial&space;z}{\\partial&space;y1}&space;\\frac{1}{v})\" title=\"(\\frac{\\partial z}{\\partial y1} \\frac{1}{v})\" \/><\/a>, the corresponding green, and red squares in Figure 3. Continuing, the autograd engine will execute the next operation; backward of the multiplication. As before, the inputs are the original function\u2019s inputs and the gradient calculated from the <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=log\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?log\" title=\"log\" \/><\/a> backward step. This step will keep repeating until we reach the gradient with respect to the inputs and the computation will be finished. The gradient of <a href=\"https:\/\/www.codecogs.com\/eqnedit.php?latex=\\frac{\\partial&space;z}{x2}\" target=\"_blank\"><img src=\"https:\/\/latex.codecogs.com\/gif.latex?\\frac{\\partial&space;z}{x2}\" title=\"\\frac{\\partial z}{x2}\" \/><\/a> is only completed once the multiplication and sin gradients are added together. As you can see, we computed the equivalent of the Jvp but without constructing the matrix.","__index_level_0__":4327}
+{"text":"In the next post we will dive inside PyTorch code to see how this graph is constructed and where are the relevant pieces should you want to experiment with it!","__index_level_0__":4328}
+{"text":"### References","__index_level_0__":4329}
+{"text":"<ol class=\"reference-list\">\n  <li><a href=\"https:\/\/pytorch.org\/tutorials\/beginner\/blitz\/autograd_tutorial.html\">https:\/\/pytorch.org\/tutorials\/beginner\/blitz\/autograd_tutorial.html<\/a><\/li>\n  <li><a href=\"https:\/\/web.stanford.edu\/class\/cs224n\/readings\/gradient-notes.pdf\">https:\/\/web.stanford.edu\/class\/cs224n\/readings\/gradient-notes.pdf<\/a><\/li>\n  <li><a href=\"https:\/\/www.cs.toronto.edu\/~rgrosse\/courses\/csc321_2018\/slides\/lec10.pdf\">https:\/\/www.cs.toronto.edu\/~rgrosse\/courses\/csc321_2018\/slides\/lec10.pdf<\/a><\/li>\n  <li><a href=\"https:\/\/mustafaghali11.medium.com\/how-pytorch-backward-function-works-55669b3b7c62\">https:\/\/mustafaghali11.medium.com\/how-pytorch-backward-function-works-55669b3b7c62<\/a><\/li>\n  <li><a href=\"https:\/\/indico.cern.ch\/event\/708041\/contributions\/3308814\/attachments\/1813852\/2963725\/automatic_differentiation_and_deep_learning.pdf\">https:\/\/indico.cern.ch\/event\/708041\/contributions\/3308814\/attachments\/1813852\/2963725\/automatic_differentiation_and_deep_learning.pdf<\/a><\/li>\n  <li><a href=\"https:\/\/pytorch.org\/docs\/stable\/notes\/autograd.html#complex-autograd-doc\">https:\/\/pytorch.org\/docs\/stable\/notes\/autograd.html#complex-autograd-doc<\/a><\/li>\n  <p>Recommended: shows why the backprop is formally expressed with the Jacobian<\/p>\n  <li><a href=\"https:\/\/www.cs.ubc.ca\/~fwood\/CS340\/lectures\/AD1.pdf\">https:\/\/cs.ubc.ca\/~fwood\/CS340\/lectures\/AD1.pdf<\/a><\/li>\n<\/ol>\n \n source: https:\/\/pytorch.org\/blog\/overview-of-pytorch-autograd-engine\/ \n category: pytorch blogs","__index_level_0__":4330}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Case Study: Amazon Ads Uses PyTorch and AWS Inferentia to Scale Models for Ads Processing\"\nauthor: Yashal Kanungo \u2013 Applied Scientist, Kamran Khan -  Sr. Technical Product Manager, Shubha Kumbadakone \u2013  Sr. Specialist, ML Frameworks\nfeatured-img: \"\"\n---","__index_level_0__":4331}
+{"text":"Amazon Ads uses PyTorch, TorchServe, and AWS Inferentia to reduce inference costs by 71% and drive scale out.","__index_level_0__":4332}
+{"text":"Amazon Ads helps companies build their brand and connect with shoppers through ads shown both within and beyond Amazon\u2019s store, including websites, apps, and streaming TV content in more than 15 countries. Businesses and brands of all sizes, including registered sellers, vendors, book vendors, Kindle Direct Publishing (KDP) authors, app developers, and agencies can upload their own ad creatives, which can include images, video, audio, and, of course, products sold on Amazon.","__index_level_0__":4333}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/amazon-ads-case-study\/amazon-advertising.png\" width=\"60%\">\n<\/p>","__index_level_0__":4334}
+{"text":"To promote an accurate, safe, and pleasant shopping experience, these ads must comply with content guidelines. For example, ads cannot flash on and off, products must be featured in an appropriate context, and images and text should be appropriate for a general audience. To help ensure that ads meet the required policies and standards, we needed to develop scalable mechanisms and tools.","__index_level_0__":4335}
+{"text":"As a solution, we used machine learning (ML) models to surface ads that might need revision. As deep neural networks flourished over the past decade, our data science team began exploring more versatile deep learning (DL) methods capable of processing text, images, audio, or video with minimal human intervention. To that end, we\u2019ve used PyTorch to build computer vision (CV) and natural language processing (NLP) models that automatically flag potentially non-compliant ads. PyTorch is intuitive, flexible, and user-friendly, and has made our transition to using DL models seamless. Deploying these new models on [AWS Inferentia-based Amazon EC2 Inf1 instances](https:\/\/aws.amazon.com\/ec2\/instance-types\/inf1\/), rather than on GPU-based instances, reduced our inference latency by 30 percent and our inference costs by 71 percent for the same workloads.","__index_level_0__":4336}
+{"text":"## Transition to deep learning","__index_level_0__":4337}
+{"text":"Our ML systems paired classical models with word embeddings to evaluate ad text. But our requirements evolved, and as the volume of submissions continued to expand, we needed a method nimble enough to scale along with our business. In addition, our models must be fast and serve ads within milliseconds to provide an optimal customer experience.","__index_level_0__":4338}
+{"text":"Over the last decade, DL has become very popular in numerous domains, including natural language, vision, and audio. Because deep neural networks channel data sets through many layers \u2014 extracting progressively higher-level features \u2014 they can make more nuanced inferences than classical ML models. Rather than simply detecting prohibited language, for example, a DL model can reject an ad for making false claims.","__index_level_0__":4339}
+{"text":"In addition, DL techniques are transferable\u2013 a model trained for one task can be adapted to carry out a related task. For instance, a pre-trained neural network can be optimized to detect objects in images and then fine-tuned to identify specific objects that are not allowed to be displayed in an ad.","__index_level_0__":4340}
+{"text":"Deep neural networks can automate two of classical ML\u2019s most time-consuming steps: feature engineering and data labeling. Unlike traditional supervised learning approaches, which require exploratory data analysis and hand-engineered features, deep neural networks learn the relevant features directly from the data. DL models can also analyze unstructured data, like text and images, without the preprocessing necessary in ML. Deep neural networks scale effectively with more data and perform especially well in applications involving large data sets.","__index_level_0__":4341}
+{"text":"We chose PyTorch to develop our models because it helped us maximize the performance of our systems. With PyTorch, we can serve our customers better while taking advantage of Python\u2019s most intuitive concepts. The programming in PyTorch is object-oriented: it groups processing functions with the data they modify. As a result, our codebase is modular, and we can reuse pieces of code in different applications. In addition, PyTorch\u2019s eager mode allows loops and control structures and, therefore, more complex operations in the model. Eager mode makes it easy to prototype and iterate upon our models, and we can work with various data structures. This flexibility helps us update our models quickly to meet changing business requirements.","__index_level_0__":4342}
+{"text":"\u201cBefore this, we experimented with other frameworks that were \u201cPythonic,\u201d but PyTorch was the clear winner for us here.\u201d said Yashal Kanungo, Applied Scientist. \u201cUsing PyTorch was easy because the structure felt native to Python programming, which the data scientists were very familiar with\u201d.","__index_level_0__":4343}
+{"text":"### Training pipeline","__index_level_0__":4344}
+{"text":"Today, we build our text models entirely in PyTorch. To save time and money, we often skip the early stages of training by fine-tuning a pre-trained NLP model for language analysis. If we need a new model to evaluate images or video, we start by browsing PyTorch\u2019s [torchvision](https:\/\/pytorch.org\/vision\/stable\/index.html) library, which offers pretrained options for image and video classification, object detection, instance segmentation, and pose estimation. For specialized tasks, we build a custom model from the ground up. PyTorch is perfect for this, because eager mode and the user-friendly front end make it easy to experiment with different architectures.","__index_level_0__":4345}
+{"text":"_To learn how to finetune neural networks in PyTorch, head to [this tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/torchvision_tutorial.html#finetuning-from-a-pretrained-model)._","__index_level_0__":4346}
+{"text":"Before we begin training, we optimize our model\u2019s [hyperparameters](https:\/\/docs.aws.amazon.com\/sagemaker\/latest\/dg\/automatic-model-tuning-define-ranges.html), the variables that define the network architecture (for example, the number of hidden layers) and training mechanics (such as learning rate and batch size). Choosing appropriate hyperparameter values is essential, because they will shape the training behavior of the model. We rely on the [Bayesian search feature in SageMaker](https:\/\/docs.aws.amazon.com\/sagemaker\/latest\/dg\/automatic-model-tuning-how-it-works.html#automatic-tuning-bayesian-search.title), AWS\u2019s ML platform, for this step. Bayesian search treats hyperparameter tuning as a regression problem: It proposes the hyperparameter combinations that are likely to produce the best results and runs training jobs to test those values. After each trial, a regression algorithm determines the next set of hyperparameter values to test, and performance improves incrementally.","__index_level_0__":4347}
+{"text":"We prototype and iterate upon our models using SageMaker Notebooks. Eager mode lets us prototype models quickly by building a new computational graph for each training batch; the sequence of operations can change from iteration to iteration to accommodate different data structures or to jibe with intermediate results. That frees us to adjust the network during training without starting over from scratch. These dynamic graphs are particularly valuable for recursive computations based on variable sequence lengths, such as the words, sentences, and paragraphs in an ad that are analyzed with NLP.","__index_level_0__":4348}
+{"text":"When we\u2019ve finalized the model architecture, we deploy training jobs on [SageMaker](https:\/\/aws.amazon.com\/sagemaker\/). PyTorch helps us develop large models faster by running numerous training jobs at the same time. PyTorch\u2019s [Distributed Data Parallel](https:\/\/sagemaker.readthedocs.io\/en\/stable\/api\/training\/sdp_versions\/v1.0.0\/smd_data_parallel_pytorch.html) (DDP) module replicates a single model across multiple interconnected machines within SageMaker, and all the processes run forward passes simultaneously on their own unique portion of the data set. During the backward pass, the module averages the gradients of all the processes, so each local model is updated with the same parameter values.","__index_level_0__":4349}
+{"text":"### Model deployment pipeline","__index_level_0__":4350}
+{"text":"When we deploy the model in production, we want to ensure lower inference costs without impacting prediction accuracy. Several PyTorch features and AWS services have helped us address the challenge.","__index_level_0__":4351}
+{"text":"The flexibility of a dynamic graph enriches training, but in deployment we want to maximize performance and portability. An advantage of developing NLP models in PyTorch is that out of the box, they can be traced into a static sequence of operations by [TorchScript](https:\/\/pytorch.org\/docs\/stable\/jit.html), a subset of Python specialized for ML applications. Torchscript converts PyTorch models to a more efficient, production-friendly intermediate representation (IR) graph that is easily compiled. We run a sample input through the model, and TorchScript records the operations executed during the forward pass. The resulting IR graph can run in high-performance environments, including C++ and other multithreaded Python-free contexts, and optimizations such as operator fusion can speed up the runtime.","__index_level_0__":4352}
+{"text":"### Neuron SDK and AWS Inferentia powered compute","__index_level_0__":4353}
+{"text":"We deploy our models on [Amazon EC2 Inf1 instances](https:\/\/aws.amazon.com\/ec2\/instance-types\/inf1\/) powered by AWS Inferentia, Amazon's first ML silicon designed to accelerate deep learning inference workloads. Inferentia has shown to reduce inference costs by up to 70% compared to Amazon EC2 GPU-based instances.\nWe used the [AWS Neuron](https:\/\/aws.amazon.com\/machine-learning\/neuron\/) SDK \u2014 a set of software tools used with Inferentia \u2014 to compile and optimize our models for deployment on EC2 Inf1 instances.","__index_level_0__":4354}
+{"text":"The code snippet below shows how to compile a Hugging Face BERT model with Neuron. Like torch.jit.trace(), neuron.trace() records the model\u2019s operations on an example input during the forward pass to build a static IR graph.","__index_level_0__":4355}
+{"text":"```python\nimport torch\nfrom transformers import BertModel, BertTokenizer\nimport torch.neuron\ntokenizer = BertTokenizer.from_pretrained(\"path to saved vocab\")\nmodel = BertModel.from_pretrained(\"path to the saved model\", returned_dict=False)\ninputs = tokenizer (\"sample input\", return_tensor=\"pt\")\nneuron_model = torch.neuron.trace(model,\n                                  example_inputs = (inputs['input_ids'], inputs['attention_mask']),\n                                  verbose = 1)\noutput = neuron_model(*(inputs['input_ids'], inputs['attention_mask']))\n```","__index_level_0__":4356}
+{"text":"### Autocasting and recalibration","__index_level_0__":4357}
+{"text":"Under the hood, Neuron optimizes our models for performance by autocasting them to a smaller data type. As a default, most applications represent neural network values in the 32-bit single-precision floating point (FP32) number format. Autocasting the model to a 16-bit format \u2014 half-precision floating point (FP16) or Brain Floating Point (BF16) \u2014 reduces a model\u2019s memory footprint and execution time. In our case, we decided to use FP16 to optimize for performance while maintaining high accuracy.","__index_level_0__":4358}
+{"text":"Autocasting to a smaller data type can, in some cases, trigger slight differences in the model\u2019s predictions. To ensure that the model\u2019s accuracy is not affected, Neuron compares the performance metrics and predictions of the FP16 and FP32 models. When autocasting diminishes the model\u2019s accuracy, we can tell the Neuron compiler to convert only the weights and certain data inputs to FP16, keeping the rest of the intermediate results in FP32. In addition, we often run a few iterations with the training data to recalibrate our autocasted models. This process is much less intensive than the original training.","__index_level_0__":4359}
+{"text":"### Deployment","__index_level_0__":4360}
+{"text":"To analyze multimedia ads, we run an ensemble of DL models. All ads uploaded to Amazon are run through specialized models that assess every type of content they include: images, video and audio, headlines, texts, backgrounds, and even syntax, grammar, and potentially inappropriate language. The signals we receive from these models indicate whether or not an advertisement complies with our criteria.","__index_level_0__":4361}
+{"text":"Deploying and monitoring multiple models is significantly complex, so we depend on [TorchServe](https:\/\/github.com\/pytorch\/serve), SageMaker\u2019s default PyTorch model serving library. Jointly developed by Facebook\u2019s PyTorch team and AWS to streamline the transition from prototyping to production, TorchServe helps us deploy trained PyTorch models at scale without having to write custom code. It provides a secure set of REST APIs for inference, management, metrics, and explanations. With features such as multi-model serving, model versioning, ensemble support, and automatic batching, TorchServe is ideal for supporting our immense workload. You can read more about deploying your Pytorch models on SageMaker with native TorchServe integration in this [blog post](https:\/\/aws.amazon.com\/blogs\/machine-learning\/serving-pytorch-models-in-production-with-the-amazon-sagemaker-native-torchserve-integration\/).","__index_level_0__":4362}
+{"text":"In some use cases, we take advantage of PyTorch\u2019s object-oriented programming paradigm to wrap multiple DL models into one parent object \u2014 a PyTorch nn.Module \u2014 and serve them as a single ensemble. In other cases, we use TorchServe to serve individual models on separate SageMaker endpoints, running on AWS Inf1 instances.","__index_level_0__":4363}
+{"text":"### Custom handlers","__index_level_0__":4364}
+{"text":"We particularly appreciate that TorchServe allows us to embed our model initialization, preprocessing, inferencing, and post processing code in a single Python script, handler.py, which lives on the server. This script \u2014 the handler \u2014preprocesses the un-labeled data from an ad, runs that data through our models, and delivers the resulting inferences to downstream systems. TorchServe provides several default handlers that load weights and architecture and prepare the model to run on a particular device. We can bundle all the additional required artifacts, such as vocabulary files or label maps, with the model in a single archive file.","__index_level_0__":4365}
+{"text":"When we need to deploy models that have complex initialization processes or that originated in third-party libraries, we design custom handlers in TorchServe. These let us load any model, from any library, with any required process. The following snippet shows a simple handler that can serve Hugging Face BERT models on any SageMaker hosting endpoint instance.","__index_level_0__":4366}
+{"text":"```python\nimport torch\nimport torch.neuron\nfrom ts.torch_handler.base_handler import BaseHandler\nimport transformers\nfrom transformers import AutoModelForSequenceClassification,AutoTokenizer","__index_level_0__":4367}
+{"text":"class MyModelHandler(BaseHandler):\n    def initialize(self, context):\n        self.manifest = ctx.manifest\n        properties = ctx.system_properties\n        model_dir = properties.get(\"model_dir\")\n        serialized_file = self.manifest[\"model\"][\"serializedFile\"]\n        model_pt_path = os.path.join(model_dir, serialized_file)","__index_level_0__":4368}
+{"text":"\n        self.tokenizer = AutoTokenizer.from_pretrained(\n                model_dir, do_lower_case=True\n            )\n        self.model = AutoModelForSequenceClassification.from_pretrained(\n                    model_dir\n                )","__index_level_0__":4369}
+{"text":"    def preprocess(self, data):","__index_level_0__":4370}
+{"text":"        input_text = data.get(\"data\")\n        if input_text is None:\n            input_text = data.get(\"body\")\n            inputs = self.tokenizer.encode_plus(input_text, max_length=int(max_length), pad_to_max_length=True, add_special_tokens=True, return_tensors='pt')\n        return inputs","__index_level_0__":4371}
+{"text":"    def inference(self,inputs):\n        predictions = self.model(**inputs)\n        return predictions","__index_level_0__":4372}
+{"text":"    def postprocess(self, output):\n        return output\n```","__index_level_0__":4373}
+{"text":"### Batching","__index_level_0__":4374}
+{"text":"Hardware accelerators are optimized for parallelism, and batching \u2014 feeding a model multiple inputs in a single step \u2014 helps saturate all available capacity, typically resulting in higher throughputs. Excessively high batch sizes, however, can increase latency with minimal improvement in throughputs. Experimenting with different batch sizes helps us identify the sweet spot for our models and hardware accelerator. We run experiments to determine the best batch size for our model size, payload size, and request traffic patterns.","__index_level_0__":4375}
+{"text":"The Neuron compiler now supports variable batch sizes. Previously, tracing a model hardcoded the predefined batch size, so we had to pad our data, which can waste compute, slow throughputs, and exacerbate latency. Inferentia is optimized to maximize throughput for small batches, reducing latency by easing the load on the system.","__index_level_0__":4376}
+{"text":"### Parallelism","__index_level_0__":4377}
+{"text":"Model parallelism on multi-cores also improves throughput and latency, which is crucial for our heavy workloads. Each Inferentia chip contains four NeuronCores that can either run separate models simultaneously or form a pipeline to stream a single model. In our use case, the data parallel configuration offers the highest throughput at the lowest cost, because it scales out concurrent processing requests.","__index_level_0__":4378}
+{"text":"Data Parallel:","__index_level_0__":4379}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/amazon-ads-case-study\/data-parallel.png\" width=\"100%\">\n<\/p>","__index_level_0__":4380}
+{"text":"Model Parallel:","__index_level_0__":4381}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/amazon-ads-case-study\/model-parallel.png\" width=\"100%\">\n<\/p>","__index_level_0__":4382}
+{"text":"### Monitoring","__index_level_0__":4383}
+{"text":"It is critical that we monitor the accuracy of our inferences in production. Models that initially make good predictions can eventually degrade in deployment as they are exposed to a wider variety of data. This phenomenon, called model drift, usually occurs when the input data distributions or the prediction targets change.","__index_level_0__":4384}
+{"text":"We use [SageMaker Model Monitor](https:\/\/aws.amazon.com\/sagemaker\/model-monitor\/) to track parity between the training and production data. Model Monitor notifies us when predictions in production begin to deviate from the training and validation results. Thanks to this early warning, we can restore accuracy \u2014 by retraining the model if necessary \u2014 before our advertisers are affected. To track performance in real time, Model Monitor also sends us metrics about the quality of predictions, such as accuracy, F-scores, and the distribution of the predicted classes.","__index_level_0__":4385}
+{"text":"To determine if our application needs to scale, TorchServe logs resource utilization metrics for the CPU, Memory, and Disk at regular intervals; it also records the number of requests received versus the number served. For custom metrics, TorchServe offers a [Metrics API](https:\/\/github.com\/pytorch\/serve\/blob\/master\/docs\/metrics_api.md).","__index_level_0__":4386}
+{"text":"### A rewarding result","__index_level_0__":4387}
+{"text":"Our DL models, developed in PyTorch and deployed on Inferentia, sped up our ads analysis while cutting costs. Starting with our first explorations in DL, programming in PyTorch felt natural. Its user-friendly features helped smooth the course from our early experiments to the deployment of our multimodal ensembles. PyTorch lets us prototype and build models quickly, which is vital as our advertising service evolves and expands. For an added benefit, PyTorch works seamlessly with Inferentia and our AWS ML stack. We look forward to building more use cases with PyTorch, so we can continue to serve our clients accurate, real-time results.\n \n source: https:\/\/pytorch.org\/blog\/amazon-ads-case-study\/ \n category: pytorch blogs","__index_level_0__":4388}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch feature classification changes'\nauthor: Team PyTorch\n---","__index_level_0__":4389}
+{"text":"Traditionally features in PyTorch were classified as either stable or experimental with an implicit third option of testing bleeding edge features by building master or through installing nightly builds (available via prebuilt whls). This has, in a few cases, caused some confusion around the level of readiness, commitment to the feature and backward compatibility that can be expected from a user perspective. Moving forward, we\u2019d like to better classify the 3 types of features as well as define explicitly here what each mean from a user perspective.","__index_level_0__":4390}
+{"text":"# New Feature Designations","__index_level_0__":4391}
+{"text":"We will continue to have three designations for features but, as mentioned, with a few changes: Stable, Beta (previously Experimental) and Prototype (previously Nightlies). Below is a brief description of each and a comment on the backward compatibility expected:","__index_level_0__":4392}
+{"text":"## Stable\nNothing changes here. A stable feature means that the user value-add is or has been proven, the API isn\u2019t expected to change, the feature is performant and all documentation exists to support end user adoption.","__index_level_0__":4393}
+{"text":"*Level of commitment*: We expect to maintain these features long term and generally there should be no major performance limitations, gaps in documentation and we also expect to maintain backwards compatibility (although breaking changes can happen and notice will be given one release ahead of time).","__index_level_0__":4394}
+{"text":"## Beta\nWe previously called these features \u2018Experimental\u2019 and we found that this created confusion amongst some of the users. In the case of a Beta level features, the value add, similar to a Stable feature, has been proven (e.g. pruning is a commonly used technique for reducing the number of parameters in NN models, independent of the implementation details of our particular choices) and the feature generally works and is documented. This feature is tagged as Beta because the API may change based on user feedback, because the performance needs to improve or because coverage across operators is not yet complete.","__index_level_0__":4395}
+{"text":"*Level of commitment*: We are committing to seeing the feature through to the Stable classification. We are however not committing to Backwards Compatibility. Users can depend on us providing a solution for problems in this area going forward, but the APIs and performance characteristics of this feature may change.","__index_level_0__":4396}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/install-matrix.png\" width=\"100%\">\n<\/div>","__index_level_0__":4397}
+{"text":"## Prototype\nPreviously these were features that were known about by developers who paid close attention to RFCs and to features that land in master. In this case the feature is not available as part of binary distributions like PyPI or Conda (except maybe behind run-time flags), but we would like to get high bandwidth partner feedback ahead of a real release in order to gauge utility and any changes we need to make to the UX. To test these kinds of features we would, depending on the feature, recommend building from master or using the nightly whls that are made available on pytorch.org. For each prototype feature, a pointer to draft docs or other instructions will be provided.","__index_level_0__":4398}
+{"text":"*Level of commitment*: We are committing to gathering high bandwidth feedback only. Based on this feedback and potential further engagement between community members, we as a community will decide if we want to upgrade the level of commitment or to fail fast. Additionally, while some of these features might be more speculative (e.g. new Frontend APIs), others have obvious utility (e.g. model optimization) but may be in a state where gathering feedback outside of high bandwidth channels is not practical, e.g. the feature may be in an earlier state, may be moving fast (PRs are landing too quickly to catch a major release) and\/or generally active development is underway.","__index_level_0__":4399}
+{"text":"# What changes for current features?","__index_level_0__":4400}
+{"text":"First and foremost, you can find these designations on [pytorch.org\/docs](http:\/\/pytorch.org\/docs). We will also be linking any early stage features here for clarity.","__index_level_0__":4401}
+{"text":"Additionally, the following features will be reclassified under this new rubric:","__index_level_0__":4402}
+{"text":"1. [High Level Autograd APIs](https:\/\/pytorch.org\/docs\/stable\/autograd.html#functional-higher-level-api): Beta (was Experimental)\n2. [Eager Mode Quantization](https:\/\/pytorch.org\/docs\/stable\/quantization.html): Beta (was Experimental)\n3. [Named Tensors](https:\/\/pytorch.org\/docs\/stable\/named_tensor.html): Prototype (was Experimental)\n4. [TorchScript\/RPC](https:\/\/pytorch.org\/docs\/stable\/rpc.html#rpc): Prototype (was Experimental)\n5. [Channels Last Memory Layout](https:\/\/pytorch.org\/docs\/stable\/tensor_attributes.html#torch-memory-format): Beta (was Experimental)\n6. [Custom C++ Classes](https:\/\/pytorch.org\/docs\/stable\/jit.html?highlight=experimental): Beta (was Experimental)\n7. [PyTorch Mobile](https:\/\/pytorch.org\/mobile\/home\/): Beta (was Experimental)\n8. [Java Bindings](https:\/\/pytorch.org\/docs\/stable\/packages.html#): Beta (was Experimental)\n9. [Torch.Sparse](https:\/\/pytorch.org\/docs\/stable\/sparse.html?highlight=experimental#): Beta (was Experimental)","__index_level_0__":4403}
+{"text":"Joe, Greg, Woo & Jessica\n \n source: https:\/\/pytorch.org\/blog\/pytorch-feature-classification-changes\/ \n category: pytorch blogs","__index_level_0__":4405}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Introducing TorchRec, a library for modern production recommendation systems'\nauthor: Meta AI - Donny Greenberg, Colin Taylor, Dmytro Ivchenko, Xing Liu, Anirudh Sudarshan \nfeatured-img: ''\n---","__index_level_0__":4406}
+{"text":"We are excited to announce [TorchRec](https:\/\/github.com\/pytorch\/torchrec), a PyTorch domain library for Recommendation Systems. This new library provides common sparsity and parallelism primitives, enabling researchers to build state-of-the-art personalization models and deploy them in production.","__index_level_0__":4407}
+{"text":"<p align=\"left\">\n  <img src=\"\/assets\/images\/introducing-torchrec\/torchrec_lockup.png\" width=\"40%\">\n<\/p>","__index_level_0__":4408}
+{"text":"## How did we get here?\nRecommendation Systems (RecSys) comprise a large footprint of production-deployed AI today, but you might not know it from looking at Github. Unlike areas like Vision and NLP, much of the ongoing innovation and development in RecSys is behind closed company doors. For academic researchers studying these techniques or companies building personalized user experiences, the field is far from democratized. Further, RecSys as an area is largely defined by learning models over sparse and\/or sequential events, which has large overlaps with other areas of AI. Many of the techniques are transferable, particularly for scaling and distributed execution. A large portion of the global investment in AI is in developing these RecSys techniques, so cordoning them off blocks this investment from flowing into the broader AI field.","__index_level_0__":4409}
+{"text":"By mid-2020, the PyTorch team received a lot of feedback that there hasn't been a large-scale  production-quality recommender systems package in the open-source PyTorch ecosystem. While we were trying to find a good answer, a group of engineers at Meta wanted to contribute Meta\u2019s production RecSys stack as a PyTorch domain library, with a strong commitment to growing an ecosystem around it. This seemed like a good idea that benefits researchers and companies across the RecSys domain. So, starting from Meta\u2019s stack, we began modularizing and designing a fully-scalable codebase that is adaptable for diverse recommendation use-cases. Our goal was to extract the key building blocks from across Meta\u2019s software stack to simultaneously enable creative exploration and scale. After nearly two years, a battery of benchmarks, migrations, and testing across Meta, we\u2019re excited to finally embark on this journey together with the RecSys community. We want this package to open a dialogue and collaboration across the RecSys industry, starting with Meta as the first sizable contributor.","__index_level_0__":4410}
+{"text":"\n## Introducing TorchRec\nTorchRec includes a scalable low-level modeling foundation alongside rich batteries-included modules. We initially target \u201ctwo-tower\u201d ([[1]], [[2]]) architectures that have separate submodules to learn representations of candidate items and the query or context. Input signals can be a mix of floating point \u201cdense\u201d features or high-cardinality categorical \u201csparse\u201d features that require large embedding tables to be trained. Efficient training of such architectures involves combining data parallelism that replicates the \u201cdense\u201d part of computation and model parallelism that  partitions large embedding tables across many nodes.","__index_level_0__":4411}
+{"text":"In particular, the library includes:\n- Modeling primitives, such as embedding bags and jagged tensors, that enable easy authoring of large, performant multi-device\/multi-node models using hybrid data-parallelism and model-parallelism.\n- Optimized RecSys kernels powered by [FBGEMM](https:\/\/github.com\/pytorch\/FBGEMM) , including support for sparse and quantized operations.\n- A sharder which can partition embedding tables with a variety of different strategies including data-parallel, table-wise, row-wise, table-wise-row-wise, and column-wise sharding.\n- A planner which can automatically generate optimized sharding plans for models.\n- Pipelining to overlap dataloading device transfer (copy to GPU), inter-device communications (input_dist), and computation (forward, backward) for increased performance.\n- GPU inference support.\n- Common modules for RecSys, such as models and public datasets (Criteo & Movielens).","__index_level_0__":4412}
+{"text":"To showcase the flexibility of this tooling, let\u2019s look at the following code snippet, pulled from our DLRM Event Prediction example:\n```python\n# Specify the sparse embedding layers\neb_configs = [\n   EmbeddingBagConfig(\n       name=f\"t_{feature_name}\",\n       embedding_dim=64,\n       num_embeddings=100_000,\n       feature_names=[feature_name],\n   )\n   for feature_idx, feature_name in enumerate(DEFAULT_CAT_NAMES)\n]","__index_level_0__":4413}
+{"text":"# Import and instantiate the model with the embedding configuration\n# The \"meta\" device indicates lazy instantiation, with no memory allocated\ntrain_model = DLRM(\n   embedding_bag_collection=EmbeddingBagCollection(\n       tables=eb_configs, device=torch.device(\"meta\")\n   ),\n   dense_in_features=len(DEFAULT_INT_NAMES),\n   dense_arch_layer_sizes=[512, 256, 64],\n   over_arch_layer_sizes=[512, 512, 256, 1],\n   dense_device=device,\n)","__index_level_0__":4414}
+{"text":"# Distribute the model over many devices, just as one would with DDP.\nmodel = DistributedModelParallel(\n   module=train_model,\n   device=device,\n)","__index_level_0__":4415}
+{"text":"optimizer = torch.optim.SGD(params, lr=args.learning_rate)\n# Optimize the model in a standard loop just as you would any other model!\n# Or, you can use the pipeliner to synchronize communication and compute\nfor epoch in range(epochs):\n   # Train\n```","__index_level_0__":4416}
+{"text":"\n## Scaling Performance\nTorchRec has state-of-the-art infrastructure for scaled Recommendations AI, powering some of the largest models at Meta. It was used to train a 1.25 trillion parameter model, pushed to production in January, and a 3 trillion parameter model which will be in production soon. This should be a good indication that PyTorch is fully capable of the largest scale RecSys problems in industry. We\u2019ve heard from many in the community that sharded embeddings are a pain point. TorchRec cleanly addresses that. Unfortunately it is challenging to provide large-scale benchmarks with public datasets, as most open-source benchmarks are too small to show performance at scale.","__index_level_0__":4417}
+{"text":"\n## Looking ahead\nOpen-source and open-technology have universal benefits. Meta is seeding the PyTorch community with a state-of-the-art RecSys package, with the hope that many join in on building it forward, enabling new research and helping many companies. The team behind TorchRec plan to continue this program indefinitely, building up TorchRec to meet the needs of the RecSys community, to welcome new contributors, and to continue to power personalization at Meta. We\u2019re excited to begin this journey and look forward to contributions, ideas, and feedback!","__index_level_0__":4418}
+{"text":"\n## References\n[[1]] Sampling-Bias-Corrected Neural Modeling for Large Corpus Item Recommendations","__index_level_0__":4419}
+{"text":"[[2]] DLRM: An advanced, open source deep learning recommendation model","__index_level_0__":4420}
+{"text":"\n[1]: https:\/\/research.google\/pubs\/pub48840\/\n[2]: https:\/\/ai.facebook.com\/blog\/dlrm-an-advanced-open-source-deep-learning-recommendation-model\/\n \n source: https:\/\/pytorch.org\/blog\/introducing-torchrec\/ \n category: pytorch blogs","__index_level_0__":4421}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Scaling PyTorch models on Cloud TPUs with FSDP\"\nauthor: Ronghang Hu, Vaibhav Singh, Jack Cao, Milad Mohammadi, Yeounoh Chung, Shauheen Zahirazami, Ross Girshick\nfeatured-img: \"\/assets\/images\/scaling-pytorch-models-on-cloud-tpus-with-fsdp.jpg\"\n---","__index_level_0__":4422}
+{"text":"## Introduction","__index_level_0__":4423}
+{"text":"The research community has witnessed a lot of successes with large models across NLP, computer vision, and other domains in recent years. Many of these successes were enabled by Cloud TPUs -- which are powerful hardware for distributed training. To support TPUs in PyTorch, the PyTorch\/XLA library provides a backend for XLA devices (most notably TPUs) and lays the groundwork for scaling large PyTorch models on TPUs.","__index_level_0__":4424}
+{"text":"However, most existing modeling scaling tools in the PyTorch ecosystem assume GPU (or CPU) devices, often depend on specific features in CUDA, and do not work directly on TPUs. The lack of scaling tools makes it challenging to build large models that cannot fit into the memory of a single TPU chip.","__index_level_0__":4425}
+{"text":"To support model scaling on TPUs, we implemented the widely-adopted [Fully Sharded Data Parallel (FSDP)](https:\/\/engineering.fb.com\/2021\/07\/15\/open-source\/fsdp\/) algorithm for XLA devices as part of the PyTorch\/XLA 1.12 release. We provide an FSDP interface with a similar high-level design to the CUDA-based PyTorch FSDP class while also handling several restrictions in XLA (see Design Notes below for more details). This FSDP interface allowed us to easily build models with e.g. 10B+ parameters on TPUs and has enabled many research explorations.","__index_level_0__":4426}
+{"text":"## Using Fully Sharded Data Parallel (FSDP) in PyTorch\/XLA","__index_level_0__":4427}
+{"text":"We provide a wrapper class `XlaFullyShardedDataParallel` over a given PyTorch model to shard its parameters across data-parallel workers. An example usage is as follows:","__index_level_0__":4428}
+{"text":"```python\nimport torch\nimport torch_xla.core.xla_model as xm\nfrom torch_xla.distributed.fsdp import XlaFullyShardedDataParallel as FSDP","__index_level_0__":4429}
+{"text":"model = FSDP(my_module)\noptim = torch.optim.Adam(model.parameters(), lr=0.0001)\noutput = model(x, y)\nloss = output.sum()\nloss.backward()\noptim.step()\n```","__index_level_0__":4430}
+{"text":"Wrapping an `nn.Module` instance with `XlaFullyShardedDataParallel` enables the [ZeRO-2](https:\/\/arxiv.org\/abs\/1910.02054) algorithm on it, where its gradients and the optimizer states are sharded for the entire training process. During its forward and backward passes, the full parameters of the wrapped module are first reconstructed from their corresponding shards for computation.","__index_level_0__":4431}
+{"text":"**Nested FSDP** wrapping can be used to further save memory. This allows the model to store only the full parameters of one individual layer at any given time. For nested FSDP, one should first wrap its individual submodules with an inner FSDP before wrapping the base model with an outer FSDP. This allows the model to store only the full parameters of one individual layer at any given time. And having an outer wrapper ensures to handle any leftover parameters, corresponding to the [ZeRO-3](https:\/\/arxiv.org\/abs\/1910.02054) algorithm. Nested FSDP wrapping can be applied at any depth of submodules and there can be more than 2 layers of nesting.","__index_level_0__":4432}
+{"text":"**Model checkpoint saving and loading** for models and optimizers can be done like before by saving and loading their `.state_dict()`. Meanwhile, each training process should save its own checkpoint file of the sharded model parameters and optimizer states, and load the checkpoint file for the corresponding rank when resuming (regardless of ZeRO-2 or ZeRO-3, i.e. nested wrapping or not). A command line tool and a Python interface are provided to consolidate the sharded model checkpoint files together into a full\/unshareded model checkpoint file.","__index_level_0__":4433}
+{"text":"[**Gradient checkpointing**](https:\/\/spell.ml\/blog\/gradient-checkpointing-pytorch-YGypLBAAACEAefHs) (also referred to as \"activation checkpointing\" or \"rematerialization\") is another common technique for model scaling and can be used in conjunction with FSDP. We provide `checkpoint_module`, a wrapper function over a given `nn.Module` instance for gradient checkpointing (based on `torch_xla.utils.checkpoint.checkpoint`).","__index_level_0__":4434}
+{"text":"The MNIST and ImageNet examples below provide illustrative usages of (plain or nested) FSDP, saving and consolidation of model checkpoints, as well as gradient checkpointing.","__index_level_0__":4435}
+{"text":"## Starting examples of FSDP in PyTorch\/XLA","__index_level_0__":4436}
+{"text":"### Training MNIST and ImageNet with FSDP","__index_level_0__":4437}
+{"text":"MNIST and ImageNet classification can often be used as starting points to build more complicated deep learning models. We provide the following FSDP examples on these two datasets:","__index_level_0__":4438}
+{"text":"- MNIST: [test\/test_train_mp_mnist_fsdp_with_ckpt.py](https:\/\/github.com\/pytorch\/xla\/blob\/master\/test\/test_train_mp_mnist_fsdp_with_ckpt.py) (it also illustrates checkpoint saving and consolidation)\n- ImageNet: [test\/test_train_mp_imagenet_fsdp.py](https:\/\/github.com\/pytorch\/xla\/blob\/master\/test\/test_train_mp_imagenet_fsdp.py)","__index_level_0__":4439}
+{"text":"A comparison of them with the vanilla data-parallel examples of [MNIST](https:\/\/github.com\/pytorch\/xla\/blob\/master\/test\/test_train_mp_mnist.py) and [ImageNet](https:\/\/github.com\/pytorch\/xla\/blob\/master\/test\/test_train_mp_imagenet.py) illustrates how to adapt a training script to use FSDP. A major distinction to keep in mind is that when stepping the optimizer on an FSDP-wrapped model, one should directly call `optimizer.step()` instead of `xm.optimizer_step(optimizer)`. The latter reduces the gradients across ranks, which is not what we need in FSDP, where the gradients are already reduced and sharded (from a reduce-scatter op in its backward pass).","__index_level_0__":4440}
+{"text":"#### Installation","__index_level_0__":4441}
+{"text":"FSDP is available from the PyTorch\/XLA 1.12 and newer nightly releases. Please refer to [https:\/\/github.com\/pytorch\/xla#-available-images-and-wheels](https:\/\/github.com\/pytorch\/xla#-available-images-and-wheels) for a guide on installation as well as Cloud TPU allocation. Then clone PyTorch\/XLA repo on a TPU VM as follows","__index_level_0__":4442}
+{"text":"```python\nmkdir -p ~\/pytorch && cd ~\/pytorch\ngit clone --recursive https:\/\/github.com\/pytorch\/xla.git\ncd ~\/\n```","__index_level_0__":4443}
+{"text":"#### Train MNIST on v3-8 TPU","__index_level_0__":4444}
+{"text":"It gets around 98.9 accuracy for 2 epochs:","__index_level_0__":4445}
+{"text":"```python\npython3 ~\/pytorch\/xla\/test\/test_train_mp_mnist_fsdp_with_ckpt.py \\\n  --batch_size 16 --drop_last --num_epochs 2 \\\n  --use_nested_fsdp\n```","__index_level_0__":4446}
+{"text":"The script above automatically tests consolidation of the sharded model checkpoints at the end. You can also manually consolidate the sharded checkpoint files via","__index_level_0__":4447}
+{"text":"```python\npython3 -m torch_xla.distributed.fsdp.consolidate_sharded_ckpts \\\n  --ckpt_prefix \/tmp\/mnist-fsdp\/final_ckpt \\\n  --ckpt_suffix \"_rank-*-of-*.pth\"\n```","__index_level_0__":4448}
+{"text":"#### Train ImageNet with ResNet-50 on v3-8 TPU","__index_level_0__":4449}
+{"text":"It gets around 75.9 accuracy for 100 epochs, same as what one would get without using FSDP; download and preprocess the [ImageNet-1k](https:\/\/github.com\/pytorch\/examples\/tree\/master\/imagenet#requirements) dataset to `\/datasets\/imagenet-1k`:","__index_level_0__":4450}
+{"text":"```python\npython3 ~\/pytorch\/xla\/test\/test_train_mp_imagenet_fsdp.py \\\n  --datadir \/datasets\/imagenet-1k --drop_last \\\n  --model resnet50 --test_set_batch_size 64 --eval_interval 10 \\\n  --lr 0.4 --batch_size 128 --num_warmup_epochs 5 \\\n  --lr_scheduler_divide_every_n_epochs 30 --lr_scheduler_divisor 10 \\\n  --num_epochs 100 \\\n  --use_nested_fsdp\n```","__index_level_0__":4451}
+{"text":"You can also explore other options in these two examples, such as `--use_gradient_checkpointing` to apply gradient checkpointing (i.e. activation checkpointing) on the ResNet blocks, or `--compute_dtype bfloat16` to perform forward and backward passes in bfloat16 precision.","__index_level_0__":4452}
+{"text":"### Examples on large-scale models","__index_level_0__":4453}
+{"text":"When building large models on TPUs, we often need to be aware of the memory constraints (e.g. 16 GB per core in TPU v3 and 32 GB per chip in TPU v4). For large models that cannot fit into a single TPU memory or the host CPU memory, one should use nested FSDP to implement the ZeRO-3 algorithm interleave submodule construction with inner FSDP wrapping, so that the full model never needs to be stored in memory during construction.","__index_level_0__":4454}
+{"text":"We illustrate these cases in [https:\/\/github.com\/ronghanghu\/ptxla_scaling_examples](https:\/\/github.com\/ronghanghu\/ptxla_scaling_examples), which provides examples of training a Vision Transformer (ViT) model with 10B+ parameters on a TPU v3 pod (with 128 cores) as well as other cases.","__index_level_0__":4455}
+{"text":"### Design Notes","__index_level_0__":4456}
+{"text":"One might wonder why we need to develop a separate FSDP class in PyTorch\/XLA instead of directly reusing [PyTorch's FSDP class](https:\/\/pytorch.org\/docs\/stable\/fsdp.html) or extending it to the XLA backend. The main motivation behind a separate FSDP class in PyTorch\/XLA is that the native PyTorch's FSDP class heavily relies on CUDA features that are not supported by XLA devices, while XLA also has several unique characteristics that need special handling. These distinctions require a different implementation of FSDP that would be much easier to build in a separate class.","__index_level_0__":4457}
+{"text":"#### Changes in API calls\nOne prominent distinction is that the native PyTorch FSDP is built upon separate CUDA streams for asynchronous execution in eager mode, while PyTorch\/XLA runs in lazy mode and also does not support streams. In addition, TPU requires that all devices homogeneously run the same program. As a result, in the PyTorch\/XLA FSDP implementation, CUDA calls and per-process heterogeneity need to be replaced by XLA APIs and alternative homogeneous implementations.","__index_level_0__":4458}
+{"text":"#### Tensor Storage Handling","__index_level_0__":4459}
+{"text":"Another prominent distinction is how to free a tensor's storage, which is much harder in XLA than in CUDA. To implement ZeRO-3, one needs to free the storage of full parameters after a module's forward pass, so that the next module can reuse this memory buffer for subsequent computation. PyTorch's FSPD accomplishes this on CUDA by freeing the actual storage of a parameter `p` via `p.data.storage().resize_(0)`. However, XLA tensors do not have this `.storage()` handle given that the XLA HLO IRs are completely functional and do not provide any ops to deallocate a tensor or resize its storage. Below the PyTorch interface, only the XLA compiler can decide when to free a TPU device memory corresponding to an XLA tensor, and a prerequisite is that the memory can only be released when the tensor object gets deallocated in Python -- which cannot happen in FSDP because these parameter tensors are referenced as module attributes and also saved by PyTorch autograd for the backward pass.","__index_level_0__":4460}
+{"text":"Our solution to this issue is to split a tensor's value properties from its autograd Variable properties, and to free a `nn.Parameter` tensor by setting its `.data` attribute to a dummy scalar of size 1. This way the actual data tensor for the full parameter gets dereferenced in Python so that XLA can recycle its memory for other computation, while autograd can still trace the base `nn.Parameter` as a weak reference to the parameter data. To get this to work, one also needs to handle views over the parameters as views in PyTorch also hold references to its actual data (this required fixing a shape-related issue with views in PyTorch\/XLA).","__index_level_0__":4461}
+{"text":"#### Working with XLA compiler","__index_level_0__":4462}
+{"text":"The solution above should be enough to free full parameters if the XLA compiler faithfully preserves the operations and their execution order in our PyTorch program. But there is another problem -- XLA attempts to optimize the program to speed up its execution by applying common subexpression elimination (CSE) to the HLO IRs. In a naive implementation of FSDP, the XLA compiler typically eliminates the 2nd all-gather in the backward pass to reconstruct the full parameters when it sees that it is a repeated computation from the forward pass, and directly holds and reuses the full parameters we want to free up after the forward pass. To guard against this undesired compiler behavior, we introduced the [optimization barrier op](https:\/\/www.tensorflow.org\/xla\/operation_semantics#optimizationbarrier) into PyTorch\/XLA and used it to stop eliminating the 2nd all-gather. This optimization barrier is also applied to a similar case of gradient checkpointing to prevent CSE between forward and backward passes that could eliminate the rematerialization.","__index_level_0__":4463}
+{"text":"In the future, if the distinctions between CUDA and XLA become not as prominent as mentioned above, it could be worth considering a merge of the PyTorch\/XLA FSDP with the native PyTorch FSDP to have a unified interface.","__index_level_0__":4464}
+{"text":"## Acknowledgments","__index_level_0__":4465}
+{"text":"Thanks to Junmin Hao from AWS for reviewing the PyTorch\/XLA FSDP pull request. Thanks to Brian Hirsh from the Meta PyTorch team for support on the PyTorch core issues. Thanks to Isaack Karanja, Will Cromar, and Blake Hechtman from Google for support on GCP, XLA, and TPU issues.","__index_level_0__":4466}
+{"text":"Thanks to Piotr Dollar, Wan-Yen Lo, Alex Berg, Ryan Mark, Kaiming He, Xinlei Chen, Saining Xie, Shoubhik Debnath, Min Xu, and Vaibhav Aggarwal from Meta FAIR for various TPU-related discussions. \n source: https:\/\/pytorch.org\/blog\/scaling-pytorch-models-on-cloud-tpus-with-fsdp\/ \n category: pytorch blogs","__index_level_0__":4467}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Accelerated Diffusers with PyTorch 2.0\"\nauthor: Pedro Cuenca, Patrick von Platen, Suraj Patil\n---","__index_level_0__":4468}
+{"text":"PyTorch 2.0 has just been released. Its flagship new feature is `torch.compile()`, a one-line code change that promises to automatically improve performance across codebases. We have previously [checked on that promise in Hugging Face Transformers and TIMM models](https:\/\/pytorch.org\/blog\/Accelerating-Hugging-Face-and-TIMM-models\/), and delved deep into its [motivation, architecture and the road ahead](https:\/\/pytorch.org\/get-started\/pytorch-2.0\/).","__index_level_0__":4469}
+{"text":"As important as `torch.compile()` is, there\u2019s much more to PyTorch 2.0. Notably, PyTorch 2.0 incorporates several strategies to accelerate transformer blocks, and these improvements are very relevant for diffusion models too. Techniques such as [FlashAttention](https:\/\/arxiv.org\/abs\/2205.14135), for example, have become very popular in the diffusion community thanks to their ability to significantly speed up Stable Diffusion and achieve larger batch sizes, and they are now part of PyTorch 2.0.","__index_level_0__":4470}
+{"text":"In this post we discuss how attention layers are optimized in PyTorch 2.0 and how these optimization are applied to the popular [\ud83e\udde8 Diffusers library](https:\/\/github.com\/huggingface\/diffusers). We finish with a benchmark that shows how the use of PyTorch 2.0 and Diffusers immediately translates to significant performance improvements across different hardware.","__index_level_0__":4471}
+{"text":"\n## Accelerating transformer blocks","__index_level_0__":4472}
+{"text":"PyTorch 2.0 includes a _scaled dot-product attention_ function as part of `torch.nn.functional`. This function encompasses several implementations that can be applied depending on the inputs and the hardware in use. Before PyTorch 2.0, you had to search for third-party implementations and install separate packages in order to take advantage of memory optimized algorithms, such as FlashAttention. The available implementations are:\n* FlashAttention, from the official [FlashAttention project](https:\/\/github.com\/HazyResearch\/flash-attention). \n* Memory-Efficient Attention, from the [xFormers project](https:\/\/github.com\/facebookresearch\/xformers).\n* A native C++ implementation suitable for non-CUDA devices or when high-precision is required.","__index_level_0__":4473}
+{"text":"All these methods are available by default, and PyTorch will try to select the optimal one automatically through the use of the new scaled dot-product attention (SDPA) API. You can also individually toggle them for finer-grained control, see [the documentation](https:\/\/pytorch.org\/docs\/master\/generated\/torch.nn.functional.scaled_dot_product_attention) for details.","__index_level_0__":4474}
+{"text":"\n## Using scaled dot-product attention in diffusers","__index_level_0__":4475}
+{"text":"The incorporation of Accelerated PyTorch 2.0 Transformer attention to the Diffusers library was achieved through the use of the [`set_attn_processor` method](https:\/\/huggingface.co\/docs\/diffusers\/v0.13.0\/en\/api\/models#diffusers.UNet2DConditionModel.set_attn_processor), which allows for pluggable attention modules to be configured. In this case, a [new attention processor was created](https:\/\/github.com\/huggingface\/diffusers\/blob\/856dad57\/src\/diffusers\/models\/cross_attention.py#L469), which is [enabled by default when PyTorch 2.0 is available](https:\/\/github.com\/huggingface\/diffusers\/blob\/856dad57bb7a9ee13af4a08492e524b0a145a2c5\/src\/diffusers\/models\/cross_attention.py#L105). For clarity, this is how you could enable it manually (but it\u2019s usually not necessary since diffusers will automatically take care of it):","__index_level_0__":4476}
+{"text":"```\nfrom diffusers import StableDiffusionPipeline\nfrom diffusers.models.cross_attention import AttnProcessor2_0","__index_level_0__":4477}
+{"text":"pipe = StableDiffusionPipeline.from_pretrained(\"runwayml\/stable-diffusion-v1-5\")\npipe.to(\"cuda\")\npipe.unet.set_attn_processor(AttnProcessor2_0())","__index_level_0__":4478}
+{"text":"prompt = \"a photo of an astronaut riding a horse on mars\"\nimage = pipe(prompt).images[0]\n```","__index_level_0__":4479}
+{"text":"## Stable Diffusion Benchmark","__index_level_0__":4480}
+{"text":"We ran a number of tests using accelerated dot-product attention from PyTorch 2.0 in Diffusers. We installed diffusers from pip and used nightly versions of PyTorch 2.0, since our tests were performed before the official release. We also used `torch.set_float32_matmul_precision('high')` to enable additional fast matrix multiplication algorithms.","__index_level_0__":4481}
+{"text":"We compared results with the traditional attention implementation in `diffusers` (referred to as `vanilla` below) as well as with the best-performing solution in pre-2.0 PyTorch: PyTorch 1.13.1 with the xFormers package (v0.0.16) installed.","__index_level_0__":4482}
+{"text":"Results were measured without compilation (i.e., no code changes at all), and also with a single call to `torch.compile()` to wrap the UNet module. We did not compile the image decoder because most of the time is spent in the 50 denoising iterations that run UNet evaluations.","__index_level_0__":4483}
+{"text":"\n### Results in float32","__index_level_0__":4484}
+{"text":"![Diffusers Speedup vs xFormers float32](\/assets\/images\/3-16-accelerated-d\/fig1-latest.png){:width=\"100%\"}","__index_level_0__":4485}
+{"text":"The following figures explore performance improvement vs batch size for various representative GPUs belonging to different generations. We collected data for each combination until we reached maximum memory utilization. Vanilla attention runs out of memory earlier than xFormers or PyTorch 2.0, which explains the missing bars for larger batch sizes. Similarly, A100 (we used the 40 GB version) is capable of running batch sizes of 64, but the other GPUs could only reach 32 in our tests.","__index_level_0__":4486}
+{"text":"![Diffusers Inference Speedup vs Vanilla and xFormers Attention (A100, float32)](\/assets\/images\/3-16-accelerated-d\/fig2-latest.png){:width=\"100%\"}","__index_level_0__":4487}
+{"text":"![Diffusers Inference Speedup vs Vanilla and xFormers Attention (3090, float32)](\/assets\/images\/3-16-accelerated-d\/fig3-latest.png){:width=\"100%\"}","__index_level_0__":4488}
+{"text":"![Diffusers Inference Speedup vs Vanilla and xFormers Attention (4090, float32)](\/assets\/images\/3-16-accelerated-d\/fig4-latest.png){:width=\"100%\"}","__index_level_0__":4489}
+{"text":"![Diffusers Inference Speedup vs Vanilla and xFormers Attention (V100, float32)](\/assets\/images\/3-16-accelerated-d\/fig5-latest.png){:width=\"100%\"}","__index_level_0__":4490}
+{"text":"\nWe found very significant performance improvements over vanilla attention across the board, without even using `torch.compile()`. An out of the box installation of PyTorch 2.0 and diffusers yields about 50% speedup on A100 and between 35% and 50% on 4090 GPUs, depending on batch size. Performance improvements are more pronounced for modern CUDA architectures such as Ada (4090) or Ampere (A100), but they are still very significant for older architectures still heavily in use in cloud services.","__index_level_0__":4491}
+{"text":"In addition to faster speeds, the accelerated transformers implementation in PyTorch 2.0 allows much larger batch sizes to be used. A single 40GB A100 GPU runs out of memory with a batch size of 10, and 24 GB high-end consumer cards such as 3090 and 4090 cannot generate 8 images at once. Using PyTorch 2.0 and diffusers we could achieve batch sizes of **48** for 3090 and 4090, and **64** for A100. This is of great significance for cloud services and applications, as they can efficiently process more images at a time.","__index_level_0__":4492}
+{"text":"When compared with PyTorch 1.13.1 + xFormers, the new accelerated transformers implementation is still faster and requires no additional packages or dependencies. In this case we found moderate speedups of up to 2% on datacenter cards such as A100 or T4, but performance was great on the two last generations of consumer cards: up to 20% speed improvement on 3090 and between 10% and 45% on 4090, depending on batch size.","__index_level_0__":4493}
+{"text":"When `torch.compile()` is used, we get an additional performance boost of (typically) 2% and 3% over the previous improvements. As compilation takes some time, this is better geared towards user-facing inference services or training.","__index_level_0__":4494}
+{"text":"\n### Results in float16","__index_level_0__":4495}
+{"text":"![Diffusers Speedup vs xFormers float16](\/assets\/images\/3-16-accelerated-d\/fig6-latest.png){:width=\"100%\"}","__index_level_0__":4496}
+{"text":"![Diffusers Inference Speedup vs Vanilla and xFormers Attention (A100, float16)](\/assets\/images\/3-16-accelerated-d\/fig7-latest.png){:width=\"100%\"}","__index_level_0__":4497}
+{"text":"![Diffusers Inference Speedup vs Vanilla and xFormers Attention (4090, float16)](\/assets\/images\/3-16-accelerated-d\/fig8-latest.png){:width=\"100%\"}","__index_level_0__":4498}
+{"text":"![Diffusers Inference Speedup vs Vanilla and xFormers Attention (3090, float16)](\/assets\/images\/3-16-accelerated-d\/fig9-latest.png){:width=\"100%\"}","__index_level_0__":4499}
+{"text":"When we consider `float16` inference, the performance improvements of the accelerated transformers implementation in PyTorch 2.0 are between 20% and 28% over standard attention, across all the GPUs we tested, except for the 4090, which belongs to the more modern Ada architecture. This GPU benefits from a dramatic performance improvement when using PyTorch 2.0 nightlies. With respect to optimized SDPA vs xFormers, results are usually on par for most GPUs, except again for the 4090. Adding `torch.compile()` to the mix boosts performance a few more percentage points across the board.","__index_level_0__":4500}
+{"text":"\n## Conclusions","__index_level_0__":4501}
+{"text":"PyTorch 2.0 comes with multiple features to optimize the crucial components of the foundational transformer block, and they can be further improved with the use of `torch.compile`. These optimizations lead to significant memory and time improvements for diffusion models, and remove the need for third-party library installations.","__index_level_0__":4502}
+{"text":"To take advantage of these speed and memory improvements all you have to do is upgrade to PyTorch 2.0 and use diffusers >= 0.13.0.","__index_level_0__":4503}
+{"text":"For more examples and in-detail benchmark numbers, please also have a look at the [Diffusers with PyTorch 2.0](https:\/\/huggingface.co\/docs\/diffusers\/v0.13.0\/en\/optimization\/torch2.0) docs.","__index_level_0__":4504}
+{"text":"\n## Acknowledgement","__index_level_0__":4505}
+{"text":"The authors are grateful to the PyTorch team for creating such excellent software. \n source: https:\/\/pytorch.org\/blog\/accelerated-diffusers-pt-20\/ \n category: pytorch blogs","__index_level_0__":4506}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Get Started with PyTorch 2.0 Summary and Overview\"\nauthor: Team PyTorch\nfeatured-img: \"assets\/images\/Pytorch_2_0_Animation_AdobeExpress.gif\"\n---","__index_level_0__":4507}
+{"text":"Introducing PyTorch 2.0, our first steps toward the next generation 2-series release of PyTorch. Over the last few years we have innovated and iterated from PyTorch 1.0 to the most recent 1.13 and moved to the newly formed PyTorch Foundation, part of the Linux Foundation.","__index_level_0__":4508}
+{"text":"To complement the PyTorch 2.0 announcement and conference, we have also posted a comprehensive introduction and technical overview within the Get Started menu at [https:\/\/pytorch.org\/get-started\/pytorch-2.0](https:\/\/pytorch.org\/get-started\/pytorch-2.0).","__index_level_0__":4509}
+{"text":"We also wanted to ensure you had all the information to quickly leverage PyTorch 2.0 in your models so we added the technical requirements, tutorial, user experience, Hugging Face benchmarks and FAQs to get you started today!","__index_level_0__":4510}
+{"text":"Finally we are launching a new \u201cAsk the Engineers: 2.0 Live Q&A\u201d series that allows you to go deeper on a range of topics with PyTorch subject matter experts. We hope this content is helpful for the entire community and level of users\/contributors.","__index_level_0__":4511}
+{"text":"[https:\/\/pytorch.org\/get-started\/pytorch-2.0](https:\/\/pytorch.org\/get-started\/pytorch-2.0)\n \n source: https:\/\/pytorch.org\/blog\/getting-started-with-pytorch-2.0\/ \n category: pytorch blogs","__index_level_0__":4512}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'New Library Releases in PyTorch 1.10, including TorchX, TorchAudio, TorchVision'\nauthor: Team PyTorch \n---","__index_level_0__":4513}
+{"text":"Today, we are announcing a number of new features and improvements to PyTorch libraries, alongside the [PyTorch 1.10 release](https:\/\/pytorch.org\/blog\/pytorch-1.10-released\/). Some highlights include:","__index_level_0__":4514}
+{"text":"Some highlights include:","__index_level_0__":4515}
+{"text":"* **TorchX** - a new SDK for quickly building and deploying ML applications from research & development to production. \n* **TorchAudio** - Added text-to-speech pipeline, self-supervised model support, multi-channel support and MVDR beamforming module, RNN transducer (RNNT) loss function, and batch and filterbank support to `lfilter` function. See the TorchAudio release notes [here](https:\/\/github.com\/pytorch\/audio\/releases).\n* **TorchVision** - Added new RegNet and EfficientNet models, FX based feature extraction added to utilities, two new Automatic Augmentation techniques: Rand Augment and Trivial Augment, and updated training recipes. See the TorchVision release notes [here](https:\/\/github.com\/pytorch\/vision\/releases).","__index_level_0__":4516}
+{"text":"\n# Introducing TorchX\nTorchX is a new SDK for quickly building and deploying ML applications from research & development to production. It offers various builtin components that encode MLOps best practices and make advanced features like distributed training and hyperparameter optimization accessible to all. ","__index_level_0__":4517}
+{"text":"Users can get started with TorchX 0.1 with no added setup cost since it supports popular ML schedulers and pipeline orchestrators that are already widely adopted and deployed in production. No two production environments are the same. To comply with various use cases, TorchX\u2019s core APIs allow tons of customization at well-defined extension points so that even the most unique applications can be serviced without customizing the whole vertical stack.","__index_level_0__":4518}
+{"text":"Read the [documentation](https:\/\/pytorch.org\/torchx) for more details and try out this feature using this quickstart [tutorial](https:\/\/pytorch.org\/torchx\/latest\/quickstart.html). ","__index_level_0__":4519}
+{"text":"\n# TorchAudio 0.10","__index_level_0__":4520}
+{"text":"### [Beta] Text-to-speech pipeline\nTorchAudio now adds the Tacotron2 model and pretrained weights.  It is now possible to build a text-to-speech pipeline with existing vocoder implementations like WaveRNN and Griffin-Lim. Building a TTS pipeline requires matching data processing and pretrained weights, which are often non-trivial to users. So TorchAudio introduces a bundle API so that constructing pipelines for specific pretrained weights is easy. The following example illustrates this.","__index_level_0__":4521}
+{"text":"```python\n>>> import torchaudio\n>>>\n>>> bundle = torchaudio.pipelines.TACOTRON2_WAVERNN_CHAR_LJSPEECH\n>>>\n>>> # Build text processor, Tacotron2 and vocoder (WaveRNN) model\n>>> processor = bundle.get_text_processor()\n>>> tacotron2 = bundle.get_tacotron2()\nDownloading:\n100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 107M\/107M [00:01<00:00, 87.9MB\/s]\n>>> vocoder = bundle.get_vocoder()\nDownloading:\n100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 16.7M\/16.7M [00:00<00:00, 78.1MB\/s]\n>>>\n>>> text = \"Hello World!\"\n>>>\n>>> # Encode text\n>>> input, lengths = processor(text)\n>>>\n>>> # Generate (mel-scale) spectrogram\n>>> specgram, lengths, _ = tacotron2.infer(input, lengths)\n>>>\n>>> # Convert spectrogram to waveform\n>>> waveforms, lengths = vocoder(specgram, lengths)\n>>>\n>>> # Save audio\n>>> torchaudio.save('hello-world.wav', waveforms, vocoder.sample_rate)","__index_level_0__":4522}
+{"text":"For the details of this API please refer to [the documentation](https:\/\/pytorch.org\/audio\/0.10.0\/pipelines#tacotron2-text-to-speech). You can also try this from [the tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/text_to_speech_with_torchaudio.html).","__index_level_0__":4524}
+{"text":"### (Beta) Self-Supervised Model Support \nTorchAudio added HuBERT model architecture and pre-trained weight support for wav2vec 2.0 and HuBERT. HuBERT and wav2vec 2.0 are novel ways for audio representation learning and they yield high accuracy when fine-tuned on downstream tasks. These models can serve as baseline in future research, therefore, TorchAudio is providing a simple way to run the model. Similar to the TTS pipeline, the pretrained weights and associated information, such as expected sample rates and output class labels (for fine-tuned weights) are put together as a bundle, so that they can be used to build pipelines. The following example illustrates this.","__index_level_0__":4525}
+{"text":"```python\n>>> import torchaudio\n>>>\n>>> bundle = torchaudio.pipelines.HUBERT_ASR_LARGE\n>>>\n>>> # Build the model and load pretrained weight.\n>>> model = bundle.get_model()\nDownloading:\n100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1.18G\/1.18G [00:17<00:00, 73.8MB\/s]\n>>> # Check the corresponding labels of the output.\n>>> labels = bundle.get_labels()\n>>> print(labels)\n('<s>', '<pad>', '<\/s>', '<unk>', '|', 'E', 'T', 'A', 'O', 'N', 'I', 'H', 'S', 'R', 'D', 'L', 'U', 'M', 'W', 'C', 'F', 'G', 'Y', 'P', 'B', 'V', 'K', \"'\", 'X', 'J', 'Q', 'Z')\n>>>\n>>> # Infer the label probability distribution\n>>> waveform, sample_rate = torchaudio.load(hello-world.wav')\n>>>\n>>> emissions, _ = model(waveform)\n>>>\n>>> # Pass emission to (hypothetical) decoder\n>>> transcripts = ctc_decode(emissions, labels)\n>>> print(transcripts[0])\nHELLO WORLD","__index_level_0__":4526}
+{"text":"Please refer to the [documentation](https:\/\/pytorch.org\/audio\/0.10.0\/pipelines#wav2vec-2-0-hubert-representation-learning) for more details and try out this feature using this [tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/speech_command_recognition_with_torchaudio_tutorial.html).","__index_level_0__":4528}
+{"text":"### (Beta) Multi-channel support and MVDR beamforming \nFar-field speech recognition is a more challenging task compared to near-field recognition. Multi-channel methods such as beamforming help reduce the noises and enhance the target speech. ","__index_level_0__":4529}
+{"text":"TorchAudio now adds support for differentiable Minimum Variance Distortionless Response (MVDR) beamforming on multi-channel audio using Time-Frequency masks. Researchers can easily assemble it with any multi-channel ASR pipeline. There are three solutions (ref_channel, stv_evd, stv_power) and it supports single-channel and multi-channel (perform average in the method) masks. It provides an online option that recursively updates the parameters for streaming audio. We also provide a tutorial on how to apply MVDR beamforming to the multi-channel audio in the example directory.","__index_level_0__":4530}
+{"text":"```python\n>>> from torchaudio.transforms import MVDR, Spectrogram, InverseSpectrogram\n>>>\n>>> # Load the multi-channel noisy audio\n>>> waveform_mix, sr = torchaudio.load('mix.wav')\n>>> # Initialize the stft and istft modules\n>>> stft = Spectrogram(n_fft=1024, hop_length=256, return_complex=True, power=None)\n>>> istft = InverseSpectrogram(n_fft=1024, hop_length=256)\n>>> # Get the noisy spectrogram\n>>> specgram_mix = stft(waveform_mix)\n>>> # Get the Time-Frequency mask via machine learning models\n>>> mask = model(waveform)\n>>> # Initialize the MVDR module \n>>> mvdr = MVDR(ref_channel=0, solution=\u201dref_channel\u201d, multi_mask=False)\n>>> # Apply MVDR beamforming\n>>> specgram_enhanced = mvdr(specgram_mix, mask)\n>>> # Get the enhanced waveform via iSTFT\n>>> waveform_enhanced = istft(specgram_enhanced, length=waveform.shape[-1])\n```\nPlease refer to the [documentation](https:\/\/pytorch.org\/audio\/0.10.0\/transforms.html#mvdr) for more details and try out this feature using the [MVDR tutorial](https:\/\/github.com\/pytorch\/audio\/blob\/main\/examples\/beamforming\/MVDR_tutorial.ipynb).","__index_level_0__":4531}
+{"text":"### (Beta) RNN Transducer Loss \nThe RNN transducer (RNNT) loss is part of the RNN transducer pipeline, which is a popular architecture for speech recognition tasks. Recently it has gotten attention for being used in a streaming setting, and has also achieved state-of-the-art WER for the LibriSpeech benchmark.","__index_level_0__":4532}
+{"text":"TorchAudio\u2019s loss function supports float16 and float32 logits, has autograd and torchscript support, and can be run on both CPU and GPU, which has a custom CUDA kernel implementation for improved performance. The implementation is consistent with the original loss function in [Sequence Transduction with Recurrent Neural Networks](https:\/\/arxiv.org\/pdf\/1211.3711.pdf), but relies on code from [Alignment Restricted Streaming Recurrent Neural Network Transducer](https:\/\/arxiv.org\/pdf\/2011.03072.pdf). Special thanks to Jay Mahadeokar and Ching-Feng Yeh for their code contributions and guidance.","__index_level_0__":4533}
+{"text":"Please refer to the [documentation](https:\/\/pytorch.org\/audio\/0.10.0\/transforms.html#rnntloss) for more details.","__index_level_0__":4534}
+{"text":"### (Beta) Batch support and filter bank support  \n`torchaudio.functional.lfilter` now supports batch processing and multiple filters.","__index_level_0__":4535}
+{"text":"### (Prototype) Emformer Module\nAutomatic speech recognition (ASR) research and productization have increasingly focused on on-device applications. Towards supporting such efforts, TorchAudio now includes [Emformer](https:\/\/arxiv.org\/abs\/2010.10759), a memory-efficient transformer architecture that has achieved state-of-the-art results on LibriSpeech in low-latency streaming scenarios, as a prototype feature.","__index_level_0__":4536}
+{"text":"Please refer to the [documentation](https:\/\/pytorch.org\/audio\/main\/prototype.html#emformer) for more details.","__index_level_0__":4537}
+{"text":"### GPU Build \nGPU builds that support custom CUDA kernels in TorchAudio, like the one being used for RNN transducer loss, have been added. Following this change, TorchAudio\u2019s binary distribution now includes CPU-only versions and CUDA-enabled versions. To use CUDA-enabled binaries, PyTorch also needs to be compatible with CUDA.","__index_level_0__":4538}
+{"text":"# TorchVision 0.11","__index_level_0__":4539}
+{"text":"### (Stable) New Models\n[RegNet](https:\/\/arxiv.org\/abs\/2003.13678) and [EfficientNet](https:\/\/arxiv.org\/abs\/1905.11946) are two popular architectures that can be scaled to different computational budgets. In this release we include 22 pre-trained weights for their classification variants. The models were trained on ImageNet and the accuracies of the pre-trained models obtained on ImageNet val can be found below (see [#4403](https:\/\/github.com\/pytorch\/vision\/pull\/4403#issuecomment-930381524), [#4530](https:\/\/github.com\/pytorch\/vision\/pull\/4530#issuecomment-933213238) and [#4293](https:\/\/github.com\/pytorch\/vision\/pull\/4293) for more details). ","__index_level_0__":4540}
+{"text":"The models can be used as follows:","__index_level_0__":4541}
+{"text":"```python\nimport torch\nfrom torchvision import models","__index_level_0__":4542}
+{"text":"x = torch.rand(1, 3, 224, 224)","__index_level_0__":4543}
+{"text":"regnet = models.regnet_y_400mf(pretrained=True)\nregnet.eval()\npredictions = regnet(x)","__index_level_0__":4544}
+{"text":"efficientnet = models.efficientnet_b0(pretrained=True)\nefficientnet.eval()\npredictions = efficientnet(x)\n```\nSee the full list of new models on the [torchvision.models](https:\/\/pytorch.org\/vision\/master\/models.html) documentation page.","__index_level_0__":4545}
+{"text":"We would like to thank Ross Wightman and Luke Melas-Kyriazi for contributing the weights of the EfficientNet variants.","__index_level_0__":4546}
+{"text":"### (Beta) FX-based Feature Extraction \nA new Feature Extraction method has been added to our utilities. It uses [torch.fx](https:\/\/pytorch.org\/docs\/stable\/fx.html) and enables us to retrieve the outputs of intermediate layers of a network which is useful for feature extraction and visualization. ","__index_level_0__":4547}
+{"text":"Here is an example of how to use the new utility:","__index_level_0__":4548}
+{"text":"```python\nimport torch\nfrom torchvision.models import resnet50\nfrom torchvision.models.feature_extraction import create_feature_extractor","__index_level_0__":4549}
+{"text":"\nx = torch.rand(1, 3, 224, 224)","__index_level_0__":4550}
+{"text":"model = resnet50()","__index_level_0__":4551}
+{"text":"return_nodes = {\n\"layer4.2.relu_2\": \"layer4\"\n}\nmodel2 = create_feature_extractor(model, return_nodes=return_nodes)\nintermediate_outputs = model2(x)","__index_level_0__":4552}
+{"text":"print(intermediate_outputs['layer4'].shape)\n```\nWe would like to thank Alexander Soare for developing this utility.","__index_level_0__":4553}
+{"text":"### (Stable) New Data Augmentations\nTwo new Automatic Augmentation techniques were added: [RandAugment](https:\/\/arxiv.org\/abs\/1909.13719) and [Trivial Augment](https:\/\/arxiv.org\/abs\/2103.10158). They apply a series of transformations on the original data to enhance them and to boost the performance of the models. The new techniques build on top of the previously added [AutoAugment](https:\/\/github.com\/pytorch\/vision\/pull\/3123)  and focus on simplifying the approach, reducing the search space for the optimal policy and improving the performance gain in terms of accuracy. These techniques enable users to reproduce recipes to achieve state-of-the-art performance on the offered models. Additionally, it enables users to apply these techniques in order to do transfer learning and achieve optimal accuracy on new datasets.","__index_level_0__":4554}
+{"text":"Both methods can be used as drop-in replacement of the AutoAugment technique as seen below:","__index_level_0__":4555}
+{"text":"```python\nfrom torchvision import transforms","__index_level_0__":4556}
+{"text":"t = transforms.RandAugment()\n# t = transforms.TrivialAugmentWide()\ntransformed = t(image)","__index_level_0__":4557}
+{"text":"transform = transforms.Compose([\ntransforms.Resize(256),\ntransforms.RandAugment(), # transforms.TrivialAugmentWide()\ntransforms.ToTensor()])\n```\nRead the [automatic augmentation transforms](https:\/\/pytorch.org\/vision\/master\/transforms.html#automatic-augmentation-transforms) for more details.","__index_level_0__":4558}
+{"text":"We would like to thank Samuel G. M\u00fcller for contributing to Trivial Augment and for his help on refactoring the AA package.","__index_level_0__":4559}
+{"text":"### Updated Training Recipes\nWe have updated our training reference scripts to add support for Exponential Moving Average, Label Smoothing, Learning-Rate Warmup, [Mixup](https:\/\/arxiv.org\/abs\/1710.09412), [Cutmix](https:\/\/arxiv.org\/abs\/1905.04899) and other [SOTA primitives](https:\/\/github.com\/pytorch\/vision\/issues\/3911). The above enabled us to improve the classification Acc@1 of some pre-trained models by over 4 points. A major update of the existing pre-trained weights is expected in the next release.","__index_level_0__":4560}
+{"text":"Thanks for reading. If you\u2019re interested in these updates and want to join the PyTorch community, we encourage you to join [the discussion](https:\/\/discuss.pytorch.org\/) forums and [open GitHub issues](https:\/\/github.com\/pytorch\/pytorch\/issues). To get the latest news from PyTorch, follow us on [Twitter](https:\/\/twitter.com\/PyTorch), [Medium](https:\/\/medium.com\/pytorch), [YouTube](https:\/\/www.youtube.com\/pytorch) and [LinkedIn](https:\/\/www.linkedin.com\/company\/pytorch).  ","__index_level_0__":4561}
+{"text":"Cheers!\nTeam PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.10-new-library-releases\/ \n category: pytorch blogs","__index_level_0__":4562}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Introducing TorchMultimodal - a library for accelerating exploration in Multimodal AI\"\nauthor: Kartikay Khandelwal, Ankita De\nfeatured-img: \"assets\/images\/torch-multimodal-feature-image.png\"\n---","__index_level_0__":4563}
+{"text":"We are announcing TorchMultimodal Beta, a PyTorch domain library for training SoTA multi-task multimodal models at scale. The library provides composable building blocks (modules, transforms, loss functions) to accelerate model development, SoTA model architectures (FLAVA, MDETR, Omnivore) from published research, training and evaluation scripts, as well as notebooks for exploring these models. The library is under active development, and we\u2019d love to hear your feedback! You can find more details on how to get started [here](https:\/\/github.com\/facebookresearch\/multimodal#installation).","__index_level_0__":4564}
+{"text":"## Why TorchMultimodal?","__index_level_0__":4565}
+{"text":"Interest is rising around AI models that understand multiple input types (text, images, videos and audio signals), and optionally use this understanding to generate different forms of outputs (sentences, pictures, videos). Recent work from FAIR such as [FLAVA](https:\/\/arxiv.org\/abs\/2112.04482), [Omnivore](https:\/\/arxiv.org\/pdf\/2201.08377.pdf) and [data2vec](https:\/\/arxiv.org\/abs\/2202.03555) have shown that [multimodal models for understanding](https:\/\/ai.facebook.com\/blog\/advances-in-multimodal-understanding-research-at-meta-ai\/) are competitive with unimodal counterparts, and in some cases are establishing the new state-of-the art. Generative models such as [Make-a-video](https:\/\/ai.facebook.com\/blog\/generative-ai-text-to-video\/) and [Make-a-scene](https:\/\/ai.facebook.com\/blog\/greater-creative-control-for-ai-image-generation\/) are redefining what modern AI systems can do.","__index_level_0__":4566}
+{"text":"As interest in multimodal AI has grown, researchers are looking for tools and libraries to quickly experiment with ideas, and build on top of the latest research in the field. While the PyTorch ecosystem has a rich repository of libraries and frameworks, it\u2019s not always obvious how components from these interoperate with each other, or how they can be stitched together to build SoTA multimodal models.","__index_level_0__":4567}
+{"text":"TorchMultimodal solves this problem by providing:","__index_level_0__":4568}
+{"text":"- **Composable and easy-to-use building blocks** which researchers can use to accelerate model development and experimentation in their own workflows. These are designed to be modular, and can be easily extended to handle new modalities.","__index_level_0__":4569}
+{"text":"- **End-to-end examples for training and evaluating the latest models from research.** These should serve as starting points for ongoing\/future research, as well as examples for using advanced features such as integrating with FSDP and activation checkpointing for scaling up model and batch sizes.","__index_level_0__":4570}
+{"text":"## Introducing TorchMultimodal","__index_level_0__":4571}
+{"text":"TorchMultimodal is a PyTorch domain library for training multi-task multimodal models at scale. In the repository, we provide:","__index_level_0__":4572}
+{"text":"- **[Building Blocks](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/main\/torchmultimodal)**. A collection of modular and composable building blocks like models, fusion layers, loss functions, datasets and utilities. Some examples include:","__index_level_0__":4573}
+{"text":"  - [Contrastive Loss with Temperature](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/4d2236877467ff8f56aa1935dd92d7782751b135\/torchmultimodal\/modules\/losses\/contrastive_loss_with_temperature.py#L145). Commonly used function for training models like CLIP and FLAVA. We also include variants such as [ImageTextContrastiveLoss](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/4d2236877467ff8f56aa1935dd92d7782751b135\/torchmultimodal\/modules\/losses\/albef.py#L14) used in models like ALBEF.","__index_level_0__":4574}
+{"text":"  - [Codebook layers](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/main\/torchmultimodal\/modules\/layers\/codebook.py#L31) which compresses high dimensional data by nearest neighbor lookup in an embedding space and is a vital component of VQVAEs (provided as a [model](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/4d2236877467ff8f56aa1935dd92d7782751b135\/torchmultimodal\/models\/vqvae.py#L26) in the repository).","__index_level_0__":4575}
+{"text":"  - [Shifted-window Attention](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/main\/torchmultimodal\/modules\/encoders\/swin_transformer_3d_encoder.py#L76) window based multi-head self attention which is a vital component of encoders like Swin 3D Transformers.","__index_level_0__":4576}
+{"text":"  - [Components for CLIP.](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/4d2236877467ff8f56aa1935dd92d7782751b135\/torchmultimodal\/models\/clip) A popular model published by OpenAI which has proven to be extremely effective at learning text and image representations.","__index_level_0__":4577}
+{"text":"  - [Multimodal GPT.](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/4d2236877467ff8f56aa1935dd92d7782751b135\/torchmultimodal\/models\/gpt.py) An abstraction that extends OpenAI\u2019s [GPT](https:\/\/cdn.openai.com\/research-covers\/language-unsupervised\/language_understanding_paper.pdf) architecture for multimodal generation when combined with the [generation utility](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/main\/torchmultimodal\/utils\/generate.py#L33).","__index_level_0__":4578}
+{"text":"  - [MultiHeadAttention](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/main\/torchmultimodal\/modules\/layers\/attention.py#L134). A critical component for attention-based models with support for fast auto-regressive decoding.","__index_level_0__":4579}
+{"text":"- **[Examples](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/main\/examples)**. A collection of examples that show how to combine these building blocks with components and common infrastructure (Lightning, TorchMetrics) from across the PyTorch Ecosystem to replicate state-of-the-art models published in literature. We currently provide five examples, which include.","__index_level_0__":4580}
+{"text":"  - [FLAVA](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/main\/examples\/flava) \\[[paper](https:\/\/arxiv.org\/abs\/2112.04482)\\]. Official code for the paper accepted at CVPR, including a tutorial on finetuning FLAVA.","__index_level_0__":4581}
+{"text":"  - [MDETR](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/main\/examples\/mdetr) \\[[paper](https:\/\/arxiv.org\/abs\/2104.12763)\\]. Collaboration with authors from NYU to provide an example which alleviates interoperability pain points in the PyTorch ecosystem, including a [notebook](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/main\/examples\/mdetr\/MDETRTutorial.ipynb) on using MDETR for phrase grounding and visual question answering.","__index_level_0__":4582}
+{"text":"  - [Omnivore](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/main\/examples\/omnivore) \\[[paper](https:\/\/arxiv.org\/abs\/2204.08058)\\]. First example in TorchMultimodal of a model which deals with Video and 3D data, including a [notebook](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/main\/examples\/omnivore\/omnivore_inference_demo.ipynb) for exploring the model.","__index_level_0__":4583}
+{"text":"  - [MUGEN](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/main\/examples\/mugen) \\[[paper](https:\/\/arxiv.org\/abs\/2204.08058)\\]. Foundational work for auto-regressive [generation](https:\/\/colab.research.google.com\/drive\/1C3ZbH_l19g_KqW3CPeX2-8Q2sOUCpmZo?usp=sharing) and [retrieval](https:\/\/colab.research.google.com\/drive\/1gZfz1jsy79CNCK9t2_r43yt3z7v-w4HS?usp=sharing), including demos for text-video generation and retrieval with a large-scale synthetic dataset enriched from OpenAI [coinrun](https:\/\/github.com\/openai\/coinrun).","__index_level_0__":4584}
+{"text":"  - [ALBEF](https:\/\/github.com\/facebookresearch\/multimodal\/tree\/main\/examples\/albef) \\[[paper](https:\/\/arxiv.org\/abs\/2107.07651)\\] Code for the model, including a [notebook](https:\/\/github.com\/facebookresearch\/multimodal\/blob\/main\/examples\/albef\/vqa_with_albef.ipynb) for using this model for Visual Question Answering.","__index_level_0__":4585}
+{"text":"The following code snippet showcases an example usage of several TorchMultimodal components related to CLIP:","__index_level_0__":4586}
+{"text":"# instantiate clip transform\nclip_transform = CLIPTransform()","__index_level_0__":4588}
+{"text":"# pass the transform to your dataset. Here we use coco captions\ndataset = CocoCaptions(root= ..., annFile=..., transforms=clip_transform)\ndataloader = DataLoader(dataset, batch_size=16)","__index_level_0__":4589}
+{"text":"# instantiate model. Here we use clip with vit-L as the image encoder\nmodel= clip_vit_l14()","__index_level_0__":4590}
+{"text":"# define loss and other things needed for training\nclip_loss = ContrastiveLossWithTemperature()\noptim = torch.optim.AdamW(model.parameters(), lr = 1e-5)\nepochs = 1","__index_level_0__":4591}
+{"text":"# write your train loop\nfor _ in range(epochs):\n\tfor batch_idx, batch in enumerate(dataloader):\n\t\timage, text = batch\n\t\timage_embeddings, text_embeddings = model(image, text)\n\t\tloss = contrastive_loss_with_temperature(image_embeddings, text_embeddings)\n\t\tloss.backward()\n\t\toptimizer.step()\n```","__index_level_0__":4592}
+{"text":"Apart from the code, we are also **releasing a tutorial for fine-tuning multimodal foundation models, and a blog post (with code pointers) on how to scale up such models using techniques from PyTorch Distributed (FSDP and activation checkpointing)**. We hope such examples and tutorials will serve to demystify a number of advanced features available in the PyTorch ecosystem.","__index_level_0__":4593}
+{"text":"## What\u2019s Next?","__index_level_0__":4594}
+{"text":"While this is an exciting launch, there\u2019s a lot more to come. The library is under development and we are working on adding some of the exciting developments in the space of diffusion models, and examples to showcase common trends from research. As you explore and use the library, we\u2019d love to hear any feedback you might have! You can find more details on how to get started [here](https:\/\/github.com\/facebookresearch\/multimodal#installation).","__index_level_0__":4595}
+{"text":"The primary contributors and developers of TorchMultimodal include Ankita De, Evan Smothers, Kartikay Khandelwal, Lan Gong, Laurence Rouesnel, Nahiyan Malik, Rafi Ayub and Yosua Michael Maranatha.\n \n source: https:\/\/pytorch.org\/blog\/introducing-torchmultimodal\/ \n category: pytorch blogs","__index_level_0__":4597}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Announcing the Winners of the 2021 PyTorch Annual Hackathon'\nauthor: Team PyTorch\nfeatured-img: 'assets\/images\/social_hackathon21.png'\n---","__index_level_0__":4598}
+{"text":"More than 1,900 people worked hard in this year\u2019s PyTorch Annual Hackathon to create unique tools and applications for PyTorch developers and researchers.","__index_level_0__":4599}
+{"text":"*Notice: None of the projects submitted to the hackathon are associated with or offered by Meta Platforms, Inc.*","__index_level_0__":4600}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/pytorch_hackathon_2021.gif\" width=\"100%\">\n<\/div>","__index_level_0__":4601}
+{"text":"This year, participants could enter their projects into following three categories:\n* **PyTorch Developer Tools**: a tool or library for improving productivity and efficiency for PyTorch researchers and developers.\n* **Web and Mobile Applications Powered by PyTorch**: a web or mobile interface and\/or an embedded device built using PyTorch.\n* **PyTorch Responsible AI Development Tools**: a tool, library, or web\/mobile app to support researchers and developers in creating responsible AI that factors in fairness, security, privacy, and more throughout its entire development process.","__index_level_0__":4602}
+{"text":"The virtual hackathon ran from September 8 through November 2, 2021, with more than 1,900 registered participants from 110 countries, submitting a total of 65 projects. Entrants were judged on their idea\u2019s quality, originality, potential impact, and how well they implemented it. All projects can be viewed [here](https:\/\/pytorch2021.devpost.com\/project-gallery).","__index_level_0__":4603}
+{"text":"Meet the winners of each category below!","__index_level_0__":4604}
+{"text":"## PYTORCH DEVELOPER TOOLS","__index_level_0__":4605}
+{"text":"#### **First Place: [RaNNC](https:\/\/devpost.com\/software\/rannc-rapid-neural-network-connector)**\nRaNNC is a middleware to automate hybrid model\/data parallelism for training very large-scale neural networks capable of training 100 billion parameter models without any manual tuning.","__index_level_0__":4606}
+{"text":"#### **Second Place: [XiTorch](https:\/\/devpost.com\/software\/xitorch-differentiable-scientific-computing-library)**\nXiTorch provides first and higher order gradients of functional routines, such as optimization, rootfinder, and ODE solver. It also contains operations for implicit linear operators (e.g. large matrix that is expressed only by its matrix-vector multiplication) such as symmetric eigen-decomposition, linear solve, and singular value decomposition.","__index_level_0__":4607}
+{"text":"#### **Third Place: [TorchLiberator](https:\/\/devpost.com\/software\/torchliberator-partial-weight-loading)**\nTorchLiberator  automates model surgery, finding the maximum correspondence between weights in two networks.","__index_level_0__":4608}
+{"text":"#### **Honorable Mentions**\n* [PADL](https:\/\/devpost.com\/software\/doch) manages your entire PyTorch work flow with a single python abstraction and a beautiful functional API, so there\u2019s no more complex configuration or juggling preprocessing, postprocessing and forward passes.\n* [PyTree](https:\/\/devpost.com\/software\/pytree) is a PyTorch package for recursive neural networks that provides highly generic recursive neural network implementations as well as efficient batching methods. \n* [IndicLP](https:\/\/devpost.com\/software\/indiclp) makes it easier for developers and researchers to build applications and models in Indian Languages, thus making NLP a more diverse field. ","__index_level_0__":4609}
+{"text":"## WEB\/MOBILE APPLICATIONS POWERED BY PYTORCH","__index_level_0__":4610}
+{"text":"#### **First Place: [PyTorch Driving Guardian](https:\/\/devpost.com\/software\/pytorch-driving-guardian)**\nPyTorch Driving Guardian is a tool that monitors driver alertness, emotional state, and potential blind spots on the road. ","__index_level_0__":4611}
+{"text":"#### **Second Place: [Kronia](https:\/\/devpost.com\/software\/kronia)**\nKronia is an Android mobile app built to maximize the harvest outputs for farmers. ","__index_level_0__":4612}
+{"text":"#### **Third Place: [Heyoh camera for Mac](https:\/\/devpost.com\/software\/heyoh-camera)**\nHeyoh is a Mac virtual camera for Zoom and Meets that augments live video by recognizing hand gestures and smiles and shows animated effects to other video participants. ","__index_level_0__":4613}
+{"text":"#### **Honorable Mentions**\n* [Mamma AI](https:\/\/devpost.com\/software\/mamma-ai) is a tool that helps doctors with the breast cancer identification process by identifying areas likely to have cancer using ultrasonic and x-ray images. \n* [AgingClock](https:\/\/devpost.com\/software\/agingclock) is a tool that predicts biological age first with methylation genome data, then blood test data and eventually with multimodal omics and lifestyle data.\n* [Iris](https:\/\/devpost.com\/software\/iris-7s3yna) is an open source photos platform which is more of an alternative of Google Photos that includes features such as Listing photos, Detecting Categories, Detecting and Classifying Faces from Photos, Detecting and Clustering by Location and Things in Photos.","__index_level_0__":4614}
+{"text":"## PYTORCH RESPONSIBLE AI DEVELOPMENT TOOLS","__index_level_0__":4615}
+{"text":"#### **First Place: [FairWell](https:\/\/devpost.com\/software\/fairwell-a-tool-to-bid-goodbye-to-unknown-ai-biasness)**\nFairWell aims to address model bias on specific groups of people by allowing data scientists to evaluate their dataset and model predictions and take steps to make their datasets more inclusive and their models less biased. ","__index_level_0__":4616}
+{"text":"#### **Second Place: [promp2slip](https:\/\/devpost.com\/software\/promp2slip)**\nPromp2slip is a library that tests the ethics of language models by using natural adversarial texts. ","__index_level_0__":4617}
+{"text":"#### **Third Place: [Phorch](https:\/\/devpost.com\/software\/phorch)**\nPhorch adversarially attacks the data using FIGA (Feature Importance Guided Attack) and creates 3 different attack sets of data based on certain parameters. These features are utilized to implement adversarial training as a defense against FIGA using neural net architecture in PyTorch.","__index_level_0__":4618}
+{"text":"#### **Honorable Mentions**\n* [Greenops](https:\/\/devpost.com\/software\/greenops) helps to measure the footprints of deep learning models at training, testing and evaluating to reduce energy consumption and carbon footprints.\n* [Xaitk-saliency](https:\/\/devpost.com\/software\/xaitk-saliency) is an open-source, explainable AI toolkit for visual saliency algorithm interfaces and implementations, built for analytic and autonomy applications.","__index_level_0__":4619}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/announcing-the-winners-of-the-2021-pytorch-annual-hackathon\/ \n category: pytorch blogs","__index_level_0__":4621}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 1.8 Release, including Compiler and Distributed Training updates, and New Mobile Tutorials'\nauthor: Team PyTorch \n---","__index_level_0__":4622}
+{"text":"We are excited to announce the availability of PyTorch 1.8. This release is composed of more than 3,000 commits since 1.7. It includes major updates and new features for compilation, code optimization, frontend APIs for scientific computing, and AMD ROCm support through binaries that are available via pytorch.org. It also provides improved features for large-scale training for pipeline and model parallelism, and gradient compression. A few of the highlights include:\n1. Support for doing python to python functional transformations via ```torch.fx```;\n2. Added or stabilized APIs to support FFTs (```torch.fft```), Linear Algebra functions (```torch.linalg```), added support for autograd for complex tensors and updates to improve performance for calculating hessians and jacobians; and\n3. Significant updates and improvements to distributed training including: Improved NCCL reliability; Pipeline parallelism support; RPC profiling; and support for communication hooks adding gradient compression.\nSee the full release notes [here](https:\/\/github.com\/pytorch\/pytorch\/releases).","__index_level_0__":4623}
+{"text":"Along with 1.8, we are also releasing major updates to PyTorch libraries including [TorchCSPRNG](https:\/\/github.com\/pytorch\/csprng), [TorchVision](https:\/\/github.com\/pytorch\/vision), [TorchText](https:\/\/github.com\/pytorch\/text) and [TorchAudio](https:\/\/github.com\/pytorch\/audio). For more on the library releases, see the post [here](http:\/\/pytorch.org\/blog\/pytorch-1.8-new-library-releases). As previously noted, features in PyTorch releases are classified as Stable, Beta and Prototype. You can learn more about the definitions in the post [here](https:\/\/pytorch.org\/blog\/pytorch-feature-classification-changes\/). ","__index_level_0__":4624}
+{"text":"# New and Updated APIs\nThe PyTorch 1.8 release brings a host of new and updated API surfaces ranging from additional APIs for NumPy compatibility, also support for ways to improve and scale your code for performance at both inference and training time. Here is a brief summary of the major features coming in this release:","__index_level_0__":4625}
+{"text":"### [Stable] ```Torch.fft``` support for high performance NumPy style FFTs\nAs part of PyTorch\u2019s goal to support scientific computing, we have invested in improving our FFT support and with PyTorch 1.8, we are releasing the ```torch.fft``` module. This module implements the same functions as NumPy\u2019s ```np.fft``` module, but with support for hardware acceleration and autograd.\n* See this [blog post](https:\/\/pytorch.org\/blog\/the-torch.fft-module-accelerated-fast-fourier-transforms-with-autograd-in-pyTorch\/) for more details\n* [Documentation](https:\/\/pytorch.org\/docs\/1.8.0\/fft.html)","__index_level_0__":4626}
+{"text":"### [Beta] Support for NumPy style linear algebra functions via ```torch.linalg```\nThe ```torch.linalg``` module, modeled after NumPy\u2019s [np.linalg](https:\/\/numpy.org\/doc\/stable\/reference\/routines.linalg.html?highlight=linalg#module-numpy.linalg) module, brings NumPy-style support for common linear algebra operations including Cholesky decompositions, determinants, eigenvalues and many others.\n* [Documentation](https:\/\/pytorch.org\/docs\/1.8.0\/linalg.html)","__index_level_0__":4627}
+{"text":"## [Beta] Python code Transformations with FX\nFX allows you to write transformations of the form ```transform(input_module : nn.Module)``` -> ```nn.Module```, where you can feed in a ```Module``` instance and get a transformed ```Module``` instance out of it.","__index_level_0__":4628}
+{"text":"This kind of functionality is applicable in many scenarios. For example, the FX-based Graph Mode Quantization product is releasing as a prototype contemporaneously with FX. Graph Mode Quantization automates the process of quantizing a neural net and does so by leveraging FX\u2019s program capture, analysis and transformation facilities. We are also developing many other transformation products with FX and we are excited to share this powerful toolkit with the community.","__index_level_0__":4629}
+{"text":"Because FX transforms consume and produce nn.Module instances, they can be used within many existing PyTorch workflows. This includes workflows that, for example, train in Python then deploy via TorchScript.","__index_level_0__":4630}
+{"text":"You can read more about FX in the official [documentation](https:\/\/pytorch.org\/docs\/master\/fx.html). You can also find several examples of program transformations implemented using ```torch.fx``` [here](https:\/\/github.com\/pytorch\/examples\/tree\/master\/fx). We are constantly improving FX and invite you to share any feedback you have about the toolkit on the [forums](https:\/\/discuss.pytorch.org\/) or [issue tracker](https:\/\/github.com\/pytorch\/pytorch\/issues).","__index_level_0__":4631}
+{"text":"We\u2019d like to acknowledge [TorchScript](https:\/\/pytorch.org\/docs\/stable\/jit.html) tracing, [Apache MXNet](https:\/\/mxnet.apache.org\/versions\/1.7.0\/) hybridize, and more recently [JAX](https:\/\/github.com\/google\/jax) as influences for program acquisition via tracing. We\u2019d also like to acknowledge [Caffe2](https:\/\/caffe2.ai\/), [JAX](https:\/\/github.com\/google\/jax), and [TensorFlow](https:\/\/www.tensorflow.org\/) as inspiration for the value of simple, directed dataflow graph program representations and transformations over those representations. ","__index_level_0__":4632}
+{"text":"# Distributed Training\nThe PyTorch 1.8 release added a number of new features as well as improvements to reliability and usability. Concretely, support for: [Stable level async error\/timeout handling](https:\/\/pytorch.org\/docs\/stable\/distributed.html?highlight=init_process_group#torch.distributed.init_process_group) was added to improve NCCL reliability; and stable support for [RPC based profiling](https:\/\/pytorch.org\/docs\/stable\/rpc.html). Additionally, we have added support for pipeline parallelism as well as gradient compression through the use of communication hooks in DDP. Details are below:","__index_level_0__":4633}
+{"text":"### [Beta] Pipeline Parallelism\nAs machine learning models continue to grow in size, traditional Distributed DataParallel (DDP) training no longer scales as these models don\u2019t fit on a single GPU device. The new pipeline parallelism feature provides an easy to use PyTorch API to leverage pipeline parallelism as part of your training loop.\n* [RFC](https:\/\/github.com\/pytorch\/pytorch\/issues\/44827)\n* [Documentation](https:\/\/pytorch.org\/docs\/1.8.0\/pipeline.html?highlight=pipeline#)","__index_level_0__":4634}
+{"text":"### [Beta] DDP Communication Hook\nThe DDP communication hook is a generic interface to control how to communicate gradients across workers by overriding the vanilla allreduce in DistributedDataParallel. A few built-in communication hooks are provided including PowerSGD, and users can easily apply any of these hooks to optimize communication. Additionally, the communication hook interface can also support user-defined communication strategies for more advanced use cases.\n* [RFC](https:\/\/github.com\/pytorch\/pytorch\/issues\/39272)\n* [Documentation](https:\/\/pytorch.org\/docs\/1.8.0\/ddp_comm_hooks.html?highlight=powersgd)","__index_level_0__":4635}
+{"text":"### Additional Prototype Features for Distributed Training\nIn addition to the major stable and beta distributed training features in this release, we also have a number of prototype features available in our nightlies to try out and provide feedback. We have linked in the draft docs below for reference:\n* **(Prototype) ZeroRedundancyOptimizer** - Based on and in partnership with the Microsoft DeepSpeed team, this feature helps reduce per-process memory footprint by sharding optimizer states across all participating processes in the ```ProcessGroup``` gang. Refer to this [documentation](https:\/\/pytorch.org\/docs\/master\/distributed.optim.html#torch.distributed.optim.ZeroRedundancyOptimizer) for more details. \n* **(Prototype) Process Group NCCL Send\/Recv** - The NCCL send\/recv API was introduced in v2.7 and this feature adds support for it in NCCL process groups. This feature will provide an option for users to implement collective operations at Python layer instead of C++ layer. Refer to this [documentation](https:\/\/pytorch.org\/docs\/master\/distributed.html#distributed-communication-package-torch-distributed) and [code examples](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/distributed\/distributed_c10d.py#L899) to learn more.\n* **(Prototype) CUDA-support in RPC using TensorPipe** - This feature should bring consequent speed improvements for users of PyTorch RPC with multiple-GPU machines, as TensorPipe will automatically leverage NVLink when available, and avoid costly copies to and from host memory when exchanging GPU tensors between processes. When not on the same machine, TensorPipe will fall back to copying the tensor to host memory and sending it as a regular CPU tensor. This will also improve the user experience as users will be able to treat GPU tensors like regular CPU tensors in their code. Refer to this [documentation](https:\/\/pytorch.org\/docs\/1.8.0\/rpc.html) for more details.\n* **(Prototype) Remote Module** - This feature allows users to operate a module on a remote worker like using a local module, where the RPCs are transparent to the user. In the past, this functionality was implemented in an ad-hoc way and overall this feature will improve the usability of model parallelism on PyTorch. Refer to this [documentation](https:\/\/pytorch.org\/docs\/master\/rpc.html#remotemodule) for more details.","__index_level_0__":4636}
+{"text":"# PyTorch Mobile\nSupport for PyTorch Mobile is expanding with a new set of tutorials to help new users launch models on-device quicker and give existing users a tool to get more out of our framework. These include:\n* [Image segmentation DeepLabV3 on iOS](https:\/\/pytorch.org\/tutorials\/beginner\/deeplabv3_on_ios.html)\n* [Image segmentation DeepLabV3 on Android](https:\/\/pytorch.org\/tutorials\/beginner\/deeplabv3_on_android.html)","__index_level_0__":4637}
+{"text":"Our new demo apps also include examples of image segmentation, object detection, neural machine translation, question answering, and vision transformers. They are available on both iOS and Android:\n* [iOS demo app](https:\/\/github.com\/pytorch\/ios-demo-app)\n* [Android demo app](https:\/\/github.com\/pytorch\/android-demo-app)","__index_level_0__":4638}
+{"text":"In addition to performance improvements on CPU for MobileNetV3 and other models, we also revamped our Android GPU backend prototype for broader models coverage and faster inferencing:\n* [Android tutorial](https:\/\/pytorch.org\/tutorials\/prototype\/vulkan_workflow.html)","__index_level_0__":4639}
+{"text":"Lastly, we are launching the PyTorch Mobile Lite Interpreter as a prototype feature in this release. The Lite Interpreter allows users to reduce the runtime binary size. Please try these out and send us your feedback on the [PyTorch Forums](https:\/\/discuss.pytorch.org\/c\/mobile\/). All our latest updates can be found on the [PyTorch Mobile page](https:\/\/pytorch.org\/mobile\/home\/)","__index_level_0__":4640}
+{"text":"### [Prototype] PyTorch Mobile Lite Interpreter\nPyTorch Lite Interpreter is a streamlined version of the PyTorch runtime that can execute PyTorch programs in resource constrained devices, with reduced binary size footprint. This prototype feature reduces binary sizes by up to 70% compared to the current on-device runtime in the current release. \n* [iOS\/Android Tutorial](https:\/\/pytorch.org\/tutorials\/prototype\/lite_interpreter.html)","__index_level_0__":4641}
+{"text":"# Performance Optimization\nIn 1.8, we are releasing the support for benchmark utils to enable users to better monitor performance. We are also opening up a new automated quantization API. See the details below:","__index_level_0__":4642}
+{"text":"### (Beta) Benchmark utils\nBenchmark utils allows users to take accurate performance measurements, and provides composable tools to help with both benchmark formulation and post processing. This expected to be helpful for contributors to PyTorch to quickly understand how their contributions are impacting PyTorch performance.","__index_level_0__":4643}
+{"text":"Example:\n```python\nfrom torch.utils.benchmark import Timer","__index_level_0__":4644}
+{"text":"results = []\nfor num_threads in [1, 2, 4]:\n    timer = Timer(\n        stmt=\"torch.add(x, y, out=out)\",\n        setup=\"\"\"\n            n = 1024\n            x = torch.ones((n, n))\n            y = torch.ones((n, 1))\n            out = torch.empty((n, n))\n        \"\"\",\n        num_threads=num_threads,\n    )\n    results.append(timer.blocked_autorange(min_run_time=5))\n    print(\n        f\"{num_threads} thread{'s' if num_threads > 1 else ' ':<4}\"\n        f\"{results[-1].median * 1e6:>4.0f} us   \" +\n        (f\"({results[0].median \/ results[-1].median:.1f}x)\" if num_threads > 1 else '')\n    )","__index_level_0__":4645}
+{"text":"1 thread     376 us   \n2 threads    189 us   (2.0x)\n4 threads     99 us   (3.8x)\n```\n* [Documentation](https:\/\/pytorch.org\/docs\/1.8.0\/benchmark_utils.html?highlight=benchmark#)\n* [Tutorial](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/benchmark.html)","__index_level_0__":4646}
+{"text":"### (Prototype) FX Graph Mode Quantization\n FX Graph Mode Quantization is the new automated quantization API in PyTorch. It improves upon Eager Mode Quantization by adding support for functionals and automating the quantization process, although people might need to refactor the model to make the model compatible with FX Graph Mode Quantization (symbolically traceable with ```torch.fx```).\n* [Documentation](https:\/\/pytorch.org\/docs\/master\/quantization.html#prototype-fx-graph-mode-quantization)\n* Tutorials:\n  * [(Prototype) FX Graph Mode Post Training Dynamic Quantization](https:\/\/pytorch.org\/tutorials\/prototype\/fx_graph_mode_ptq_dynamic.html)\n  * [(Prototype) FX Graph Mode Post Training Static Qunatization](https:\/\/pytorch.org\/tutorials\/prototype\/fx_graph_mode_ptq_static.html)\n  * [(Prototype) FX Graph Mode Quantization User Guide](https:\/\/pytorch.org\/tutorials\/prototype\/fx_graph_mode_quant_guide.html)","__index_level_0__":4647}
+{"text":"# Hardware Support","__index_level_0__":4648}
+{"text":"### [Beta] Ability to Extend the PyTorch Dispatcher for a new backend in C++\nIn PyTorch 1.8, you can now create new out-of-tree devices that live outside the ```pytorch\/pytorch``` repo. The tutorial linked below shows how to register your device and keep it in sync with native PyTorch devices.\n* [Tutorial](https:\/\/pytorch.org\/tutorials\/advanced\/extend_dispatcher.html)","__index_level_0__":4649}
+{"text":"### [Beta] AMD GPU Binaries Now Available\nStarting in PyTorch 1.8, we have added support for ROCm wheels providing an easy onboarding to using AMD GPUs. You can simply go to the standard [PyTorch installation selector](https:\/\/pytorch.org\/get-started\/locally\/) and choose ROCm as an installation option and execute the provided command.","__index_level_0__":4650}
+{"text":"Thanks for reading, and if you are excited about these updates and want to participate in the future of PyTorch, we encourage you to join the [discussion forums](https:\/\/discuss.pytorch.org\/) and [open GitHub issues](https:\/\/github.com\/pytorch\/pytorch\/issues).","__index_level_0__":4651}
+{"text":"***Team PyTorch***\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.8-released\/ \n category: pytorch blogs","__index_level_0__":4653}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Efficient PyTorch I\/O library for Large Datasets, Many Files, Many GPUs'\nauthor: Alex Aizman, Gavin Maltby, Thomas Breuel\n---","__index_level_0__":4654}
+{"text":"Data sets are growing bigger every day and GPUs are getting faster. This means there are more data sets for deep learning researchers and engineers to train and validate their models.","__index_level_0__":4655}
+{"text":"* Many datasets for research in still image recognition are becoming available with 10 million or more images, including OpenImages and Places.\n* million YouTube videos [(YouTube 8M)](https:\/\/research.google.com\/youtube8m\/) consume about 300 TB in 720p, used for research in object recognition, video analytics, and action recognition.\n* The Tobacco Corpus consists of about 20 million scanned HD pages, useful for OCR and text analytics research.","__index_level_0__":4656}
+{"text":"Although the most commonly encountered big data sets right now involve images and videos, big datasets occur in many other domains and involve many other kinds of data types: web pages, financial transactions, network traces, brain scans, etc.","__index_level_0__":4657}
+{"text":"However, working with the large amount of data sets presents a number of challenges:","__index_level_0__":4658}
+{"text":"* **Dataset Size:** datasets often exceed the capacity of node-local disk storage, requiring distributed storage systems and efficient network access.\n* **Number of Files:** datasets often consist of billions of files with uniformly random access patterns, something that often overwhelms both local and network file systems.\n* **Data Rates:** training jobs on large datasets often use many GPUs, requiring aggregate I\/O bandwidths to the dataset of many GBytes\/s; these can only be satisfied by massively parallel I\/O systems.\n* **Shuffling and Augmentation:** training data needs to be shuffled and augmented prior to training.\n* **Scalability:** users often want to develop and test on small datasets and then rapidly scale up to large datasets.","__index_level_0__":4659}
+{"text":"Traditional local and network file systems, and even object storage servers, are not designed for these kinds of applications. [The WebDataset I\/O library](https:\/\/github.com\/tmbdev\/webdataset) for PyTorch, together with the optional [AIStore server](https:\/\/github.com\/NVIDIA\/aistore) and [Tensorcom](https:\/\/github.com\/NVlabs\/tensorcom) RDMA libraries, provide an efficient, simple, and standards-based solution to all these problems. The library is simple enough for day-to-day use, is based on mature open source standards, and is easy to migrate to from existing file-based datasets.","__index_level_0__":4660}
+{"text":"Using WebDataset is simple and requires little effort, and it will let you scale up the same code from running local experiments to using hundreds of GPUs on clusters or in the cloud with linearly scalable performance. Even on small problems and on your desktop, it can speed up I\/O tenfold and simplifies data management and processing of large datasets. The rest of this blog post tells you how to get started with WebDataset and how it works.","__index_level_0__":4661}
+{"text":"## The WebDataset Library","__index_level_0__":4662}
+{"text":"The WebDataset library provides a simple solution to the challenges listed above. Currently, it is available as a separate library [(github.com\/tmbdev\/webdataset)](https:\/\/github.com\/tmbdev\/webdataset), but it is on track for being incorporated into PyTorch (see [RFC 38419](https:\/\/github.com\/pytorch\/pytorch\/issues\/38419)).  The WebDataset implementation is small (about 1500 LOC) and has no external dependencies.","__index_level_0__":4663}
+{"text":"Instead of inventing a new format, WebDataset represents large datasets as collections of POSIX tar archive files consisting of the original data files. The WebDataset library can use such tar archives directly for training, without the need for unpacking or local storage.","__index_level_0__":4664}
+{"text":"WebDataset scales perfectly from small, local datasets to petascale datasets and training on hundreds of GPUs and allows data to be stored on local disk, on web servers, or dedicated file servers. For container-based training, WebDataset eliminates the need for volume plugins or node-local storage. As an additional benefit, datasets need not be unpacked prior to training, simplifying the distribution and use of research data.","__index_level_0__":4665}
+{"text":"WebDataset implements PyTorch\u2019s [IterableDataset](https:\/\/pytorch.org\/docs\/stable\/data.html#torch.utils.data.IterableDataset) interface and can be used like existing DataLoader-based code. Since data is stored as files inside an archive, existing loading and data augmentation code usually requires minimal modification.","__index_level_0__":4666}
+{"text":"The WebDataset library is a complete solution for working with large datasets and distributed training in PyTorch (and also works with TensorFlow, Keras, and DALI via their Python APIs). Since POSIX tar archives are a standard, widely supported format, it is easy to write other tools for manipulating datasets in this format. E.g., the [tarp](https:\/\/github.com\/tmbdev\/tarp) command is written in Go and can shuffle and process training datasets.","__index_level_0__":4667}
+{"text":"## Benefits","__index_level_0__":4668}
+{"text":"The use of sharded, sequentially readable formats is essential for very large datasets. In addition, it has benefits in many other environments. WebDataset provides a solution that scales well from small problems on a desktop machine to very large deep learning problems in clusters or in the cloud. The following table summarizes some of the benefits in different environments.","__index_level_0__":4669}
+{"text":"  {:.table.table-striped.table-bordered}\n | Environment  | Benefits of WebDataset |\n| ------------- | ------------- |\n| Local Cluster with AIStore | AIStore can be deployed easily as K8s containers and offers linear scalability and near 100% utilization of network and I\/O bandwidth. Suitable for petascale deep learning. |\n| Cloud Computing | WebDataset deep learning jobs can be trained directly against datasets stored in cloud buckets; no volume plugins required. Local and cloud jobs work identically. Suitable for petascale learning. |\n| Local Cluster with existing distributed FS or object store |  WebDataset\u2019s large sequential reads improve performance with existing distributed stores and eliminate the need for dedicated volume plugins. |\n| Educational Environments | WebDatasets can be stored on existing web servers and web caches, and can be accessed directly by students by URL |\n| Training on Workstations from Local Drives | Jobs can start training as the data still downloads. Data doesn\u2019t need to be unpacked for training. Ten-fold improvements in I\/O performance on hard drives over random access file-based datasets. |\n| All Environments | Datasets are represented in an archival format and contain metadata such as file types. Data is compressed in native formats (JPEG, MP4, etc.). Data management, ETL-style jobs, and data transformations and I\/O are simplified and easily parallelized.  |","__index_level_0__":4670}
+{"text":"We will be adding more examples giving benchmarks and showing how to use WebDataset in these environments over the coming months.","__index_level_0__":4671}
+{"text":"## High-Performance\nFor high-performance computation on local clusters, the companion open-source [AIStore](https:\/\/github.com\/NVIDIA\/AIStore) server provides full disk to GPU I\/O bandwidth, subject only to hardware constraints. [This Bigdata 2019 Paper](https:\/\/arxiv.org\/abs\/2001.01858) contains detailed benchmarks and performance measurements. In addition to benchmarks, research projects at NVIDIA and Microsoft have used WebDataset for petascale datasets and billions of training samples.","__index_level_0__":4672}
+{"text":"Below is a benchmark of AIStore with WebDataset clients using 12 server nodes with 10 rotational drives each.","__index_level_0__":4673}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/pytorchwebdataset1.png\" width=\"100%\">\n<\/div>","__index_level_0__":4674}
+{"text":"The left axis shows the aggregate bandwidth from the cluster, while the right scale shows the measured per drive I\/O bandwidth. WebDataset and AIStore scale linearly to about 300 clients, at which point they are increasingly limited by the maximum I\/O bandwidth available from the rotational drives (about 150 MBytes\/s per drive). For comparison, HDFS is shown. HDFS uses a similar approach to AIStore\/WebDataset and also exhibits linear scaling up to about 192 clients; at that point, it hits a performance limit of about 120 MBytes\/s per drive, and it failed when using more than 1024 clients. Unlike HDFS, the WebDataset-based code just uses standard URLs and HTTP to access data and works identically with local files, with files stored on web servers, and with AIStore. For comparison, NFS in similar experiments delivers about 10-20 MBytes\/s per drive.","__index_level_0__":4675}
+{"text":"## Storing Datasets in Tar Archives","__index_level_0__":4676}
+{"text":"The format used for WebDataset is standard POSIX tar archives, the same archives used for backup and data distribution. In order to use the format to store training samples for deep learning, we adopt some simple naming conventions:\n* datasets are POSIX tar archives\n* each training sample consists of adjacent files with the same basename\n* shards are numbered consecutively","__index_level_0__":4677}
+{"text":"For example, ImageNet is stored in 1282 separate 100 Mbyte shards with names ```pythonimagenet-train-000000.tar to imagenet-train-001281.tar,``` the contents of the first shard are:","__index_level_0__":4678}
+{"text":"```python\n-r--r--r-- bigdata\/bigdata      3 2020-05-08 21:23 n03991062_24866.cls\n-r--r--r-- bigdata\/bigdata 108611 2020-05-08 21:23 n03991062_24866.jpg\n-r--r--r-- bigdata\/bigdata      3 2020-05-08 21:23 n07749582_9506.cls\n-r--r--r-- bigdata\/bigdata 129044 2020-05-08 21:23 n07749582_9506.jpg\n-r--r--r-- bigdata\/bigdata      3 2020-05-08 21:23 n03425413_23604.cls\n-r--r--r-- bigdata\/bigdata 106255 2020-05-08 21:23 n03425413_23604.jpg\n-r--r--r-- bigdata\/bigdata      3 2020-05-08 21:23 n02795169_27274.cls\n```","__index_level_0__":4679}
+{"text":"WebDataset datasets can be used directly from local disk, from web servers (hence the name), from cloud storage and object stores, just by changing a URL. WebDataset datasets can be used for training without unpacking, and training can even be carried out on streaming data, with no local storage.","__index_level_0__":4680}
+{"text":"Shuffling during training is important for many deep learning applications, and WebDataset performs shuffling both at the shard level and at the sample level. Splitting of data across multiple workers is performed at the shard level using a user-provided ```shard_selection``` function that defaults to a function that splits based on ```get_worker_info.``` (WebDataset can be combined with the [tensorcom](https:\/\/github.com\/NVLabs\/tensorcom) library to offload decompression\/data augmentation and provide RDMA and direct-to-GPU loading; see below.)","__index_level_0__":4681}
+{"text":"## Code Sample\nHere are some code snippets illustrating the use of WebDataset in a typical PyTorch deep learning application (you can find a full example at [http:\/\/github.com\/tmbdev\/pytorch-imagenet-wds](http:\/\/github.com\/tmbdev\/pytorch-imagenet-wds).","__index_level_0__":4682}
+{"text":"```python\nimport webdataset as wds\nimport ...","__index_level_0__":4683}
+{"text":"sharedurl = \"\/imagenet\/imagenet-train-{000000..001281}.tar\"","__index_level_0__":4684}
+{"text":"normalize = transforms.Normalize(\n  mean=[0.485, 0.456, 0.406],\n  std=[0.229, 0.224, 0.225])","__index_level_0__":4685}
+{"text":"preproc = transforms.Compose([\n  transforms.RandomResizedCrop(224),\n  transforms.RandomHorizontalFlip(),\n  transforms.ToTensor(),\n  normalize,\n])","__index_level_0__":4686}
+{"text":"dataset = (\n  wds.Dataset(sharedurl)\n  .shuffle(1000)\n  .decode(\"pil\")\n  .rename(image=\"jpg;png\", data=\"json\")\n  .map_dict(image=preproc)\n  .to_tuple(\"image\", \"data\")\n)","__index_level_0__":4687}
+{"text":"loader = torch.utils.data.DataLoader(dataset, batch_size=64, num_workers=8)","__index_level_0__":4688}
+{"text":"for inputs, targets in loader:\n  ...\n  ```","__index_level_0__":4689}
+{"text":"This code is nearly identical to the file-based I\/O pipeline found in the PyTorch Imagenet example: it creates a preprocessing\/augmentation pipeline, instantiates a dataset using that pipeline and a data source location, and then constructs a DataLoader instance from the dataset.","__index_level_0__":4690}
+{"text":" WebDataset uses a fluent API for a configuration that internally builds up a processing pipeline. Without any added processing stages, In this example, WebDataset is used with the PyTorch DataLoader class, which replicates DataSet instances across multiple threads and performs both parallel I\/O and parallel data augmentation.","__index_level_0__":4691}
+{"text":"WebDataset instances themselves just iterate through each training sample as a dictionary:","__index_level_0__":4692}
+{"text":"```python\n# load from a web server using a separate client process\nsharedurl = \"pipe:curl -s http:\/\/server\/imagenet\/imagenet-train-{000000..001281}.tar\"","__index_level_0__":4693}
+{"text":"dataset = wds.Dataset(sharedurl)","__index_level_0__":4694}
+{"text":"for sample in dataset:\n  # sample[\"jpg\"] contains the raw image data\n  # sample[\"cls\"] contains the class\n  ...\n  ```","__index_level_0__":4695}
+{"text":"For a general introduction to how we handle large scale training with WebDataset, see these [YouTube videos](https:\/\/www.youtube.com\/playlist?list=PL0dsKxFNMcX4XcB0w1Wm-pvSfQu-eWM26).","__index_level_0__":4696}
+{"text":"## Related Software","__index_level_0__":4697}
+{"text":"* [AIStore](https:\/\/github.com\/NVIDIA\/AIStore) is an open-source object store capable of full-bandwidth disk-to-GPU data delivery (meaning that if you have 1000 rotational drives with 200 MB\/s read speed, AIStore actually delivers an aggregate bandwidth of 200 GB\/s to the GPUs). AIStore is fully compatible with WebDataset as a client, and in addition understands the WebDataset format, permitting it to perform shuffling, sorting, ETL, and some map-reduce operations directly in the storage system. AIStore can be thought of as a remix of a distributed object store, a network file system, a distributed database, and a GPU-accelerated map-reduce implementation.","__index_level_0__":4698}
+{"text":"* [tarp](https:\/\/github.com\/tmbdev\/tarp) is a small command-line program for splitting, merging, shuffling, and processing tar archives and WebDataset datasets.","__index_level_0__":4699}
+{"text":"* [tensorcom](https:\/\/github.com\/NVLabs\/tensorcom) is a library supporting distributed data augmentation and RDMA to GPU.","__index_level_0__":4700}
+{"text":"* [pytorch-imagenet-wds](https:\/\/github.com\/tmbdev\/pytorch-imagenet-wds) contains an example of how to use WebDataset with ImageNet, based on the PyTorch ImageNet example.","__index_level_0__":4701}
+{"text":"* [Bigdata 2019 Paper with Benchmarks](https:\/\/arxiv.org\/abs\/2001.01858)","__index_level_0__":4702}
+{"text":"Check out [the library](https:\/\/github.com\/tmbdev\/webdataset) and provide your feedback for [RFC 38419](https:\/\/github.com\/pytorch\/pytorch\/issues\/38419).\n \n source: https:\/\/pytorch.org\/blog\/efficient-pytorch-io-library-for-large-datasets-many-files-many-gpus\/ \n category: pytorch blogs","__index_level_0__":4703}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'PyTorch 0.4.0 Migration Guide'\nredirect_from: \/2018\/04\/22\/0_4_0-migration-guide.html\n---","__index_level_0__":4704}
+{"text":"Welcome to the migration guide for PyTorch 0.4.0. In this release we introduced [many exciting new features and critical bug fixes](https:\/\/github.com\/pytorch\/pytorch\/releases\/tag\/v0.4.0), with the goal of providing users a better and cleaner interface. In this guide, we will cover the most important changes in migrating existing code from previous versions:","__index_level_0__":4705}
+{"text":"- `Tensors` and `Variables` have merged\n- Support for 0-dimensional (scalar) `Tensors`\n- Deprecation of the `volatile` flag\n- `dtypes`, `devices`, and Numpy-style `Tensor` creation functions\n- Writing device-agnostic code\n- New edge-case constraints on names of submodules, parameters, and buffers in `nn.Module`","__index_level_0__":4706}
+{"text":"## Merging [`Tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/tensors.html) and `Variable` and classes","__index_level_0__":4707}
+{"text":"[`torch.Tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/tensors.html) and `torch.autograd.Variable` are now the same class. More precisely, [`torch.Tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/tensors.html) is capable of tracking history and behaves like the old `Variable`; `Variable` wrapping continues to work as before but returns an object of type [`torch.Tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/tensors.html). This means that you don't need the `Variable` wrapper everywhere in your code anymore.","__index_level_0__":4708}
+{"text":"### The `type()` of a [`Tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/tensors.html) has changed","__index_level_0__":4709}
+{"text":"Note also that the `type()` of a Tensor no longer reflects the data type. Use `isinstance()` or `x.type()`instead:","__index_level_0__":4710}
+{"text":"```python\n>>> x = torch.DoubleTensor([1, 1, 1])\n>>> print(type(x))  # was torch.DoubleTensor\n\"<class 'torch.Tensor'>\"\n>>> print(x.type())  # OK: 'torch.DoubleTensor'\n'torch.DoubleTensor'\n>>> print(isinstance(x, torch.DoubleTensor))  # OK: True\nTrue\n```","__index_level_0__":4711}
+{"text":"### When does [`autograd`](https:\/\/pytorch.org\/docs\/0.4.0\/autograd.html) start tracking history now?","__index_level_0__":4712}
+{"text":"`requires_grad`, the central flag for [`autograd`](https:\/\/pytorch.org\/docs\/0.4.0\/autograd.html), is now an attribute on `Tensors`. The same rules previously used for `Variables` applies to `Tensors`; [`autograd`](https:\/\/pytorch.org\/docs\/0.4.0\/autograd.html) starts tracking history when any input `Tensor` of an operation has `requires_grad=True`. For example,","__index_level_0__":4713}
+{"text":"```python\n>>> x = torch.ones(1)  # create a tensor with requires_grad=False (default)\n>>> x.requires_grad\nFalse\n>>> y = torch.ones(1)  # another tensor with requires_grad=False\n>>> z = x + y\n>>> # both inputs have requires_grad=False. so does the output\n>>> z.requires_grad\nFalse\n>>> # then autograd won't track this computation. let's verify!\n>>> z.backward()\nRuntimeError: element 0 of tensors does not require grad and does not have a grad_fn\n>>>\n>>> # now create a tensor with requires_grad=True\n>>> w = torch.ones(1, requires_grad=True)\n>>> w.requires_grad\nTrue\n>>> # add to the previous result that has require_grad=False\n>>> total = w + z\n>>> # the total sum now requires grad!\n>>> total.requires_grad\nTrue\n>>> # autograd can compute the gradients as well\n>>> total.backward()\n>>> w.grad\ntensor([ 1.])\n>>> # and no computation is wasted to compute gradients for x, y and z, which don't require grad\n>>> z.grad == x.grad == y.grad == None\nTrue\n```","__index_level_0__":4714}
+{"text":"#### Manipulating `requires_grad` flag","__index_level_0__":4715}
+{"text":"Other than directly setting the attribute, you can change this flag `in-place` using [`my_tensor.requires_grad_()`](https:\/\/pytorch.org\/docs\/0.4.0\/tensors.html#torch.Tensor.requires_grad_), or, as in the above example, at creation time by passing it in as an argument (default is `False`), e.g.,","__index_level_0__":4716}
+{"text":"```python\n>>> existing_tensor.requires_grad_()\n>>> existing_tensor.requires_grad\nTrue\n>>> my_tensor = torch.zeros(3, 4, requires_grad=True)\n>>> my_tensor.requires_grad\nTrue\n```","__index_level_0__":4717}
+{"text":"### What about `.data?`","__index_level_0__":4718}
+{"text":"`.data` was the primary way to get the underlying `Tensor` from a `Variable`. After this merge, calling `y = x.data` still has similar semantics. So `y` will be a `Tensor` that shares the same data with `x`, is unrelated with the computation history of `x`, and has `requires_grad=False`.","__index_level_0__":4719}
+{"text":"However, `.data` can be unsafe in some cases. Any changes on `x.data` wouldn't be tracked by `autograd`, and the computed gradients would be incorrect if `x` is needed in a backward pass. A safer alternative is to use [`x.detach()`](https:\/\/pytorch.org\/docs\/master\/autograd.html#torch.Tensor.detach), which also returns a `Tensor` that shares data with `requires_grad=False`, but will have its in-place changes reported by `autograd` if `x` is needed in backward.","__index_level_0__":4720}
+{"text":"Here is an example of the difference between `.data` and `x.detach()` (and why we recommend using `detach` in general).","__index_level_0__":4721}
+{"text":"If you use `Tensor.detach()`, the gradient computation is guaranteed to be correct.","__index_level_0__":4722}
+{"text":"```python\n>>> a = torch.tensor([1,2,3.], requires_grad = True)\n>>> out = a.sigmoid()\n>>> c = out.detach()\n>>> c.zero_()\ntensor([ 0.,  0.,  0.])","__index_level_0__":4723}
+{"text":">>> out  # modified by c.zero_() !!\ntensor([ 0.,  0.,  0.])","__index_level_0__":4724}
+{"text":">>> out.sum().backward()  # Requires the original value of out, but that was overwritten by c.zero_()\nRuntimeError: one of the variables needed for gradient computation has been modified by an\n```","__index_level_0__":4725}
+{"text":"However, using `Tensor.data` can be unsafe and can easily result in incorrect gradients when a tensor is required for gradient computation but modified in-place.","__index_level_0__":4726}
+{"text":"```python\n>>> a = torch.tensor([1,2,3.], requires_grad = True)\n>>> out = a.sigmoid()\n>>> c = out.data\n>>> c.zero_()\ntensor([ 0.,  0.,  0.])","__index_level_0__":4727}
+{"text":">>> out  # out  was modified by c.zero_()\ntensor([ 0.,  0.,  0.])","__index_level_0__":4728}
+{"text":">>> out.sum().backward()\n>>> a.grad  # The result is very, very wrong because `out` changed!\ntensor([ 0.,  0.,  0.])\n```","__index_level_0__":4729}
+{"text":"## Support for 0-dimensional (scalar) Tensors","__index_level_0__":4730}
+{"text":"Previously, indexing into a `Tensor` vector (1-dimensional tensor) gave a Python number but indexing into a `Variable` vector gave (inconsistently!) a vector of size `(1,)`! Similar behavior existed with reduction functions, e.g. `tensor.sum()` would return a Python number, but `variable.sum()` would return a vector of size `(1,)`.","__index_level_0__":4731}
+{"text":"Fortunately, this release introduces proper scalar (0-dimensional tensor) support in PyTorch! Scalars can be created using the new `torch.tensor` function (which will be explained in more detail later; for now just think of it as the PyTorch equivalent of `numpy.array`). Now you can do things like:","__index_level_0__":4732}
+{"text":"```python\n>>> torch.tensor(3.1416)         # create a scalar directly\ntensor(3.1416)\n>>> torch.tensor(3.1416).size()  # scalar is 0-dimensional\ntorch.Size([])\n>>> torch.tensor([3]).size()     # compare to a vector of size 1\ntorch.Size([1])\n>>>\n>>> vector = torch.arange(2, 6)  # this is a vector\n>>> vector\ntensor([ 2.,  3.,  4.,  5.])\n>>> vector.size()\ntorch.Size([4])\n>>> vector[3]                    # indexing into a vector gives a scalar\ntensor(5.)\n>>> vector[3].item()             # .item() gives the value as a Python number\n5.0\n>>> mysum = torch.tensor([2, 3]).sum()\n>>> mysum\ntensor(5)\n>>> mysum.size()\ntorch.Size([])\n```","__index_level_0__":4733}
+{"text":"### Accumulating losses","__index_level_0__":4734}
+{"text":"Consider the widely used pattern `total_loss += loss.data[0]`. Before 0.4.0. `loss` was a `Variable` wrapping a tensor of size `(1,)`, but in 0.4.0 `loss` is now a scalar and has `0` dimensions. Indexing into a scalar doesn't make sense (it gives a warning now, but will be a hard error in 0.5.0). Use `loss.item()` to get the Python number from a scalar.","__index_level_0__":4735}
+{"text":"Note that if you don't convert to a Python number when accumulating losses, you may find increased memory usage in your program. This is because the right-hand-side of the above expression used to be a Python float, while it is now a zero-dim Tensor. The total loss is thus accumulating Tensors and their gradient history, which may keep around large autograd graphs for much longer than necessary.","__index_level_0__":4736}
+{"text":"## Deprecation of volatile flag","__index_level_0__":4737}
+{"text":"The `volatile` flag is now deprecated and has no effect. Previously, any computation that involves a `Variable` with `volatile=True` wouldn't be tracked by `autograd`. This has now been replaced by a [set of more flexible context managers](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#locally-disabling-gradient-computation) including `torch.no_grad()`, `torch.set_grad_enabled(grad_mode)`, and others.","__index_level_0__":4738}
+{"text":"```python\n>>> x = torch.zeros(1, requires_grad=True)\n>>> with torch.no_grad():\n...     y = x * 2\n>>> y.requires_grad\nFalse\n>>>\n>>> is_train = False\n>>> with torch.set_grad_enabled(is_train):\n...     y = x * 2\n>>> y.requires_grad\nFalse\n>>> torch.set_grad_enabled(True)  # this can also be used as a function\n>>> y = x * 2\n>>> y.requires_grad\nTrue\n>>> torch.set_grad_enabled(False)\n>>> y = x * 2\n>>> y.requires_grad\nFalse\n```","__index_level_0__":4739}
+{"text":"## [`dtypes`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.dtype), [`devices`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.device) and NumPy-style creation functions","__index_level_0__":4740}
+{"text":"In previous versions of PyTorch, we used to specify data type (e.g. float vs double), device type (cpu vs cuda) and layout (dense vs sparse) together as a \"tensor type\". For example, `torch.cuda.sparse.DoubleTensor` was the `Tensor` type representing the `double` data type, living on CUDA devices, and with [COO sparse tensor](https:\/\/en.wikipedia.org\/wiki\/Sparse_matrix#Coordinate_list_(COO)) layout.","__index_level_0__":4741}
+{"text":"In this release, we introduce [`torch.dtype`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.dtype), [`torch.device`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.device) and [`torch.layout`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.layout) classes to allow better management of these properties via NumPy-style creation functions.","__index_level_0__":4742}
+{"text":"### [`torch.dtype`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.dtype)","__index_level_0__":4743}
+{"text":"Below is a complete list of available [`torch.dtype`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.dtype)s (data types) and their corresponding tensor types.","__index_level_0__":4744}
+{"text":"| Data | `type torch.dtype` | Tensor types |\n|------|------------------|--------------|\n| 32-bit floating point | `torch.float32` or `torch.float` | `torch.*.FloatTensor`\n| 64-bit floating point | `torch.float64` or `torch.double` | `torch.*.DoubleTensor`\n| 16-bit floating point | `torch.float16` or `torch.half` | `torch.*.HalfTensor`\n| 8-bit integer (unsigned) |  `torch.uint8` | `torch.*.ByteTensor`\n| 8-bit integer (signed) | `torch.int8` | `torch.*.CharTensor`\n| 16-bit integer (signed) | `torch.int16` or `torch.short` | `torch.*.ShortTensor`\n| 32-bit integer (signed) | `torch.int32` or `torch.int` | `torch.*.IntTensor`\n| 64-bit integer (signed) | `torch.int64` or `torch.long` | `torch.*.LongTensor`","__index_level_0__":4745}
+{"text":"The dtype of a tensor can be access via its `dtype` attribute.","__index_level_0__":4746}
+{"text":"### [`torch.device`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.device)","__index_level_0__":4747}
+{"text":"A [`torch.device`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.device) contains a device type (`'cpu'` or `'cuda'`) and optional device ordinal (id) for the device type. It can be initialized with `torch.device('{device_type}')` or `torch.device('{device_type}:{device_ordinal}')`.","__index_level_0__":4748}
+{"text":"If the device ordinal is not present, this represents the current device for the device type; e.g., `torch.device('cuda')` is equivalent to `torch.device('cuda:X')` where `X` is the result of `torch.cuda.current_device()`.","__index_level_0__":4749}
+{"text":"The device of a tensor can be accessed via its `device` attribute.","__index_level_0__":4750}
+{"text":"### [`torch.layout`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.layout)","__index_level_0__":4751}
+{"text":"[`torch.layout`](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.layout) represents the data layout of a [`Tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/tensors.html). Currently `torch.strided` (dense tensors, the default) and `torch.sparse_coo` (sparse tensors with COO format) are supported.","__index_level_0__":4752}
+{"text":"The layout of a tensor can be access via its `layout` attribute.","__index_level_0__":4753}
+{"text":"### Creating Tensors","__index_level_0__":4754}
+{"text":"[Methods that create a](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#creation-ops) [`Tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/tensors.html) now also take in `dtype`, `device`, `layout`, and `requires_grad` options to specify the desired attributes on the returned `Tensor`. For example,","__index_level_0__":4755}
+{"text":"```python\n>>> device = torch.device(\"cuda:1\")\n>>> x = torch.randn(3, 3, dtype=torch.float64, device=device)\ntensor([[-0.6344,  0.8562, -1.2758],\n        [ 0.8414,  1.7962,  1.0589],\n        [-0.1369, -1.0462, -0.4373]], dtype=torch.float64, device='cuda:1')\n>>> x.requires_grad  # default is False\nFalse\n>>> x = torch.zeros(3, requires_grad=True)\n>>> x.requires_grad\nTrue\n```","__index_level_0__":4756}
+{"text":"##### [`torch.tensor(data, ...)`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.tensor)","__index_level_0__":4757}
+{"text":"[`torch.tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.tensor) is one of the newly added [tensor creation methods](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#creation-ops). It takes in array-like data of all kinds and copies the contained values into a new `Tensor`. As mentioned earlier, [`torch.tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.tensor) is the PyTorch equivalent of NumPy's `numpy.array`constructor. Unlike the `torch.*Tensor` methods, you can also create zero-dimensional `Tensor`s (aka scalars) this way (a single python number is treated as a Size in the `torch.*Tensor methods`). Moreover, if a `dtype` argument isn't given, it will infer the suitable `dtype` given the data. It is the recommended way to create a tensor from existing data like a Python list. For example,","__index_level_0__":4758}
+{"text":"```python\n>>> cuda = torch.device(\"cuda\")\n>>> torch.tensor([[1], [2], [3]], dtype=torch.half, device=cuda)\ntensor([[ 1],\n        [ 2],\n        [ 3]], device='cuda:0')\n>>> torch.tensor(1)               # scalar\ntensor(1)\n>>> torch.tensor([1, 2.3]).dtype  # type inferece\ntorch.float32\n>>> torch.tensor([1, 2]).dtype    # type inferece\ntorch.int64\n```","__index_level_0__":4759}
+{"text":"We've also added more tensor creation methods. Some of them have `torch.*_like` and\/or `tensor.new_*` variants.","__index_level_0__":4760}
+{"text":"- `torch.*_like` takes in an input `Tensor` instead of a shape. It returns a `Tensor` with same attributes as the input `Tensor` by default unless otherwise specified:","__index_level_0__":4761}
+{"text":"  ```python\n >>> x = torch.randn(3, dtype=torch.float64)\n >>> torch.zeros_like(x)\n tensor([ 0.,  0.,  0.], dtype=torch.float64)\n >>> torch.zeros_like(x, dtype=torch.int)\n tensor([ 0,  0,  0], dtype=torch.int32)\n  ```","__index_level_0__":4762}
+{"text":"- `tensor.new_*` can also create `Tensors` with same attributes as `tensor`, but it always takes in a shape argument:","__index_level_0__":4763}
+{"text":"  ```python\n >>> x = torch.randn(3, dtype=torch.float64)\n >>> x.new_ones(2)\n tensor([ 1.,  1.], dtype=torch.float64)\n >>> x.new_ones(4, dtype=torch.int)\n tensor([ 1,  1,  1,  1], dtype=torch.int32)\n  ```","__index_level_0__":4764}
+{"text":"To specify the desired shape, you can either use a tuple (e.g., `torch.zeros((2, 3))`) or variable arguments (e.g., `torch.zeros(2, 3)`) in most cases.","__index_level_0__":4765}
+{"text":"| Name | Returned `Tensor` | `torch.*_like` variant | `tensor.new_*` variant |\n|------|-----------------|----------------------|----------------------|\n| [`torch.empty`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.empty) | uninitialized memory | \u2714 | \u2714 |\n| [`torch.zeros`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.zeros) | all zeros | \u2714 | \u2714 |\n| [`torch.ones`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.ones) | all ones | \u2714 | \u2714 |\n| [`torch.full`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.full) | filled with a given value | \u2714 | \u2714 |\n| [`torch.rand`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.rand) | i.i.d. continuous Uniform[0, 1) | \u2714 |\n| [`torch.randn`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.randn) | i.i.d. `Normal(0, 1)` | \u2714 |\n| [`torch.randint`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.randint) | i.i.d. discrete Uniform in given range | \u2714 |\n| [`torch.randperm`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.randperm) | random permutation of `{0, 1, ..., n - 1}` |\n| [`torch.tensor`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.tensor) | copied from existing data (list, NumPy ndarray, etc.) | | \u2714 |\n| [`torch.from_numpy`*](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.from_numpy) | from NumPy `ndarray` (sharing storage without copying) |\n| [`torch.arange`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.arange), [`torch.range`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.range), and [`torch.linspace`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.linspace) | uniformly spaced values in a given range |\n| [`torch.logspace`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.logspace) | logarithmically spaced values in a given range |\n| [`torch.eye`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.eye) | identity matrix |","__index_level_0__":4766}
+{"text":"\n*: [`torch.from_numpy`](https:\/\/pytorch.org\/docs\/0.4.0\/torch.html#torch.from_numpy) only takes in a NumPy `ndarray` as its input argument.","__index_level_0__":4767}
+{"text":"\n## Writing device-agnostic code","__index_level_0__":4768}
+{"text":"Previous versions of PyTorch made it difficult to write code that was device agnostic (i.e. that could run on both CUDA-enabled and CPU-only machines without modification).","__index_level_0__":4769}
+{"text":"PyTorch 0.4.0 makes this easier in two ways:","__index_level_0__":4770}
+{"text":"- The `device` attribute of a Tensor gives the [torch.device](https:\/\/pytorch.org\/docs\/0.4.0\/tensor_attributes.html#torch.torch.device) for all Tensors (`get_device` only works for CUDA tensors)\n- The `to` method of `Tensors` and `Modules` can be used to easily move objects to different devices (instead of having to call `cpu()` or `cuda()` based on the context)","__index_level_0__":4771}
+{"text":"We recommend the following pattern:","__index_level_0__":4772}
+{"text":"```python\n# at beginning of the script\ndevice = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")","__index_level_0__":4773}
+{"text":"# then whenever you get a new Tensor or Module\n# this won't copy if they are already on the desired device\ninput = data.to(device)\nmodel = MyModule(...).to(device)\n```","__index_level_0__":4775}
+{"text":"## New edge-case constraints on names of submodules, parameters, and buffers in `nn.Module`","__index_level_0__":4776}
+{"text":"`name` that is an empty string or contains `\".\"` is no longer permitted in `module.add_module(name, value)`, `module.add_parameter(name, value)` or `module.add_buffer(name, value)` because such names may cause lost data in the `state_dict`. If you are loading a checkpoint for modules containing such names, please update the module definition and patch the `state_dict` before loading it.","__index_level_0__":4777}
+{"text":"## Code Samples (Putting it all together)","__index_level_0__":4778}
+{"text":"To get a flavor of the overall recommended changes in 0.4.0, let's look at a quick example for a common code pattern in both 0.3.1 and 0.4.0:","__index_level_0__":4779}
+{"text":"- 0.3.1 (old):\n  ```python\n  model = MyRNN()\n  if use_cuda:\n      model = model.cuda()","__index_level_0__":4780}
+{"text":"  # train\n  total_loss = 0\n  for input, target in train_loader:\n      input, target = Variable(input), Variable(target)\n      hidden = Variable(torch.zeros(*h_shape))  # init hidden\n      if use_cuda:\n          input, target, hidden = input.cuda(), target.cuda(), hidden.cuda()\n      ...  # get loss and optimize\n      total_loss += loss.data[0]","__index_level_0__":4781}
+{"text":"  # evaluate\n  for input, target in test_loader:\n      input = Variable(input, volatile=True)\n      if use_cuda:\n          ...\n      ...\n  ```","__index_level_0__":4782}
+{"text":"- 0.4.0 (new):\n  ```python\n  # torch.device object used throughout this script\n  device = torch.device(\"cuda\" if use_cuda else \"cpu\")","__index_level_0__":4783}
+{"text":"  model = MyRNN().to(device)","__index_level_0__":4784}
+{"text":"  # train\n  total_loss = 0\n  for input, target in train_loader:\n      input, target = input.to(device), target.to(device)\n      hidden = input.new_zeros(*h_shape)  # has the same device & dtype as `input`\n      ...  # get loss and optimize\n      total_loss += loss.item()           # get Python number from 1-element Tensor","__index_level_0__":4785}
+{"text":"  # evaluate\n  with torch.no_grad():                   # operations inside don't track history\n      for input, target in test_loader:\n          ...\n  ```","__index_level_0__":4786}
+{"text":"Thank you for reading! Please refer to our [documentation](https:\/\/pytorch.org\/docs\/0.4.0\/index.html) and [release notes](https:\/\/github.com\/pytorch\/pytorch\/releases\/tag\/v0.4.0) for more details.","__index_level_0__":4787}
+{"text":"Happy PyTorch-ing!\n \n source: https:\/\/pytorch.org\/blog\/pytorch-0_4_0-migration-guide\/ \n category: pytorch blogs","__index_level_0__":4788}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Efficient Large-Scale Training with Pytorch FSDP and AWS\"\nauthor: Less Wright, Hamid Shojanazeri, Geeta Chauhan\nfeatured-img: \"assets\/images\/largeblog_index_1.png\"\n---","__index_level_0__":4789}
+{"text":"Cutting-edge AI models are becoming extremely large. The cost and overhead of training these models is increasing rapidly, and involves large amounts of engineering and guesswork to find the right training regime. FSDP reduces these costs significantly by enabling you to train much larger models with the same amount of resources. FSDP lowers the memory footprint on your GPUs, and is usable via a lightweight configuration that requires substantially less effort, typically with just a few lines of code.","__index_level_0__":4790}
+{"text":"The main performance gains in FSDP come from maximizing the overlap between network communication and model computation, and eliminating the memory redundancy inherent in traditional data parallel training (DDP).  PyTorch FSDP can train models approximately 4x larger on the same server resources as DDP and 20x larger if we combine activation checkpointing and activation offloading.","__index_level_0__":4791}
+{"text":"Since PyTorch 1.12, FSDP is now in beta status, and has added a number of new features that can be tuned to further accelerate your model training. ","__index_level_0__":4792}
+{"text":"In this series of blog posts, we will explain multiple performance optimizations you can run with FSDP to boost your distributed training speed and model sizes within the context of your available server resources.  We use the HuggingFace T5 3B, 11B and DeepVit, in fine-tuning mode, as the running examples throughout the series.","__index_level_0__":4793}
+{"text":"As a preview of some of the optimizations discussed in this series, we show the before and after performance scaled in Flops below (Note that these results can vary based on your server resources and model architecture). ","__index_level_0__":4794}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_1.png\" width=\"90%\">\n<\/p>","__index_level_0__":4795}
+{"text":"<i> *T5 3B Performance measured on AWS A100 and A10 servers. Original with no optimizations and Tuned with the applied optimization <\/i>","__index_level_0__":4796}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_2.png\" width=\"90%\">\n<\/p>","__index_level_0__":4797}
+{"text":"<i> *T5 11B Performance measured on A100 servers. Original with no optimizations and Tuned with the applied optimization <\/i>","__index_level_0__":4798}
+{"text":"In this first post, we will provide a quick overview of FSDP and how it can make training large- scale AI models more efficient.  We will highlight briefly the multiple performance options available, and dive deeper into the details on these in upcoming posts.  We will then conclude with an overview on how to leverage AWS parallel cluster for large- scale training with FSDP. ","__index_level_0__":4799}
+{"text":"<table style=\"border: 1px solid black;\">\n  <tr>\n   <td><strong>Optimization <\/strong>\n   <\/td>\n   <td><strong>T5 Model <\/strong>\n   <\/td>\n   <td><strong>Throughput Improvement <\/strong>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td rowspan=\"2\" >Mixed Precision\n   <\/td>\n   <td>3 B\n   <\/td>\n   <td>5x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>11 B\n   <\/td>\n   <td>10x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td rowspan=\"2\" >Activation Checkpointing (AC)\n   <\/td>\n   <td>3 B\n   <\/td>\n   <td>10x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>11 B\n   <\/td>\n   <td>100x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td rowspan=\"2\" >Transformer Wrapping Policy\n   <\/td>\n   <td>3 B\n   <\/td>\n   <td>2x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>11 B\n   <\/td>\n   <td><em>Unable to run the experiment without the Transformer wrapping policy.<\/em>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td rowspan=\"2\" >Full Shard Strategy\n   <\/td>\n   <td>3 B\n   <\/td>\n   <td>1.5x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>11 B\n   <\/td>\n   <td><em>Not able to run with Zero2<\/em>\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":4800}
+{"text":"_Performance optimization gains on T5 models over non-optimized._","__index_level_0__":4801}
+{"text":"In our experiments with the T5 3B model, using the  [transformer wrapping policy](https:\/\/www.youtube.com\/watch?v=HQeKwCsnH4k&list=PL_lsbAsL_o2BT6aerEKgIoufVD_fodnuT&index=2) resulted in >2x higher throughput measured in TFLOPS versus the default wrapping policy. [Activation checkpointing](https:\/\/www.youtube.com\/watch?v=5B4d0FuxSQc&list=PL_lsbAsL_o2BT6aerEKgIoufVD_fodnuT&index=3) resulted in 10x improvement by reinvesting the freed memory from the checkpoints into larger batch size. [Mixed precision](https:\/\/www.youtube.com\/watch?v=-caN92JtKqA&list=PL_lsbAsL_o2BT6aerEKgIoufVD_fodnuT&index=4) with BFloat16 resulted in ~5x improvement versus FP32 and finally the [full sharding strategy](https:\/\/www.youtube.com\/watch?v=a3iW6Cggccw&list=PL_lsbAsL_o2BT6aerEKgIoufVD_fodnuT&index=5) versus zero2 (DDP)  resulted in 1.5x improvement.","__index_level_0__":4802}
+{"text":"We ran similar experiments for a larger model, T5 11B, but the larger model size resulted in some changes to the experiment space.  Specifically, we found that two optimizations,  transformer wrapping policy and activation checkpointing, were needed to enable us to run these experiments on 3 nodes (each node had 8 A100 gpus with 80 GB of memory). With these optimizations, we could fit a batch size of 50 and get higher throughput compared to removing each one of them. Thus rather than running on\/off solely for a single optimization test as with the 3B model, the larger model experiments were done with 1 of 3 optimizations turned on\/off while always running the other two in order to allow a usable batch size for both test states for each item.  ","__index_level_0__":4803}
+{"text":"Based on TFLOP comparisons, with the 11B model, we saw even more payoff from the optimizations.  Mixed precision(~10x improvement) and activation checkpointing (~100x improvement) had a much larger impact with the 11B model compared to the 3B parameter model. With mixed precision we could fit ~2x larger batch sizes and with activation checkpointing >15x batch sizes (from 3 with no activation checkpointing to 50 with activation checkpointing) which translated into large throughput improvements.","__index_level_0__":4804}
+{"text":"We also have observed that for these larger models > 3B, using Zero2 sharding strategy would result in minimal room left in memory for the batch data, and had to go with very small batch sizes (e.g 1-2) that essentially makes full sharding strategy a necessity to enable fitting larger batches sizes. ","__index_level_0__":4805}
+{"text":"_Note - this tutorial assumes a basic understanding of FSDP. To learn more about basics of FSDP please refer to the [getting started](https:\/\/pytorch.org\/tutorials\/intermediate\/FSDP_tutorial.html) and [advanced FSDP ](https:\/\/pytorch.org\/tutorials\/intermediate\/FSDP_adavnced_tutorial.html)tutorials._","__index_level_0__":4806}
+{"text":"**What is FSDP? How does it make Large-Scale Training More Efficient**","__index_level_0__":4807}
+{"text":"**FSDP** expands upon distributed data parallel, by parallelizing not just data, but the model parameters, the optimizer states and gradients associated with the model. Specifically - **each** **GPU only stores a subset of the entire model** **and the associated subset of optimizer states and gradients.**","__index_level_0__":4808}
+{"text":"_To show the evolution of distributed training, we can start from the beginning, where AI models were simply trained on a single GPU._","__index_level_0__":4809}
+{"text":"DDP (Distributed Data Parallel) was the initial step up from training with only a single GPU, and was an effort to address the data and model size growth, where multiple GPUs each housed their own copy of the same model. The gain here is that the data for each batch could be split and processed independently on each GPU, all at the same time,thus parallelizing the processing of the data set and increasing training speed by the increasing number of GPUs. The tradeoff is the need to communicate the gradients between each GPU to synchronize the models after the backward pass.","__index_level_0__":4810}
+{"text":"FSDP expands on scaling models by removing the redundancy of optimizer calculations and state storage, as well as gradient and memory storage of model parameters that are present in DDP (DDP = Distributed Data Parallel). This redundancy reduction, along with increased communication overlap where model parameter communication takes place at the same time as model computation, is what allows FSDP to train much larger models with the same resources as DDP.","__index_level_0__":4811}
+{"text":"A key point is that this efficiency also allows for AI models that are larger than a single GPU to be trained. The model size available for training is now increased to the aggregate memory of all GPUs, rather than the size of a single GPU. (And as a point of note, FSDP can go beyond aggregated GPU memory by leveraging CPU memory as well, though we will not directly cover this aspect here).","__index_level_0__":4812}
+{"text":"As discussed in a previous [blog post](https:\/\/medium.com\/pytorch\/pytorch-data-parallel-best-practices-on-google-cloud-6c8da2be180d), with DDP the largest model that we could train on 32, A100 gpus with 40 GB memory (4 nodes) was up to 3B parameters, and batch size of 128, with the help of activation checkpointing. By contrast, using FSDP we were able to train up to 81B model size, combining activation checkpointing, along with activation and parameter offloading. In another [experiment](https:\/\/medium.com\/pytorch\/training-a-1-trillion-parameter-model-with-pytorch-fully-sharded-data-parallel-on-aws-3ac13aa96cff), we benchmarked a 1T parameter model with FSDP using 512 gpus.","__index_level_0__":4813}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_3.png\" width=\"90%\">\n<\/p>","__index_level_0__":4814}
+{"text":"For intuition on the parameter level workings of FSDP, below we show an animation detailing how the model parameters are sharded and communicated assuming a two GPU scenario and a simple 8 parameter model:","__index_level_0__":4815}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_5.gif\" width=\"70%\">\n<\/p>","__index_level_0__":4816}
+{"text":"\n_Above - the animations walk through the steps involved with the initial sharding of the model amongst ranks, and we start the `all_gathers` and forward pass_","__index_level_0__":4817}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_6.gif\" width=\"70%\">\n<\/p>","__index_level_0__":4818}
+{"text":"_We continue through the model with the forward pass. After each FSDP unit completes, non-locally owned params are dropped to free memory, and optionally activations can be checkpointed. This continues until we finish the forward pass and compute the loss._","__index_level_0__":4819}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_6.5.gif\" width=\"70%\">\n<\/p>","__index_level_0__":4820}
+{"text":"_During the backward pass, another `all_gather` is used to load the parameters and the gradients are computed. These gradients are then `reduce_scattered` so that the local owners of each param can aggregate and prepare to update the weights._","__index_level_0__":4821}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_7.gif\" width=\"70%\">\n<\/p>","__index_level_0__":4822}
+{"text":"_Finally, each rank passes the summed gradients through the optimizer states and updates the weights to complete the mini-batch._","__index_level_0__":4823}
+{"text":"With the model now distributed across the entire set of available GPUs, the logical question is how data moves through the model given this sharding of model parameters.","__index_level_0__":4824}
+{"text":"This is accomplished by FSDP coordinating with all GPUs to effectively share (communicate) the respective parts of the model.  The model is decomposed into FSDP units and parameters within each unit are flattened and then sharded across all GPUs.  Within each FSDP unit, GPU\u2019s are assigned interleaving ownership of individual model parameters.","__index_level_0__":4825}
+{"text":"By interleaving, we mean the following - assuming 2 gpus with an id of 1 and 2, the FSDP unit ownership pattern would be [12121212],  rather than a contiguous chunk of [111222].","__index_level_0__":4826}
+{"text":"During training, an `all_gather` is initiated and the locally owned model parameters within a FSDP unit are shared by the owner GPU with the other non-owners, when they need it, on a \u2018just in time\u2019 type basis. FSDP prefetches parameters to overlap `all_gather` communication with computation. ","__index_level_0__":4827}
+{"text":"When those requested parameters arrive, the GPU uses the delivered parameters, in combination with the parameters it already owns, to create a fully populated FSDP unit. Thus there is a moment where each GPU hits peak memory usage while holding a fully populated FSDP unit.","__index_level_0__":4828}
+{"text":"It then processes the data through the FSDP unit, and drops the parameters it received from other GPU\u2019s to free up memory for the next unit\u2026the process continues over and over proceeding through the entire model to complete the forward pass.The process is then repeated (in general) for the backward pass.(note - this is a simplified version for understanding..there is additional complexity but this should help construct a basic mental model of the FSDP process). ","__index_level_0__":4829}
+{"text":"This eliminates much of the memory redundancy present in DDP, but imposes the cost of higher amounts of network communication to shuttle these requested parameters back and forth amongst all the GPUs.**Overlapping the communication timing with the computation taking place is the basis of many of the performance improvements we\u2019ll discuss in this series.** The key gains are frequently based on the fact that communication can often take place at the same time as computation.As you can surmise, **having high communication speed is vital for FSDP performance.**","__index_level_0__":4830}
+{"text":"\n### **How do I optimize my training with FSDP?**","__index_level_0__":4831}
+{"text":"There are four main performance improvements we will cover - the transformer wrapper, activation checkpointing, mixed precision, and selecting the proper sharding strategy. The flowchart below will help as a checklist for tuning options that we will discuss in this post.","__index_level_0__":4832}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_8.png\" width=\"70%\">\n<\/p>","__index_level_0__":4833}
+{"text":"**Wrapping policy - _for transformers, use Transformer wrapping policy_**","__index_level_0__":4834}
+{"text":"The first performance optimization is leveraging the FSDP transformer wrapper for transformer models. \n \nOne of the pre-defined wrapping policy is `size_based_autowrap_policy`. With `size_based_autowrap_policy`, FSDP will traverse the module structure from bottom to top, a new FSDP unit will be created once the current unit has at least the `min_num_params` specified within the size policy (this defaults to 1e8, or 100M). If the module can not be created as an FSDP unit, FSDP will continue to check its parent module. This size based wrapping policy may not be ideal for some model structures, PyTorch distributed team is actively working on a new default wrapping policy in the next release which is based on size and also module execution order, users can simply tune the size and achieve the optimized performance. \n \nIn the current release, you can greatly improve your performance when running Transformer models by using the \u2018transformer wrapper\u2019. You will need to provide the appropriate layer class for your model. Here, layer class is the class that houses the Multi-Head Attention and Feed Forward Network.","__index_level_0__":4835}
+{"text":"FSDP will then form the FSDP units around the layer class rather than arbitrary breaks based on parameter size. By sharding the model around layer classes that are uniformly repeated within the transformer, FSDP can create uniform FSDP units that better balance the overlap of computation and communication. By contrast, size based wrapping can produce very uneven or skewed shards for models, which then have uneven matching of compute vs communication overlap. As discussed earlier, the main driver of FSDP high performance is the overlap of communication and computation, and hence why the Transformer wrapper provides improved performance. Note that the Transformer wrapper can also be used for non-transformer models if these models have a list of uniform layers.","__index_level_0__":4836}
+{"text":"Let\u2019s compare the performance difference on a T5, 3B parameter model when running under the default wrapper and the transformer wrapper.","__index_level_0__":4837}
+{"text":"For default wrapping, we don\u2019t need to take any action - we simply pass the model to FSDP as shown:","__index_level_0__":4838}
+{"text":"```python\nmodel = FSDP(\n      model,\n      device_id=torch.cuda.current_device(),\n  )\n```","__index_level_0__":4839}
+{"text":"\nIn this case FSDP will simply wrap the whole model in a single FSDP unit.","__index_level_0__":4840}
+{"text":"Running on an [NVIDIA A100-SXM4\u201340GB](https:\/\/www.nvidia.com\/content\/dam\/en-zz\/Solutions\/Data-Center\/a100\/pdf\/nvidia-a100-datasheet-us-nvidia-1758950-r4-web.pdf) with 8 GPUs, we are able to reach 2.3 TFlops and 95% GPU memory utilization with a batch size of 14.","__index_level_0__":4841}
+{"text":"However, since T5 is a transformer model, we are better served to leverage the transformer wrapper for this model. \n \nTo use that, we need to isolate the layer class for the transformer, and then pass it in to create our transformer wrapper. ","__index_level_0__":4842}
+{"text":"```python\nfrom transformers.models.t5.modeling_t5 import T5Block\n```","__index_level_0__":4843}
+{"text":"And now we can create our Transformer wrapper: ","__index_level_0__":4844}
+{"text":"```python\ntransformer_auto_wrapper_policy = functools.partial(\n        transformer_auto_wrap_policy,\n        transformer_layer_cls={\n            T5Block,  # < ---- Your Transformer layer class\n        },\n    )\n```","__index_level_0__":4845}
+{"text":"With our model aware wrapper ready, we can initialize FSDP:","__index_level_0__":4846}
+{"text":"```python\n# invoke FSDP with your transformer wrapper policy:\nmodel = FSDP(\n        model,\n        auto_wrap_policy=transformer_auto_wrapper_policy,\n        device_id=torch.cuda.current_device(),  # streaming init\n    )\n```","__index_level_0__":4847}
+{"text":"Running this wrapped model, we can see some substantial performance gains.We can fit nearly double the batch size, going to 28, and with better memory and communication efficiency, we see a TFlops increase to 5.07 from 2.3.","__index_level_0__":4848}
+{"text":"Thus, we\u2019ve increased our training throughput by over 200% (2.19x) due to providing greater model info to FSDP! The transformer wrapping policy results in more fine-grained and balanced FSDP units each holding a layer class, which leads to a more effective communication-computation overlap.","__index_level_0__":4849}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_9.png\" width=\"70%\">\n<\/p>","__index_level_0__":4850}
+{"text":"_Above: Graphical comparison of TFlops based on wrapper type_","__index_level_0__":4851}
+{"text":"If you are training a Transformer model, it pays to configure your training with FSDP using the transformer wrapper. For more information on how to isolate your layer class, please see our in depth video on Transformer wrapping [here](https:\/\/www.youtube.com\/watch?v=HQeKwCsnH4k), where we walk through a number of transformers showing where the layer class can be found.","__index_level_0__":4852}
+{"text":"**Mixed precision - _use BF16 if you have an Ampere architecture GPU_**","__index_level_0__":4853}
+{"text":"FSDP supports a flexible mixed precision policy that gives you granular control over parameters, gradients and buffer data types. This lets you easily leverage BFloat16 or FP16 to increase your training speed by up to 70%. ","__index_level_0__":4854}
+{"text":"*Note that BFloat 16 is only available on Ampere type GPUs. On AWS this is available with p4dn and g5 instances.","__index_level_0__":4855}
+{"text":"By way of comparison, we can show a 77% speed improvement when comparing fully tuned BFloat16 vs FP32 on an 8B DeepVit model.","__index_level_0__":4856}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_10.png\" width=\"70%\">\n<\/p>","__index_level_0__":4857}
+{"text":"We have obtained even greater acceleration using BFloat16 in fine-tuning a 3B HuggingFace T5 model as shown in the figures below. We observed that because of the lower precision the validation loss of BFloat16 is slightly behind in the first few epochs, but it is able to catch up and results in the same final accuracy as FP32.","__index_level_0__":4858}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/largeblog_index_10a.png\" width=\"70%\">\n<\/p>","__index_level_0__":4859}
+{"text":"\nTo use mixed precision, we create a policy with our desired data types, and pass it in during the FSDP initialization.","__index_level_0__":4860}
+{"text":"To create our policy, we need to import the MixedPrecision class, and then define our custom policy using our customized class:","__index_level_0__":4861}
+{"text":"```python\nfrom torch.distributed.fsdp import MixedPrecision\nbfSixteen = MixedPrecision(\n   param_dtype=torch.bfloat16,\n   # Gradient communication precision.\n   reduce_dtype=torch.bfloat16,\n   # Buffer precision.\n   buffer_dtype=torch.bfloat16,\n)\nmodel = FSDP(\n       model,\n       auto_wrap_policy=transformer_auto_wrapper_policy,\n       mixed_precision=bfloatPolicy)\n```","__index_level_0__":4862}
+{"text":"You can mix and match the precision for parameters, gradients and buffers as you prefer:","__index_level_0__":4863}
+{"text":"```python\ncomboPolicy = MixedPrecision(\n        # Param precision\n        param_dtype=torch.bfloat16,\n        # Gradient communication precision.\n        reduce_dtype=torch.float32,\n        # Buffer precision.\n        buffer_dtype=torch.float32,\n    )\n```","__index_level_0__":4864}
+{"text":"For training with FP16, you will need to also use the ShardedGradScaler, which we will cover in subsequent posts. For BFloat16, it is a drop-in replacement.","__index_level_0__":4865}
+{"text":"**AnyPrecision Optimizer - _going beyond mixed precision with full BF16 training_**","__index_level_0__":4866}
+{"text":"Mixed precision training, both in FSDP and elsewhere, maintains the working weights in the reduced datatype (BF16 or FP16) while keeping the master weights in full FP32. The reason for the master weights in FP32 is that running in pure BF16 will result in \u2018weight stagnation\u2019, where very small weight updates are lost due to the lower precision, and the accuracy flatlines over time while FP32 weights can continue to improve from these small updates.","__index_level_0__":4867}
+{"text":"In order to resolve this dilemma, we can use the new AnyPrecision optimizer available in [TorchDistX](https:\/\/github.com\/pytorch\/torchdistx) (Torch Distributed Experimental) that allows you to successfully train and keep the master weights in pure BF16 instead of FP32. In addition, unlike the typical storage of optimizer states in FP32, AnyPrecision is able to maintain states in pure BF16 as well. \n \nAnyPrecision enables pure BF16 training by maintaining an extra buffer that tracks the precision lost during the weight updates and re-applies that during the next update\u2026effectively resolving the weight stagnation issue without requiring FP32. \n \nAs a comparison of the throughput gains available with pure BF16 training using AnyPrecision, we ran experiments using FSDP with the T5 11B model with regular FP32 training, Mixed Precision training with BF16, and pure BF16 training using the AnyPrecision optimizer on 3 nodes with A100 gpus as mentioned previously. ","__index_level_0__":4868}
+{"text":"<p style=\"text-align:center\">\n<img src=\"\/assets\/images\/largeblog_index_11.png\" width=\"70%\">\n<\/p>","__index_level_0__":4869}
+{"text":"As shown above, training with AnyPrecision and pure BF16 resulted in 2x the throughput vs Mixed Precision, and over 20x improvement vs FP32.","__index_level_0__":4870}
+{"text":"The potential tradeoff is the impact on final accuracy - in the cases we tested, the accuracy was equal or better than FP32 due to a regularization effect from the slightly reduced precision, but your results may vary. \n \nAnyPrecision optimizer is available for you to test with [here](https:\/\/github.com\/pytorch\/torchdistx), and is a drop in replacement for AdamW optimizer. ","__index_level_0__":4871}
+{"text":"**Activation checkpointing - _increasing throughput by trading compute for memory_**","__index_level_0__":4872}
+{"text":"<p style=\"text-align:center\">\n<img src=\"\/assets\/images\/largeblog_index_12.png\" width=\"70%\">\n<\/p>","__index_level_0__":4873}
+{"text":"**FSDP supports activation checkpointing once the model has been sharded**, and makes it easy to implement. The graph above shows ~4x throughput improvement using activation checkpointing.","__index_level_0__":4874}
+{"text":"Activation checkpointing is where the intermediate activations are freed during the forward pass, and a checkpoint is left as a placeholder. This generally increases available GPU memory by over 30%.","__index_level_0__":4875}
+{"text":"The tradeoff is that during the backward pass, these previously removed intermediate activations must be re-calculated again using information in the checkpoint (duplicate compute), but by leveraging the increased GPU memory, one can increase the batch size such that the net throughput can increase substantially.","__index_level_0__":4876}
+{"text":"```python\n# verify we have FSDP activation support ready by importing:\nfrom torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (\n   checkpoint_wrapper,\n   CheckpointImpl,\n   apply_activation_checkpointing_wrapper,\n)\n```","__index_level_0__":4877}
+{"text":"\nThe steps required to implement activation checkpointing is to first import the FSDP checkpointing functions. We need declare our checkpointer wrapper type which is non-reentrant and create a check function to identify which layer to wrap as follows","__index_level_0__":4878}
+{"text":"```python\nnon_reentrant_wrapper = partial(\n    checkpoint_wrapper,\n    offload_to_cpu=False,\n    checkpoint_impl=CheckpointImpl.NO_REENTRANT,\n)\ncheck_fn = lambda submodule: isinstance(submodule, T5Block)\n```","__index_level_0__":4879}
+{"text":"```python\napply_activation_checkpointing_wrapper(\n       model, checkpoint_wrapper_fn=non_reentrant_wrapper, check_fn=check_fn\n   )\n```","__index_level_0__":4880}
+{"text":"_Important note - this must be run after the model has been initialized with FSDP._","__index_level_0__":4881}
+{"text":"However, hopefully you\u2019ve seen how some initial tuning with FSDP options can have a large impact on your training performance. ","__index_level_0__":4882}
+{"text":"With that, we turn our attention from how to scale within FSDP, to how to scale your server hardware for FSDP using AWS.","__index_level_0__":4883}
+{"text":"**Large Scale Training with FSDP on AWS - _For multi-node prioritize high speed network_**","__index_level_0__":4884}
+{"text":"AWS provides several services that can be used to run distributed training with FSDP: [Amazon EC2 Accelerated Computing instances](https:\/\/aws.amazon.com\/ec2\/instance-types\/#Accelerated_Computing), AWS [ParallelCluster](https:\/\/aws.amazon.com\/hpc\/parallelcluster\/), and Amazon [Sagemaker](https:\/\/aws.amazon.com\/sagemaker\/features\/?nc=sn&loc=2).","__index_level_0__":4885}
+{"text":"In this series of blog posts, we used [Amazon EC2 p4d](https:\/\/aws.amazon.com\/ec2\/instance-types\/p4\/) instances in a single-instance multi-GPU configuration and in a multi-instance configuration using AWS [ParallelCluster](https:\/\/aws.amazon.com\/hpc\/parallelcluster\/) and SageMaker in order to run our training jobs.","__index_level_0__":4886}
+{"text":"Here, we\u2019ll focus specifically on AWS parallel cluster and provide an overview of how to utilize it for training purposes.","__index_level_0__":4887}
+{"text":"**AWS ParallelCluster Setup**","__index_level_0__":4888}
+{"text":"<p>AWS ParallelCluster is an open source, cluster management tool that makes it easy for you to deploy and manage High Performance Computing (HPC) clusters on AWS.  AWS ParallelCluster uses yaml configuration files to provision all the necessary resources. It also supports multiple instance types, job submission queues, shared file systems like <a href=\"https:\/\/aws.amazon.com\/efs\/?trk=3c5ce89c-8865-47a3-bec3-f6820351aa6d&sc_channel=ps&sc_campaign=acquisition&sc_medium=ACQ-P|PS-GO|Non-Brand|Desktop|SU|Storage|Solution|US|EN|DSA&ef_id=Cj0KCQjwuaiXBhCCARIsAKZLt3l6dtldpE152xuxTMa3mbUbaqtTXwsBdfDRIzCL8cw3NO5DO_y1vOgaAj1pEALw_wcB:G:s&s_kwcid=AL!4422!3!579408162404!!!g!!\">Amazon EFS<\/a> (NFS) or <a href=\"https:\/\/aws.amazon.com\/fsx\/lustre\/?refid=3c5ce89c-8865-47a3-bec3-f6820351aa6d\" target=\"_blank\">Amazon FSx for Lustre<\/a>, and job schedulers like AWS Batch and Slurm.<\/p>","__index_level_0__":4889}
+{"text":"<p style=\"text-align:center\">\n<img src=\"\/assets\/images\/largeblog_index_13.png\" width=\"70%\">\n<\/p>","__index_level_0__":4890}
+{"text":"**Workflow on Clusters**","__index_level_0__":4891}
+{"text":"The high level idea is to have a cluster that has a head node which controls the compute nodes. The actual training job runs on the compute nodes. Overall steps to run a training job on a cluster are as follows:","__index_level_0__":4892}
+{"text":"1. Set up an AWS ParallelCuster (we discuss below)\n2. Connect to the head node, and import the training code\/ setup the environment.\n3. Pull the data and place it in a shared folder that compute nodes can access (FSx Lustre drive).\n4. Run the training job using a job scheduler (in this case Slurm).","__index_level_0__":4893}
+{"text":"**Setup AWS ParallelCuster**","__index_level_0__":4894}
+{"text":"To setup AWS ParallelCluster,","__index_level_0__":4895}
+{"text":"1.  **Deploy a network stack.** This step is optional since you could use your account default VPC and let AWS ParallelCluster create your subnets and security groups. However, we prefer to compartmentalize our desired network infrastructure and do this deployment via a CloudFormation stack.","__index_level_0__":4896}
+{"text":"    Since we deploy a public and a private subnet, we want to create them into an Availability Zone that contains our target instances, in this case p4d. We consult their availability in the region we use (us-east-1) through the following AWS CLI command:","__index_level_0__":4897}
+{"text":"    `aws ec2 describe-instance-type-offerings --location-type availability-zone \\ --filters Name=instance-type,Values=p4d.24xlarge --region us-east-1 --output table`","__index_level_0__":4898}
+{"text":"    We see three availability zones containing p4d instances, we pick one of them (`us-east-1c`, yours may be different) when deploying our network stack. This can be done with the AWS Console or the AWS CLI. In our case we use the latter as follows","__index_level_0__":4899}
+{"text":"    `aws cloudformation create-stack --stack-name VPC-Large-Scale --capabilities CAPABILITY_IAM --template-body file:\/\/VPC-Large-Scale.yaml --parameters ParameterKey=SubnetsAZ,ParameterValue=us-east-1c`","__index_level_0__":4900}
+{"text":"    CloudFormation will deploy our new VPC, subnets, security groups and endpoints on our behalf. Once done, you can retrieve the IDs of the public and private subnets by querying the stack outputs and the values `PublicSubnet` and `PrivateSubnet`.","__index_level_0__":4901}
+{"text":"    For example, using the AWS CLI for the private subnet:","__index_level_0__":4902}
+{"text":"    `aws cloudformation describe-stacks --stack-name VPC-Large-Scale --query \"Stacks[0].Outputs[?OutputKey=='PrivateSubnet'].OutputValue\" --output text`","__index_level_0__":4903}
+{"text":"2.  **Create ParallelCluster,** The cluster configuration file specifies the resources for our cluster. These resources include instance type for Head node, compute nodes, access to S3 buckets, shared storage where our data will be located. We will use Amazon FSx for Lustre that offers a fully managed shared storage service with [Lustre](<https:\/\/en.wikipedia.org\/wiki\/Lustre_(file_system)>).","__index_level_0__":4904}
+{"text":"    [Here](https:\/\/github.com\/lessw2020\/t5_11\/blob\/main\/hpc-cluster\/cluster.yaml) is an example of a cluster configuration file. We can use AWs ParallelCluster CLI to create the cluster. Please note that the private and public subnet IDs will need to be replaced by the ones you retrieved earlier. You will be able to control the cluster using the AWS ParallelCluster CLI to start, stop, pause, etc.","__index_level_0__":4905}
+{"text":"    ```\n    pcluster create-cluster --cluster-name my-hpc-cluster --cluster-configuration cluster.yaml\n    ```","__index_level_0__":4906}
+{"text":"3.  **SSH to Head node -** once the cluster is ready, we can connect to the Head node using the SSH protocol, pull our training code with and place the data in the shared storage specified in the cluster configuration file.","__index_level_0__":4907}
+{"text":"        pcluster ssh --cluster-name cluster -i your-key_pair","__index_level_0__":4908}
+{"text":"4.  **Launch the training job -** now that we have the data and training code, we can launch the slurm job for training. Here is an [example](https:\/\/github.com\/lessw2020\/t5_11\/blob\/main\/hpc-cluster\/modified-bert.slurm) of a slurm script to launch the job using torchrun.","__index_level_0__":4909}
+{"text":"More details on how to set up the cluster is out of the scope of this post, however we will have a separate post on it.","__index_level_0__":4910}
+{"text":"**What\u2019s next?**","__index_level_0__":4911}
+{"text":"With this post we provided a high level overview of FSDP and how it efficiently scales distributed AI training. The flowchart included will help provide a checklist for you to review tuning options discussed such as the transformer wrapper and activation checkpointing. ","__index_level_0__":4912}
+{"text":"In the next posts, we will continue with the T5 model and go deeper into each of the topics above, specifically with sharding strategy and other optimizations to provide more insight and details. For now, a good reference for the sharding strategy is in our video tutorial [here](https:\/\/www.youtube.com\/watch?v=a3iW6Cggccw&list=PL_lsbAsL_o2BT6aerEKgIoufVD_fodnuT&index=5):","__index_level_0__":4913}
+{"text":"If you have questions or find an issue, please find the authors [Less](https:\/\/www.linkedin.com\/in\/less-wright-22b59017\/), [Hamid](https:\/\/www.linkedin.com\/in\/hamid-nazeri\/) and [Geeta](https:\/\/www.linkedin.com\/in\/geetachauhan\/) or open an issue on[ PyTorch github](https:\/\/github.com\/pytorch\/pytorch).","__index_level_0__":4914}
+{"text":"**Special thanks to:**","__index_level_0__":4915}
+{"text":"Pytorch Distributed team, Shen Li, Rohan Varma, Yanli Zhao, Andrew Gu, Anjali Sridhar, Ana Simoes, Pierre-Yves Aquilanti, Sundar Ranganathan, and the broader AWS team for supporting us with providing infrastructure and technical support for running the large scale experiments.","__index_level_0__":4916}
+{"text":"**Resources:**","__index_level_0__":4917}
+{"text":"_[FSDP video series](https:\/\/www.youtube.com\/playlist?list=PL_lsbAsL_o2BT6aerEKgIoufVD_fodnuT)_","__index_level_0__":4918}
+{"text":"_[Getting started with FSDP](https:\/\/pytorch.org\/tutorials\/intermediate\/FSDP_tutorial.html)_","__index_level_0__":4919}
+{"text":"_[Advanced tutorial on FSDP](https:\/\/pytorch.org\/tutorials\/intermediate\/FSDP_adavnced_tutorial.html)_","__index_level_0__":4920}
+{"text":"_[API documentation](https:\/\/pytorch.org\/docs\/stable\/fsdp.html?highlight=fsdp#module-torch.distributed.fsdp)_","__index_level_0__":4921}
+{"text":"    td{\n        border: 1px solid black;\n    }\n    \n    article.pytorch-article table tr td:first-of-type{\n        padding: 0.3125rem;\n    }","__index_level_0__":4923}
+{"text":"    article.pytorch-article table td {\n    padding: 0.3125rem;\n    }\n}","__index_level_0__":4924}
+{"text":"<\/style> \n source: https:\/\/pytorch.org\/blog\/efficient-large-scale-training-with-pytorch\/ \n category: pytorch blogs","__index_level_0__":4925}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Performance Debugging of Production PyTorch Models at Meta\"\nauthor: CK Luk, Lei Tian\nfeatured-img: \"\/assets\/images\/performance-debugging-of-production-pytorch-models-at-meta-1.png\"\n---","__index_level_0__":4926}
+{"text":"## 1. Meta\u2019s AI Performance Profiling (MAIProf)","__index_level_0__":4927}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/performance-debugging-of-production-pytorch-models-at-meta-1.png\" width=\"90%\">\n<\/p>","__index_level_0__":4928}
+{"text":"<p align=\"center\">\n<b>Figure 1: A simplified illustration of the Meta\u2019s AI performance profiling (MAIProf) infrastructure.<\/b>\n<\/p>","__index_level_0__":4929}
+{"text":"Figure 1 gives a simplified illustration of the AI performance profiling infrastructure at Meta. ML research and performance engineers submit through the User Portal a profiling request for a training job to the Profiling Service, which subsequently broadcasts the request to all the GPU hosts running the training job. When the Monitoring Daemon on a GPU host receives the profiling request, it will notify the Kineto GPU tracer (built on top of NVIDIA\u2019s libcupti) inside the PyTorch program corresponding to the training job. As a result, Kineto traces will be collected and uploaded to the Object Store asynchronously (in more details: there is one Kineto trace collected for each individual GPU, each is treated and stored as a blob; an example will be given in Section 2). Meanwhile, MAIProf also collects a variety of aggregated performance metrics: the Monitoring Daemon on every GPU host continuously reads performance counters from NVIDIA\u2019s DCGM\/NVML and logs them to a Time Series DB.","__index_level_0__":4930}
+{"text":"Once both trace and metrics collections are completed, the Profiling Service will automatically download traces from the Object Store for trace analysis and performance metrics from the Time Series DB for metric analysis. Finally, an overall profiling report with detailed and insightful analysis is delivered to the user.","__index_level_0__":4931}
+{"text":"To serve production uses, we deliberately made the following design choices for MAIProf:","__index_level_0__":4932}
+{"text":"- **No source-code change required in the PyTorch models**: profiling is triggered by sampling the execution of an unmodified model for a user-specified amount of time.\n- **Provide a holistic view of performance**: MAIProf performs system-wide analysis that cover both CPU and GPU. Under the hood, it invokes various CPU tools (e.g., Python tracer, Autograd Observer) and GPU tools (e.g., Kineto, DCGM) and correlates their results. \n- **Provide multiple tools that target a wide range of AI partitioners**: At Meta, there are engineers with different backgrounds who may need to tune their AI workload performance. Some of them are AI experts while others are general software engineers. Therefore, MAIProf provides a variety of tools for different levels of performance debugging, from high-level automatic trace comprehension to low-level trace analysis.\n- **Support distributed GPU profiling**: MAIProf can collect profiling data from multiple hosts, each with multiple GPUs. It then shows a combined view\/analysis of the entire system.\n- **Highly scalable**: MAIProf is built as a service on top of existing infrastructures in Meta data centers such as a scalable storage system called Manifold. Its profiling capability can be easily scaled by adding more machines in the service pool with the increase of workloads.","__index_level_0__":4933}
+{"text":"## 2. Case Study: Optimizing a Protection PyTorch Model","__index_level_0__":4934}
+{"text":"To be concrete, we use a case study on a protection PyTorch model used in production. First, we discuss our steps for identifying the performance bottlenecks in the model with MAIProf. Then we describe the corresponding optimizations applied and their impacts.","__index_level_0__":4935}
+{"text":"### 2.1 Performance Bottlenecks","__index_level_0__":4936}
+{"text":"#### Step 1: ","__index_level_0__":4937}
+{"text":"Inspect the CPU and GPU utilization on the same timeline, as shown in Figure 2.","__index_level_0__":4938}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/performance-debugging-of-production-pytorch-models-at-meta-2.png\" width=\"90%\">\n<\/p>","__index_level_0__":4939}
+{"text":"<p align=\"center\">\n<b>Figure 2: CPU usage over time (the top) vs. GPU usage over time (the bottom).<\/b>\n<\/p>","__index_level_0__":4940}
+{"text":"The first performance anomaly we noticed in Figure 2 is the pattern: *\u201cGPU-idle, GPU-active, GPU-idle, GPU-active \u2026\u201d* throughout the training. Overall, the GPU is idle for more than half of the training time (this is bad for performance because the GPU is a higher-performance device and so we want it to be utilized as much as possible).","__index_level_0__":4941}
+{"text":"#### Step 2:","__index_level_0__":4942}
+{"text":"Collect a Python function call trace on the CPU with MAIProf while the GPU is idle, which is shown in Figure 3.","__index_level_0__":4943}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/performance-debugging-of-production-pytorch-models-at-meta-3.png\" width=\"100%\">\n<\/p>","__index_level_0__":4944}
+{"text":"<p align=\"center\">\n<b>Figure 3: A Python call trace.<\/b>\n<\/p>","__index_level_0__":4945}
+{"text":"The Python trace shows that most of the CPU time is spent inside a Python function `sharded_iterrows()`. From the source code of the model, we learned that this function processes a big feature table in parallel. The number of worker threads used is controlled by a configurable parameter (`num_worker_threads`). Also, after investigating how the feature table is generated, we understood the performance anomaly: the training dataset is too large to fit in the CPU memory all at once; it needs to be broken into multiple sub-datasets, each has sufficient data for running 10 epochs. Consequently, a new sub-dataset needs to be read from the disk to memory every 10 epochs,  during which the GPU is totally idle.","__index_level_0__":4946}
+{"text":"#### Step 3:","__index_level_0__":4947}
+{"text":"Collect GPU performance metrics, which is shown in Figure 4.","__index_level_0__":4948}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/performance-debugging-of-production-pytorch-models-at-meta-4.png\" width=\"100%\">\n<\/p>","__index_level_0__":4949}
+{"text":"<p align=\"center\">\n<b>Figure 4: GPU performance metrics in MAIProf.<\/b>\n<\/p>","__index_level_0__":4950}
+{"text":"We made the following observations from Figure 4:","__index_level_0__":4951}
+{"text":"- The streaming multiprocessor (SM) runs the model\u2019s CUDA kernels. Its utilization [1] is 9.1%, indicating that the parallel compute units on the GPU are not well utilized.\n- Tensor Core utilization is 0, meaning that Tensor Core (the mixed-precision compute unit on GPU) [2] is not used at all.\n- Max GPU memory utilization is 47.13%, indicating that half of the GPU memory is left unused.","__index_level_0__":4952}
+{"text":"#### Step 4:","__index_level_0__":4953}
+{"text":"Collect a GPU trace (aka Kineto trace) of the training loop as shown in Figure 5.","__index_level_0__":4954}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/performance-debugging-of-production-pytorch-models-at-meta-5.png\" width=\"100%\">\n<\/p>","__index_level_0__":4955}
+{"text":"<p align=\"center\">\n<b>Figure 5: A GPU trace (aka Kineto trace) of the training loop.<\/b>\n<\/p>","__index_level_0__":4956}
+{"text":"Since commonly used PyTorch functions are already annotated, their names are automatically shown on the trace. With them, we can roughly divide the trace into the four phases in a training iteration: (1) data loading, (2) forward pass, (3) backward pass, (4) gradient optimization (note: In Figure 5, the \u201coptimizer\u201d phase is from the previous batch while the other three phases are from the current batch).","__index_level_0__":4957}
+{"text":"### 2.2 Optimizations","__index_level_0__":4958}
+{"text":"We performed four simple optimizations that target the bottlenecks identified above, each requiring only a change in a config parameter or at most a few source lines. They are listed in Figure 6.","__index_level_0__":4959}
+{"text":"| Optimization | Amount of changes | Bottlenecks addressed |\n| ------------ | ----------------- | --------------------- |\n|Tune `num_worker_threads` by trying a few possible values within the number of CPU cores on each host. | 1 source line | GPU totally idle time |\n| Double the batch sizes | 2 config parameters | GPU memory under-utilization |\n| Use [automatic mixed precision](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/amp_recipe.html) in PyTorch | 13 source lines | Zero Tensor Core utilization |\n| Use [mulitensor optimizer](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.optim.AdamW.html#torch.optim.AdamW) in PyTorch | 1 source line | Many small GPU kernels in the optimizer |","__index_level_0__":4960}
+{"text":"<p align=\"center\">\n<b>Figure 6: Four simple optimizations applied.<\/b>\n<\/p>","__index_level_0__":4961}
+{"text":"## 3. Concluding Remarks","__index_level_0__":4962}
+{"text":"Performance tuning for PyTorch in production environments is increasingly important. A capable performance-debugging tool is a key to this process. We demonstrate with a case study on a production model that MAIProf is a powerful infrastructure for identifying optimization opportunities. ","__index_level_0__":4963}
+{"text":"At Meta, MAIProf has been used by 100s of engineers, from performance novices to experts, to identify many more types of bottlenecks. These include slow data loading, small and\/or slow GPU kernels, distributed training issues such as load imbalance and excessive communication. MAIProf covers major classes of models, including recommendation, vision, and natural language processing. In summary, it is now an indispensable tool for tuning the performance of production PyTorch workloads.","__index_level_0__":4964}
+{"text":"## References","__index_level_0__":4965}
+{"text":"[1] [https:\/\/docs.nvidia.com\/gameworks\/content\/developertools\/desktop\/analysis\/report\/ cudaexperiments\/kernellevel\/achievedoccupancy.htm](https:\/\/docs.nvidia.com\/gameworks\/content\/developertools\/desktop\/analysis\/report\/cudaexperiments\/kernellevel\/achievedoccupancy.htm)","__index_level_0__":4966}
+{"text":"[2] [https:\/\/www.nvidia.com\/en-us\/data-center\/tensor-cores\/](https:\/\/www.nvidia.com\/en-us\/data-center\/tensor-cores\/) \n source: https:\/\/pytorch.org\/blog\/performance-debugging-of-production-pytorch-models-at-meta\/ \n category: pytorch blogs","__index_level_0__":4967}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'The torch.fft module: Accelerated Fast Fourier Transforms with Autograd in PyTorch'\nauthor: Mike Ruberry, Peter Bell, and Joe Spisak \n---","__index_level_0__":4968}
+{"text":"The Fast Fourier Transform (FFT) calculates the Discrete Fourier Transform in O(n log n) time. It is foundational to a wide variety of numerical algorithms and signal processing techniques since it makes working in signals\u2019 \u201cfrequency domains\u201d as tractable as working in their spatial or temporal domains.","__index_level_0__":4969}
+{"text":"As part of PyTorch\u2019s goal to support hardware-accelerated deep learning and scientific computing, we have invested in improving our FFT support, and with PyTorch 1.8, we are releasing the ``torch.fft`` module. This module implements the same functions as NumPy\u2019s ``np.fft`` module, but with support for accelerators, like GPUs, and autograd. ","__index_level_0__":4970}
+{"text":"## Getting started","__index_level_0__":4971}
+{"text":"Getting started with the new ``torch.fft`` module is easy whether you are familiar with NumPy\u2019s ``np.fft`` module or not. While complete documentation for each function in the module can be found [here](https:\/\/pytorch.org\/docs\/1.8.0\/fft.html), a breakdown of what it offers is:","__index_level_0__":4972}
+{"text":"* ``fft``, which computes a complex FFT over a single dimension, and ``ifft``, its inverse\n* the more general ``fftn`` and ``ifftn``, which support multiple dimensions\n* The \u201creal\u201d FFT functions, ``rfft``, ``irfft``, ``rfftn``, ``irfftn``,  designed to work with signals that are real-valued in their time domains\n* The \"Hermitian\" FFT functions, ``hfft`` and ``ihfft``, designed to work with signals that are real-valued in their frequency domains\n* Helper functions, like ``fftfreq``, ``rfftfreq``, ``fftshift``, ``ifftshift``, that make it easier to manipulate signals","__index_level_0__":4973}
+{"text":"We think these functions provide a straightforward interface for FFT functionality, as vetted by the NumPy community, although we are always interested in feedback and suggestions!","__index_level_0__":4974}
+{"text":"To better illustrate how easy it is to move from NumPy\u2019s ``np.fft`` module to PyTorch\u2019s ``torch.fft`` module, let\u2019s look at a NumPy implementation of a simple low-pass filter that removes high-frequency variance from a 2-dimensional image, a form of noise reduction or blurring:","__index_level_0__":4975}
+{"text":"```python\nimport numpy as np\nimport numpy.fft as fft","__index_level_0__":4976}
+{"text":"def lowpass_np(input, limit):\n    pass1 = np.abs(fft.rfftfreq(input.shape[-1])) < limit\n    pass2 = np.abs(fft.fftfreq(input.shape[-2])) < limit\n    kernel = np.outer(pass2, pass1)\n    \n    fft_input = fft.rfft2(input)\n    return fft.irfft2(fft_input * kernel, s=input.shape[-2:])\n```","__index_level_0__":4977}
+{"text":"Now let\u2019s see the same filter implemented in PyTorch:","__index_level_0__":4978}
+{"text":"```python\nimport torch\nimport torch.fft as fft","__index_level_0__":4979}
+{"text":"def lowpass_torch(input, limit):\n    pass1 = torch.abs(fft.rfftfreq(input.shape[-1])) < limit\n    pass2 = torch.abs(fft.fftfreq(input.shape[-2])) < limit\n    kernel = torch.outer(pass2, pass1)\n    \n    fft_input = fft.rfft2(input)\n    return fft.irfft2(fft_input * kernel, s=input.shape[-2:])\n```","__index_level_0__":4980}
+{"text":"Not only do current uses of NumPy\u2019s ``np.fft`` module translate directly to ``torch.fft``, the ``torch.fft`` operations also support tensors on accelerators, like GPUs and autograd. This makes it possible to (among other things) develop new neural network modules using the FFT.","__index_level_0__":4981}
+{"text":"\n## Performance","__index_level_0__":4982}
+{"text":"The ``torch.fft`` module is not only easy to use \u2014 it is also fast! PyTorch natively supports Intel\u2019s MKL-FFT library on Intel CPUs, and NVIDIA\u2019s cuFFT library on CUDA devices, and we have carefully optimized how we use those libraries to maximize performance. While your own results will depend on your CPU and CUDA hardware, computing Fast Fourier Transforms on CUDA devices can be many times faster than computing it on the CPU, especially for larger signals.","__index_level_0__":4983}
+{"text":"In the future, we may add support for additional math libraries to support more hardware. See below for where you can request additional hardware support.","__index_level_0__":4984}
+{"text":"## Updating from older PyTorch versions","__index_level_0__":4985}
+{"text":"Some PyTorch users might know that older versions of PyTorch also offered FFT functionality with the ``torch.fft()`` function. Unfortunately, this function had to be removed because its name conflicted with the new module\u2019s name, and we think the new functionality is the best way to use the Fast Fourier Transform in PyTorch. In particular, ``torch.fft()`` was developed before PyTorch supported complex tensors, while the ``torch.fft`` module was designed to work with them.","__index_level_0__":4986}
+{"text":"PyTorch also has a \u201cShort Time Fourier Transform\u201d, ``torch.stft``, and its inverse ``torch.istft``. These functions are being kept but updated to support complex tensors. ","__index_level_0__":4987}
+{"text":"As mentioned, PyTorch 1.8 offers the torch.fft module, which makes it easy to use the Fast Fourier Transform (FFT) on accelerators and with support for autograd. We encourage you to try it out!","__index_level_0__":4989}
+{"text":"While this module has been modeled after NumPy\u2019s ``np.fft`` module so far, we are not stopping there. We are eager to hear from you, our community, on what FFT-related functionality you need, and we encourage you to create posts on our forums at [https:\/\/discuss.pytorch.org\/](https:\/\/discuss.pytorch.org\/), or [file issues on our Github](https:\/\/github.com\/pytorch\/pytorch\/issues\/new?assignees=&labels=&template=feature-request.md) with your feedback and requests. Early adopters have already started asking about Discrete Cosine Transforms and support for more hardware platforms, for example, and we are investigating those features now.","__index_level_0__":4990}
+{"text":"We look forward to hearing from you and seeing what the community does with PyTorch\u2019s new FFT functionality!\n \n source: https:\/\/pytorch.org\/blog\/the-torch.fft-module-accelerated-fast-fourier-transforms-with-autograd-in-pyTorch\/ \n category: pytorch blogs","__index_level_0__":4991}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch Internals Part II - The Build System\"\nauthor: \"Trevor Killeen\"\ndate: 2017-06-27 12:00:00 -0500\nredirect_from: \/2017\/06\/27\/Internals2.html\n---","__index_level_0__":4992}
+{"text":"In the first [post]({{ site.baseurl }}{% link _posts\/2017-5-11-a-tour-of-pytorch-internals-1.md %}) I explained how we generate a `torch.Tensor` object that you can use in your Python interpreter. Next, I will explore the build system for PyTorch. The PyTorch codebase has a variety of components:","__index_level_0__":4993}
+{"text":" - The core Torch libraries: TH, THC, THNN, THCUNN\n - Vendor libraries: CuDNN, NCCL\n - Python Extension libraries\n - Additional third-party libraries: NumPy, MKL, LAPACK","__index_level_0__":4994}
+{"text":"How does a simple invocation of `python setup.py install` do the work that allows you to call `import torch` and use the PyTorch library in your code?","__index_level_0__":4995}
+{"text":"The first part of this document will explain the build process from and end-user point of view. This will explain how we take the components above to build the library. The second part of the document will be important for PyTorch developers. It will document ways to improve your iteration speed by building only a subset of the code that you are working on.","__index_level_0__":4996}
+{"text":"### Setuptools and PyTorch's setup( ) function","__index_level_0__":4997}
+{"text":"Python uses [Setuptools](https:\/\/setuptools.readthedocs.io\/en\/latest\/index.html) to build the library. Setuptools is an extension to the original distutils system from the core Python library. The core component of Setuptools is the `setup.py` file which contains all the information needed to build the project. The most important function is the `setup()` function which serves as the main entry point. Let's take a look at the one in PyTorch:","__index_level_0__":4998}
+{"text":"```python\nsetup(name=\"torch\", version=version,\n      description=\"Tensors and Dynamic neural networks in Python with strong GPU acceleration\",\n      ext_modules=extensions,\n      cmdclass={\n          'build': build,\n          'build_py': build_py,\n          'build_ext': build_ext,\n          'build_deps': build_deps,\n          'build_module': build_module,\n          'develop': develop,\n          'install': install,\n          'clean': clean,\n      },\n      packages=packages,\n      package_data={'torch': [\n          'lib\/*.so*', 'lib\/*.dylib*',\n          'lib\/torch_shm_manager',\n          'lib\/*.h',\n          'lib\/include\/TH\/*.h', 'lib\/include\/TH\/generic\/*.h',\n          'lib\/include\/THC\/*.h', 'lib\/include\/THC\/generic\/*.h']},\n      install_requires=['pyyaml'],\n      )\n```","__index_level_0__":4999}
+{"text":"The function is composed entirely of keyword arguments, which serve two purposes:","__index_level_0__":5000}
+{"text":"- Metadata (e.g. name, description, version)\n- The contents of the package","__index_level_0__":5001}
+{"text":"We are concerned with #2. Let's break down the individual components:","__index_level_0__":5002}
+{"text":" - **ext_modules**: Python modules are either \"pure\" modules, containing only Python code, or \"extension\" modules written in the low-level language of the Python implementation. Here we are listing the extension modules in the build, including the main `torch._C` library that contains our Python Tensor\n - **cmdclass**: When using the `setup.py` script from the command line, the user must specify one or more \"commands\", code snippets that perform a specific action. For example, the \"install\" command builds and installs the package. This mapping routes specific commands to functions in `setup.py` that implement them\n - **packages**: The list of packages in the project. These are \"pure\" - i.e. they only contain Python code. These are defined elsewhere in `setup.py`\n - **package_data**: Additional files that need to be installed into a package: in this case the header files and shared libraries that the build will generate must be included in our installation\n - **install_requires**: In order to build PyTorch, we need pyyaml. Setuptools will handle making sure that pyyaml will be available, downloading and installing it if necessary","__index_level_0__":5003}
+{"text":"We will consider these components in more detail, but for now it is instructive to look at the end product of an installation -- i.e. what Setuptools does after building the code.","__index_level_0__":5004}
+{"text":"### site_packages","__index_level_0__":5005}
+{"text":"Third party packages are by default installed into the `lib\/<version>\/site_packages`  directory associated with your Python binary. For example, because I am using an [Miniconda](https:\/\/conda.io\/miniconda.html) environment, my Python binary is found at:","__index_level_0__":5006}
+{"text":"```bash\n(p3) killeent@devgpu047:pytorch (master)$ which python\n~\/local\/miniconda2\/envs\/p3\/bin\/python\n```\nAnd thus packages are installed into:","__index_level_0__":5007}
+{"text":"```bash\n\/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages\n```\nI installed PyTorch, and let's take a look into torch folder in site-packages:","__index_level_0__":5008}
+{"text":"```bash\n(p3) killeent@devgpu047:site-packages$ cd torch\n(p3) killeent@devgpu047:torch$ ls\nautograd  backends  _C.cpython-36m-x86_64-linux-gnu.so  cuda  distributed  _dl.cpython-36m-x86_64-linux-gnu.so  functional.py  __init__.py  legacy  lib  multiprocessing  nn  optim  __pycache__  serialization.py  _six.py  sparse  storage.py  _tensor_docs.py  tensor.py  _tensor_str.py  _thnn  _torch_docs.py  utils  _utils.py  version.py\n```","__index_level_0__":5009}
+{"text":"Note that everything we would expect to be here is here:","__index_level_0__":5010}
+{"text":" - All the \"pure\" packages are here [todo print packages from setup.py to explain]\n - The extension libraries are here - the ._C* and ._dl* shared libraries\n - The package_data is here: the contents of lib\/ match exactly what we described in the setup function:","__index_level_0__":5011}
+{"text":"```bash\n(p3) killeent@devgpu047:torch$ ls lib\/\ninclude     libnccl.so.1  libTHC.so.1   libTHCUNN.so.1  libTHNN.so.1  libTH.so.1   THCUNN.h  torch_shm_manager libnccl.so  libshm.so     libTHCS.so.1  libTHD.so.1     libTHPP.so.1  libTHS.so.1  THNN.h\n```","__index_level_0__":5012}
+{"text":"The Python interpreter looks into `site_packages` during an import. If we call `import torch` in our Python code it will find the module here and initialize and import it. You can read more about the import system [here](https:\/\/docs.python.org\/3\/tutorial\/modules.html).","__index_level_0__":5013}
+{"text":"### Building Individual Parts","__index_level_0__":5014}
+{"text":"Next, we will look at the various individual components of the build from start to finish. This will illustrate how we combine all the code we mentioned in the introduction.","__index_level_0__":5015}
+{"text":"### Backend Torch and Vendor Libraries","__index_level_0__":5016}
+{"text":"Let's take a look at the `install` cmd override in PyTorch's `setup.py`:","__index_level_0__":5017}
+{"text":"```python\nclass install(setuptools.command.install.install):","__index_level_0__":5018}
+{"text":"    def run(self):\n        if not self.skip_build:\n            self.run_command('build_deps')\n        setuptools.command.install.install.run(self)\n```","__index_level_0__":5019}
+{"text":"We note the first thing it does is run a command called \"build_deps\" - let's take a look at it's `run()` method:","__index_level_0__":5020}
+{"text":"```python\ndef run(self):\n        from tools.nnwrap import generate_wrappers as generate_nn_wrappers\n        build_all_cmd = ['bash', 'torch\/lib\/build_all.sh']\n        if WITH_CUDA:\n            build_all_cmd += ['--with-cuda']\n        if WITH_NCCL and not SYSTEM_NCCL:\n            build_all_cmd += ['--with-nccl']\n        if WITH_DISTRIBUTED:\n            build_all_cmd += ['--with-distributed']\n        if subprocess.call(build_all_cmd) != 0:\n            sys.exit(1)\n        generate_nn_wrappers()\n```","__index_level_0__":5021}
+{"text":"Here we note that that we have a shell script `build_all.sh` in the `torch\/lib\/` directory. This script is configurable by whether we are on a system with CUDA enabled, the NCCL library enabled, and PyTorch's distributed library enabled.","__index_level_0__":5022}
+{"text":"Let's take a look in `torch\/lib`:","__index_level_0__":5023}
+{"text":"```bash\n(p3) killeent@devgpu047:lib (master)$ ls\nbuild_all.sh  libshm  nccl  README.md  TH  THC  THCS  THCUNN  THD  THNN  THPP  THS\n```","__index_level_0__":5024}
+{"text":"Here we see the directories for all the backend libraries. `TH`, `THC`, `THNN`,  `THCUNN`, and `nccl` are [git subtrees](https:\/\/developer.atlassian.com\/blog\/2015\/05\/the-power-of-git-subtree\/) that are in sync with the libraries in e.g. [github.com\/torch](https:\/\/github.com\/torch\/torch7\/tree\/master\/lib\/TH). `THS`, `THCS`, `THD`, `THPP` and `libshm` are libraries specific to PyTorch. All of the libraries contain `CMakeLists.txt` - indicating they are built with CMake.","__index_level_0__":5025}
+{"text":"The `build_all.sh` is essentially a script that runs the CMake configure step on all of these libraries, and then `make install`. Let's run `.\/build_all.sh` and see what we are left with:","__index_level_0__":5026}
+{"text":"```bash\n(p3) killeent@devgpu047:lib (master)$ .\/build_all.sh --with-cuda --with-nccl --with-distributed\n[various CMake output logs]\n(p3) killeent@devgpu047:lib (master)$ ls\nbuild  build_all.sh  include  libnccl.so  libnccl.so.1  libshm  libshm.so  libTHC.so.1  libTHCS.so.1  libTHCUNN.so.1  libTHD.so.1  libTHNN.so.1  libTHPP.so.1  libTH.so.1  libTHS.so.1  nccl  README.md  TH  THC  THCS  THCUNN  THCUNN.h  THD  THNN  THNN.h  THPP  THS  tmp_install  torch_shm_manager\n```","__index_level_0__":5027}
+{"text":"Now there are a number of extra things in the directory:","__index_level_0__":5028}
+{"text":" - Shared library files for each library\n - Headers for `THNN` and `THCUNN`\n - `build` and `tmp_install` directories\n - The `torch_shm_manager` executable","__index_level_0__":5029}
+{"text":"Let's explore further. In the shell script, we create the `build` directory and a subdir for each library to build:","__index_level_0__":5030}
+{"text":"```bash\n# We create a build directory for the library, which will\n# contain the cmake output. $1 is the library to be built\n  mkdir -p build\/$1\n  cd build\/$1\n```","__index_level_0__":5031}
+{"text":"Thus e.g. `build\/TH` contains the CMake configuration output including the `Makefile` for building TH, and also the result of running make install in this directory.","__index_level_0__":5032}
+{"text":"Let's also look at `tmp_install`:","__index_level_0__":5033}
+{"text":"```bash\n(p3) killeent@devgpu047:lib (master)$ ls tmp_install\/\nbin  include  lib  share\n```","__index_level_0__":5034}
+{"text":"`tmp_install` looks like a standard install directory containing binaries, header files and library files. For example, `tmp_install\/include\/TH` contains all the `TH` headers, and `tmp_install\/lib\/` contains the `libTH.so.1` file.","__index_level_0__":5035}
+{"text":"So why have this directory? It is used to compile the libraries that depend on each other. For example, the `THC` library depends on the `TH` library and its headers. This is referenced in the build shell script as arguments to the `cmake` command:","__index_level_0__":5036}
+{"text":"```bash\n# install_dir is tmp_install\ncmake ...\n\t-DTH_INCLUDE_PATH=\"$INSTALL_DIR\/include\" \\\n\t-DTH_LIB_PATH=\"$INSTALL_DIR\/lib\" \\\n```","__index_level_0__":5037}
+{"text":"And indeed if we look at the `THC` library we built:","__index_level_0__":5038}
+{"text":"```bash\n(p3) killeent@devgpu047:lib (master)$ ldd libTHC.so.1\n\t...\n\tlibTH.so.1 => \/home\/killeent\/github\/pytorch\/torch\/lib\/tmp_install\/lib\/.\/libTH.so.1 (0x00007f84478b7000)\n```","__index_level_0__":5039}
+{"text":"The way the `build_all.sh` specifies the include and library paths is a little messy but this is representative of the overall idea. Finally, at the end of the script:","__index_level_0__":5040}
+{"text":"```bash\n# If all the builds succeed we copy the libraries, headers,\n# binaries to torch\/lib\ncp $INSTALL_DIR\/lib\/* .\ncp THNN\/generic\/THNN.h .\ncp THCUNN\/generic\/THCUNN.h .\ncp -r $INSTALL_DIR\/include .\ncp $INSTALL_DIR\/bin\/* .\n```","__index_level_0__":5041}
+{"text":"As we can see, at the end, we copy everything to the top-level `torch\/lib` directory - explaining the contents we saw above. We'll see why we do this next:","__index_level_0__":5042}
+{"text":"### NN Wrappers","__index_level_0__":5043}
+{"text":"Briefly, let's touch on the last part of the `build_deps` command: `generate_nn_wrappers()`.  We bind into the backend libraries using PyTorch's custom `cwrap` tooling, which we touched upon in a previous post. For binding `TH` and `THC` we manually write the YAML declarations for each function. However, due to the relative simplicity of the `THNN` and `THCUNN` libraries, we auto-generate both the cwrap declarations and the resulting C++ code.","__index_level_0__":5044}
+{"text":"The reason we copy the `THNN.h` and `THCUNN.h` header files into `torch\/lib` is that this is where the `generate_nn_wrappers()` code expects these files to be located. `generate_nn_wrappers()` does a few things:","__index_level_0__":5045}
+{"text":"1. Parses the header files, generating cwrap YAML declarations and writing them to output `.cwrap` files\n2. Calls `cwrap` with the appropriate plugins on these `.cwrap` files to generate source code for each\n3. Parses the headers *a second time* to generate `THNN_generic.h` - a library that takes `THPP` Tensors, PyTorch's \"generic\" C++ Tensor Library, and calls into the appropriate `THNN`\/`THCUNN` library function based on the dynamic type of the Tensor","__index_level_0__":5046}
+{"text":"If we take a look into `torch\/csrc\/nn` after running `generate_nn_wrappers()` we can see the output:","__index_level_0__":5047}
+{"text":"```bash\n(p3) killeent@devgpu047:nn (master)$ ls\nTHCUNN.cpp  THCUNN.cwrap  THNN.cpp  THNN.cwrap  THNN_generic.cpp  THNN_generic.cwrap  THNN_generic.h  THNN_generic.inc.h\n```","__index_level_0__":5048}
+{"text":"For example, the code generates cwrap like:","__index_level_0__":5049}
+{"text":"```\n[[\n  name: FloatBatchNormalization_updateOutput\n  return: void\n  cname: THNN_FloatBatchNormalization_updateOutput\n  arguments:\n    - void* state\n    - THFloatTensor* input\n    - THFloatTensor* output\n    - type: THFloatTensor*\n      name: weight\n      nullable: True\n    - type: THFloatTensor*\n      name: bias\n      nullable: True\n    - THFloatTensor* running_mean\n    - THFloatTensor* running_var\n    - THFloatTensor* save_mean\n    - THFloatTensor* save_std\n    - bool train\n    - double momentum\n    - double eps\n]]\n```","__index_level_0__":5050}
+{"text":"with corresponding `.cpp`:","__index_level_0__":5051}
+{"text":"```cpp\nextern \"C\" void THNN_FloatBatchNormalization_updateOutput(void*, THFloatTensor*, THFloatTensor*, THFloatTensor*, THFloatTensor*, THFloatTensor*, THFloatTensor*, THFloatTensor*, THFloatTensor*, bool, double, double);","__index_level_0__":5052}
+{"text":"PyObject * FloatBatchNormalization_updateOutput(PyObject *_unused, PyObject *args) {\n\t\/\/ argument checking, unpacking\n\t PyThreadState *_save = NULL;\n      try {\n        Py_UNBLOCK_THREADS;\n        THNN_FloatBatchNormalization_updateOutput(arg_state, arg_input, arg_output, arg_weight, arg_bias, arg_running_mean, arg_running_var, arg_save_mean, arg_save_std, arg_train, arg_momentum, arg_eps);\n        Py_BLOCK_THREADS;\n        Py_RETURN_NONE;\n      } catch (...) {\n        if (_save) {\n          Py_BLOCK_THREADS;\n        }\n        throw;\n      }","__index_level_0__":5053}
+{"text":"    ...\n}\n```","__index_level_0__":5054}
+{"text":"In the `THPP` generated code, the function looks like this:","__index_level_0__":5055}
+{"text":"```cpp\nvoid BatchNormalization_updateOutput(thpp::Tensor* input, thpp::Tensor* output, thpp::Tensor* weight, thpp::Tensor* bias, thpp::Tensor* running_mean, thpp::Tensor* running_var, thpp::Tensor* save_mean, thpp::Tensor* save_std, bool train, double momentum, double eps) {\n\t\/\/ Call appropriate THNN function based on tensor type, whether its on CUDA, etc.\n}\n```","__index_level_0__":5056}
+{"text":"We will look a little more at how these source files are used later.","__index_level_0__":5057}
+{"text":"### \"Building\" the Pure Python Modules","__index_level_0__":5058}
+{"text":"Now that we have built the backend libraries (the \"dependencies\") we can move forward with building the actual PyTorch code. The next Setuptools command that runs is `build_py`, which is used to build all the \"Pure\" python modules in our library. These are the \"packages\" passed to `setup.py`.","__index_level_0__":5059}
+{"text":"The packages are found using the Setuptools' utility function `find_packages()`:","__index_level_0__":5060}
+{"text":"```python\npackages = find_packages(exclude=('tools.*',))\n['torch', 'torch._thnn', 'torch.autograd', 'torch.backends', 'torch.cuda', 'torch.distributed', 'torch.legacy', 'torch.multiprocessing', 'torch.nn', 'torch.optim', 'torch.sparse', 'torch.utils', 'torch.autograd._functions', 'torch.backends.cudnn', 'torch.legacy.nn', 'torch.legacy.optim', 'torch.nn._functions', 'torch.nn.backends', 'torch.nn.modules', 'torch.nn.parallel', 'torch.nn.utils', 'torch.nn._functions.thnn', 'torch.utils.data', 'torch.utils.ffi', 'torch.utils.serialization', 'torch.utils.trainer', 'torch.utils.backcompat', 'torch.utils.trainer.plugins']\n```","__index_level_0__":5061}
+{"text":"As we can see, `find_package` has recursively traversed the `torch` directory, finding all the directory paths that have an `__init__.py` file.","__index_level_0__":5062}
+{"text":"When building with Setuptools, the tool creates a `build` directory in the distribution root, i.e. the same location as the `setup.py` file. Because PyTorch is composed of both \"Pure\" python modules and Extension Modules, we need to preserve information about the Operating System and Python version used when performing the build. So if we look in my `build` directory, we see:","__index_level_0__":5063}
+{"text":"```bash\n(p3) killeent@devgpu047:pytorch (master)$ ls build\nlib.linux-x86_64-3.6  temp.linux-x86_64-3.6\n```","__index_level_0__":5064}
+{"text":"This indicates that I've built the project on `linux-x86-64` using Python 3.6. The lib directory contains the library files, while the temp directory contains files generated during the build that aren't needed in the final installation.","__index_level_0__":5065}
+{"text":"Because \"Pure\" python modules are just Python code, and don't need to be \"compiled\", the `build_py` process simply copies files from their locations as found by `find_packages` to the equivalent location in `build\/`. So our build output is littered with lines like:","__index_level_0__":5066}
+{"text":"```bash\ncopying torch\/autograd\/_functions\/blas.py -> build\/lib.linux-x86_64-3.6\/torch\/autograd\/_functions\n```","__index_level_0__":5067}
+{"text":"We also noted earlier that we could pass files and directories to the `package_data` keyword argument to the main `setup()` function, and that Setuptools would handle copying those files to the installation location. During `build_py`, these files are copied to the `build\/` directory, so we also see lines like:","__index_level_0__":5068}
+{"text":"```bash\ncopying torch\/lib\/libTH.so.1 -> build\/lib.linux-x86_64-3.6\/torch\/lib\n...\ncopying torch\/lib\/include\/THC\/generic\/THCTensor.h -> build\/lib.linux-x86_64-3.6\/torch\/lib\/include\/THC\/generic\n```","__index_level_0__":5069}
+{"text":"### Building the Extension Modules","__index_level_0__":5070}
+{"text":"Finally, we need to build the Extension Modules, i.e. the PyTorch modules written in C++ using the CPython backend. This also constitutes the majority of the code logic in `setup.py`. Our overridden `build_ext` Command has some special logic before the extensions themselves are actually built:","__index_level_0__":5071}
+{"text":"```python\nfrom tools.cwrap import cwrap\nfrom tools.cwrap.plugins.THPPlugin import THPPlugin\nfrom tools.cwrap.plugins.ArgcountSortPlugin import ArgcountSortPlugin\nfrom tools.cwrap.plugins.AutoGPU import AutoGPU\nfrom tools.cwrap.plugins.BoolOption import BoolOption\nfrom tools.cwrap.plugins.KwargsPlugin import KwargsPlugin\nfrom tools.cwrap.plugins.NullableArguments import NullableArguments\nfrom tools.cwrap.plugins.CuDNNPlugin import CuDNNPlugin\nfrom tools.cwrap.plugins.WrapDim import WrapDim\nfrom tools.cwrap.plugins.AssertNDim import AssertNDim\nfrom tools.cwrap.plugins.Broadcast import Broadcast\nfrom tools.cwrap.plugins.ProcessorSpecificPlugin import ProcessorSpecificPlugin\n        thp_plugin = THPPlugin()\n        cwrap('torch\/csrc\/generic\/TensorMethods.cwrap', plugins=[\n            ProcessorSpecificPlugin(), BoolOption(), thp_plugin,\n            AutoGPU(condition='IS_CUDA'), ArgcountSortPlugin(), KwargsPlugin(),\n            AssertNDim(), WrapDim(), Broadcast()\n        ])\n        cwrap('torch\/csrc\/cudnn\/cuDNN.cwrap', plugins=[\n            CuDNNPlugin(), NullableArguments()\n        ])\n```","__index_level_0__":5072}
+{"text":"Recall above that I documented that we auto-generated C++ code for calling into the `THNN` etc. libraries. Here is where we bind `TH`, `THC` and `CuDNN`. We take the YAML declarations in `TensorMethods.cwrap`, and use them to generate output C++ source files that contain implementations that work within PyTorch's C++ Ecosystem. For example, a simple declaration like zero_:","__index_level_0__":5073}
+{"text":"```\n[[\n  name: zero_\n  cname: zero\n  return: self\n  arguments:\n    - THTensor* self\n]]\n```","__index_level_0__":5074}
+{"text":"Generates code like:","__index_level_0__":5075}
+{"text":"```cpp\n PyObject * THPTensor_(zero_)(PyObject *self, PyObject *args, PyObject *kwargs) {\n\t...\n\tTHTensor_(zero)(LIBRARY_STATE arg_self);\n\t...\n}\n```","__index_level_0__":5076}
+{"text":"In the previous post we documented how these functions are tied to specific Tensor types, so I won't expand on that there. For the build process its enough to know that these C++ files are generated prior to the extension being built, because these source files are used during Extension compilation.","__index_level_0__":5077}
+{"text":"### Specifying the Extensions","__index_level_0__":5078}
+{"text":"Unlike pure modules, it\u2019s not enough just to list modules or packages and expect the Setuptools to go out and find the right files; you have to specify the extension name, source file(s), and any compile\/link requirements (include directories, libraries to link with, etc.).","__index_level_0__":5079}
+{"text":"The bulk (200~ LOC at the time of this writing) of the `setup.py` goes into specifying how to build these Extensions. Here, some of the choices we make in `build_all.sh` begin to make sense. For example, we saw that our build script specified a `tmp_install` directory where we installed our backend libraries. In our `setup.py` code, we reference this directory when adding to the list of directories containing header files to include:","__index_level_0__":5080}
+{"text":"```python\n# tmp_install_path is torch\/lib\/tmp_install\ninclude_dirs += [\n    cwd,\n    os.path.join(cwd, \"torch\", \"csrc\"),\n    tmp_install_path + \"\/include\",\n    tmp_install_path + \"\/include\/TH\",\n    tmp_install_path + \"\/include\/THPP\",\n    tmp_install_path + \"\/include\/THNN\",\n```","__index_level_0__":5081}
+{"text":"Similarly, we copied the shared object libraries to `torch\/csrc` at the end of the `build_all.sh` script. We reference these locations directly in our `setup.py` code when identifying libraries that we may link against:","__index_level_0__":5082}
+{"text":"```python\n# lib_path is torch\/lib\nTH_LIB = os.path.join(lib_path, 'libTH.so.1')\nTHS_LIB = os.path.join(lib_path, 'libTHS.so.1')\nTHC_LIB = os.path.join(lib_path, 'libTHC.so.1')\nTHCS_LIB = os.path.join(lib_path, 'libTHCS.so.1')\nTHNN_LIB = os.path.join(lib_path, 'libTHNN.so.1')\n# ...\n```","__index_level_0__":5083}
+{"text":"Let's consider how we build the main `torch._C` Extension Module:","__index_level_0__":5084}
+{"text":"```python\nC = Extension(\"torch._C\",\n              libraries=main_libraries,\n              sources=main_sources,\n              language='c++',\n              extra_compile_args=main_compile_args + extra_compile_args,\n              include_dirs=include_dirs,\n              library_dirs=library_dirs,\n              extra_link_args=extra_link_args + main_link_args + [make_relative_rpath('lib')],\n              )\n```","__index_level_0__":5085}
+{"text":" - The main libraries are all the libraries we link against. This includes things like `shm`, PyTorch's shared memory management library, and also system libraries like `cudart` and `cudnn`. Note that the `TH` libraries *are not* listed here\n - The main sources are the C++ files that make up the C++ backend for PyTorch\n - The compile args are various flags that configure compilation. For example, we might want to add debug flags when compiling in debug mode\n - The include dirs are the paths to all the directories containing header files. This is also another example where the `build_all.sh` script is important - for example, we look for the `TH` header files in `torch\/lib\/tmp_install\/include\/TH` - which is the install location we specified with our CMake configuration\n - The library dirs are directories to search for shared libraries at link time. For example, we include `torch\/lib` - the location we copied our `.so` files to at the end of `build_all.sh`, but also the paths to the CUDA and CuDNN directories\n -  The link arguments are used when linking object files together to create the extension. In PyTorch, this includes more *normal* options like decided to link `libstdc++` statically. However, there is one key component: **this is where we link the backend TH libraries**. Note that we have lines like:","__index_level_0__":5086}
+{"text":"```python\n# The explicit paths to .so files we described above\nmain_link_args = [TH_LIB, THS_LIB, THPP_LIB, THNN_LIB]\n```","__index_level_0__":5087}
+{"text":"You might be wondering why we do this as opposed to adding these libraries to the list we pass to the `libraries` keyword argument. After all, that is a list of libraries to link against. The issue is that Lua Torch installs often set the `LD_LIBRARY_PATH` variable, and thus we could mistakenly link against a `TH` library built for Lua Torch, instead of the library we have built locally. This would be problematic because the code could be out of date, and also there are various configuration options for Lua Torch's `TH` that would not play nicely with PyTorch.","__index_level_0__":5088}
+{"text":"As such, we manually specify the paths to the shared libraries we generated directly to the linker.","__index_level_0__":5089}
+{"text":"There are other extensions needed to power PyTorch and they are built in a similar way. The Setuptools library invokes the C++ compiler and linker to build all of these extensions. If the builds succeed, we have successfully *built* the PyTorch library and we can move on to installation.","__index_level_0__":5090}
+{"text":"### Installation","__index_level_0__":5091}
+{"text":"After building has finished, installation is quite simple. We simply have to copy everything from our `build\/lib.linux-x86_64-3.6` directory to the appropriate installation directory. Recall that we noted above that this directory is the `site_packages` directory associated with our Python binary. As a result, we see lines like:","__index_level_0__":5092}
+{"text":"```bash\nrunning install_lib\ncreating \/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages\/torch\ncopying build\/lib.linux-x86_64-3.6\/torch\/_C.cpython-36m-x86_64-linux-gnu.so -> \/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages\/torch\ncopying build\/lib.linux-x86_64-3.6\/torch\/_dl.cpython-36m-x86_64-linux-gnu.so -> \/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages\/torch\ncreating \/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages\/torch\/_thnn\ncopying build\/lib.linux-x86_64-3.6\/torch\/_thnn\/_THNN.cpython-36m-x86_64-linux-gnu.so -> \/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages\/torch\/_thnn\ncopying build\/lib.linux-x86_64-3.6\/torch\/_thnn\/_THCUNN.cpython-36m-x86_64-linux-gnu.so -> \/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages\/torch\/_thnn\n```","__index_level_0__":5093}
+{"text":"Finally lets power up the Python interpreter. When the Python interpreter executes an import statement, it searches for Python code and extension modules along a search path. A default value for the path is configured into the Python binary when the interpreter is built.","__index_level_0__":5094}
+{"text":"```bash\n# note we are now in my home directory\n(p3) killeent@devgpu047:~$ python\nPython 3.6.1 |Continuum Analytics, Inc.| (default, Mar 22 2017, 19:54:23)\n[GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] on linux\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>> import sys\n>>> sys.path\n['', '\/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python36.zip', '\/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6', '\/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/lib-dynload', '\/home\/killeent\/.local\/lib\/python3.6\/site-packages', '\/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages', '\/home\/killeent\/github\/pytorch', '\/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages\/setuptools-27.2.0-py3.6.egg']\n```","__index_level_0__":5095}
+{"text":"As we can see, the `site-packages` directory we copied our PyTorch installation to is part of search path. Now let's load the `torch` module and see its location:","__index_level_0__":5096}
+{"text":"```python\n>>> import torch\n>>> import inspect\n>>> inspect.getfile(torch)\n'\/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/python3.6\/site-packages\/torch\/__init__.py'\n```","__index_level_0__":5097}
+{"text":"As we can see, we have loaded the module from `site_packages` as expected - and our build and installation is successful!","__index_level_0__":5098}
+{"text":"**Note:** Python prepends the empty string to `sys.path` to represent the current working directory - making it the first place we search for a module. So if we run Python from the pytorch directory, we would accidentally load the local version of PyTorch rather than our installed version. This is something to watch out for.","__index_level_0__":5099}
+{"text":"### Addendum - Developer Efficiency, 3rd Party Libraries, Things I Didn't Cover","__index_level_0__":5100}
+{"text":"The entire installation loop for PyTorch can be quite time-consuming. On my devserver, it takes around 5 minutes for an installation from source. Often times, when developing PyTorch, we only want to work on a subset of the entire project, and re-build only that subset in order to test changes. Fortunately, our build system enables this.","__index_level_0__":5101}
+{"text":"### Setuptools Develop Mode","__index_level_0__":5102}
+{"text":"The main tool that supports this is Setuptools `develop` command. The documentation states that:","__index_level_0__":5103}
+{"text":">This command allows you to deploy your project\u2019s source for use in one or more \u201cstaging areas\u201d where it will be available for importing. This deployment is done in such a way that changes to the project source are immediately available in the staging area(s), without needing to run a build or install step after each change.","__index_level_0__":5104}
+{"text":"But how does it work? Suppose we run `python setup.py build develop` in the PyTorch directory. The `build` command is run, building our dependencies (`TH`, `THPP`, etc.) and the extension libraries. However, if we look inside `site-packages`:","__index_level_0__":5105}
+{"text":"```bash\n(p3) killeent@devgpu047:site-packages$ ls -la torch*\n-rw-r--r--. 1 killeent users 31 Jun 27 08:02 torch.egg-link\n```","__index_level_0__":5106}
+{"text":"Looking at the contents of the `torch.egg-link` file, it simply references the PyTorch directory:","__index_level_0__":5107}
+{"text":"```bash\n(p3) killeent@devgpu047:site-packages$ cat torch.egg-link\n\/home\/killeent\/github\/pytorch\n```","__index_level_0__":5108}
+{"text":"If we navigate back to the PyTorch directory, we see there is a new directory `torch.egg-info`:","__index_level_0__":5109}
+{"text":"```bash\n(p3) killeent@devgpu047:pytorch (master)$ ls -la torch.egg-info\/\ntotal 28\ndrwxr-xr-x.  2 killeent users  4096 Jun 27 08:09 .\ndrwxr-xr-x. 10 killeent users  4096 Jun 27 08:01 ..\n-rw-r--r--.  1 killeent users     1 Jun 27 08:01 dependency_links.txt\n-rw-r--r--.  1 killeent users   255 Jun 27 08:01 PKG-INFO\n-rw-r--r--.  1 killeent users     7 Jun 27 08:01 requires.txt\n-rw-r--r--.  1 killeent users 16080 Jun 27 08:01 SOURCES.txt\n-rw-r--r--.  1 killeent users    12 Jun 27 08:01 top_level.txt\n```","__index_level_0__":5110}
+{"text":"This file contains metadata about the PyTorch project. For example, `requirements.txt` lists all of the dependencies for setting up PyTorch:","__index_level_0__":5111}
+{"text":"```bash\n(p3) killeent@devgpu047:pytorch (master)$ cat torch.egg-info\/requires.txt\npyyaml\n```","__index_level_0__":5112}
+{"text":"Without going into too much detail, `develop` allows us to essentially treat the PyTorch repo itself as if it were in `site-packages`, so we can import the module and it just works:","__index_level_0__":5113}
+{"text":"```bash\n(p3) killeent@devgpu047:~$ python\nPython 3.6.1 |Continuum Analytics, Inc.| (default, Mar 22 2017, 19:54:23)\n[GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] on linux\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>> import torch\n>>> torch.__file__\n'\/home\/killeent\/github\/pytorch\/torch\/__init__.py'\n```","__index_level_0__":5114}
+{"text":"As a result, the following consequences hold:","__index_level_0__":5115}
+{"text":"- If we change a Python source file, the changes are automatically picked up, and we don't have to run any commands to let the Python interpreter *see* this change\n- If we change a C++ Source File in one of the extension libraries, we can re-run the `develop` command, it will re-build the extension","__index_level_0__":5116}
+{"text":"Thus we can develop the PyTorch codebases seamlessly, and test our changes in an easy way.","__index_level_0__":5117}
+{"text":"#### Working on the Dependency Libraries","__index_level_0__":5118}
+{"text":"If we are working on the dependencies (e.g. `TH`, `THPP`, etc.) we can re-build our changes more quickly by simply running the `build_deps` command directly. This will automatically call into `build_all.sh` to re-build our libraries, and copy the generated libraries appropriately. If we are using Setuptools `develop` mode, we will be using the local extension library built in the PyTorch directory. Because we have specified the paths to the shared libraries when compiling our Extension Libraries, the changes will be picked up:","__index_level_0__":5119}
+{"text":"```bash\n# we are using the local extension\n(p3) killeent@devgpu047:~$ python\nPython 3.6.1 |Continuum Analytics, Inc.| (default, Mar 22 2017, 19:54:23)\n[GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] on linux\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>> import torch\n>>> torch._C.__file__\n'\/home\/killeent\/github\/pytorch\/torch\/_C.cpython-36m-x86_64-linux-gnu.so'","__index_level_0__":5120}
+{"text":"# it references the local shared object library we just re-built\n(p3) killeent@devgpu047:~$ ldd \/home\/killeent\/github\/pytorch\/torch\/_C.cpython-36m-x86_64-linux-gnu.so\n# ...\nlibTH.so.1 => \/home\/killeent\/github\/pytorch\/torch\/lib\/libTH.so.1 (0x00007f543d0e2000)\n# ...\n```","__index_level_0__":5121}
+{"text":"As such, we can test any changes here without having to do a full rebuild.","__index_level_0__":5122}
+{"text":"#### 3rd Party Libraries","__index_level_0__":5123}
+{"text":"PyTorch has dependencies on some 3rd party libraries. The usual mechanism for using these libraries is to install them via Anaconda, and then link against them. For example, we can use the `mkl` library with PyTorch by doing:","__index_level_0__":5124}
+{"text":"```bash\n# installed to miniconda2\/envs\/p3\/lib\/libmkl_intel_lp64.so\nconda install mkl\n```","__index_level_0__":5125}
+{"text":"And then as long as we have the path to this `lib` directory on our `$CMAKE_PREFIX_PATH`, it will successfully find this library when compiling:","__index_level_0__":5126}
+{"text":"```bash\n# in the site-packages dir\n(p3) killeent@devgpu047:torch$ ldd _C.cpython-36m-x86_64-linux-gnu.so\n# ...\nlibmkl_intel_lp64.so => \/home\/killeent\/local\/miniconda2\/envs\/p3\/lib\/libmkl_intel_lp64.so (0x00007f3450bba000)\n# ...\n```","__index_level_0__":5127}
+{"text":"### Not Covered, But Also Relevant","__index_level_0__":5128}
+{"text":"- How `ccache` is used to speed up build times\n- How PyTorch's top-level `__init__.py` file handles the initial module import and pulling together all the various modules and extension libraries\n- The CMake build system, how the backend libraries are configured and built with CMake\n \n source: https:\/\/pytorch.org\/blog\/a-tour-of-pytorch-internals-2\/ \n category: pytorch blogs","__index_level_0__":5129}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'An Overview of the PyTorch Mobile Demo Apps'\nauthor: Jeff Tang and Mark Saroufim\nfeatured-img: 'assets\/images\/android-demo-app.png'\ndate: 2021-06-18 12:00:00 -0500\n---","__index_level_0__":5130}
+{"text":"\nPyTorch Mobile provides a runtime environment to execute state-of-the-art machine learning models on mobile devices. Latency is reduced, privacy preserved, and models can run on mobile devices anytime, anywhere.","__index_level_0__":5131}
+{"text":"In this blog post, we provide a quick overview of 10 currently available PyTorch Mobile powered demo apps running various state-of-the-art PyTorch 1.9 machine learning models spanning images, video, audio and text.","__index_level_0__":5132}
+{"text":"It\u2019s never been easier to deploy a state-of-the-art ML model to a phone. You don\u2019t need any domain knowledge in Machine Learning and we hope one of the below examples resonates enough with you to be the starting point for your next project.","__index_level_0__":5133}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/mobile_app_code.png\" width=\"100%\"\/>\n<\/div>","__index_level_0__":5134}
+{"text":"## Computer Vision\n### Image Classification\nThis app demonstrates how to use PyTorch C++ libraries on iOS and Android to classify a static image with the MobileNetv2\/3 model.","__index_level_0__":5135}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS #1](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/HelloWorld) [iOS #2](https:\/\/github.com\/pytorch\/workshops\/tree\/master\/PTMobileWalkthruIOS) [Android #1](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/HelloWorldApp) [Android #2](https:\/\/github.com\/pytorch\/workshops\/tree\/master\/PTMobileWalkthruAndroid)","__index_level_0__":5136}
+{"text":"<img src=\"\/assets\/images\/screencast.png\"> [iOS](https:\/\/youtu.be\/amTepUIR93k) [Android](https:\/\/youtu.be\/5Lxuu16_28o)","__index_level_0__":5137}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/screenshot_mobile_helloworld.png\" width=\"50%\">\n<\/div>","__index_level_0__":5138}
+{"text":"\n### Live Image Classification\nThis app demonstrates how to run a quantized MobileNetV2 and Resnet18 models to classify images in real time with an iOS and Android device camera.","__index_level_0__":5139}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/PyTorchDemo) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/PyTorchDemoApp)","__index_level_0__":5140}
+{"text":"<div class=\"text-center\">\n<img src=\"\/assets\/images\/screenshot_live_image_classification1.png\" width=\"40%\">\n<img src=\"\/assets\/images\/screenshot_live_image_classification2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5141}
+{"text":"\n### Image Segmentation\nThis app demonstrates how to use the PyTorch DeepLabV3 model to segment images. The updated app for PyTorch 1.9 also demonstrates how to create the model using the Mobile Interpreter and load the model with the LiteModuleLoader API.","__index_level_0__":5142}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/ImageSegmentation) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/ImageSegmentation)","__index_level_0__":5143}
+{"text":"<img src=\"\/assets\/images\/tutorial.png\"> [iOS](https:\/\/pytorch.org\/tutorials\/beginner\/deeplabv3_on_ios.html) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/ImageSegmentation)","__index_level_0__":5144}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/deeplab1.png\" width=\"40%\"> <img src=\"\/assets\/images\/deeplab2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5145}
+{"text":"\n### Vision Transformer for Handwritten Digit Recognition\nThis app demonstrates how to use Facebook's latest optimized Vision Transformer DeiT model to do image classification and handwritten digit recognition.","__index_level_0__":5146}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/ViT4MNIST) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/ViT4MNIST)","__index_level_0__":5147}
+{"text":"<img src=\"\/assets\/images\/screencast.png\"> [Android](https:\/\/drive.google.com\/file\/d\/11L5mIjrLn7B7VdwjQl5vJv3ZVK4hcYut\/view?usp=sharing)","__index_level_0__":5148}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/screenshot_mobile_digit_recognition1.png\" width=\"40%\"> <img src=\"\/assets\/images\/screenshot_mobile_digit_recognition2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5149}
+{"text":"\n### Object Detection\nThis app demonstrates how to convert the popular YOLOv5 model and use it on an iOS app that detects objects from pictures in your photos, taken with camera, or with live camera.","__index_level_0__":5150}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/ObjectDetection) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/ObjectDetection)","__index_level_0__":5151}
+{"text":"<img src=\"\/assets\/images\/screencast.png\"> [iOS](https:\/\/drive.google.com\/file\/d\/1pIDrUDnCD5uF-mIz8nbSlZcXxPlRBKhl\/view) [Android](https:\/\/drive.google.com\/file\/d\/1-5AoRONUqZPZByM-fy0m7r8Ct11OnlIT\/view)","__index_level_0__":5152}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/screenshot_mobile_object_detection1.png\" width=\"40%\"> <img src=\"\/assets\/images\/screenshot_mobile_object_detection2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5153}
+{"text":"\n### D2Go\nThis app demonstrates how to create and use a much lighter and faster Facebook D2Go model to detect objects from pictures in your photos, taken with camera, or with live camera.","__index_level_0__":5154}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/D2Go) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/D2Go)","__index_level_0__":5155}
+{"text":"<img src=\"\/assets\/images\/screencast.png\"> [iOS](https:\/\/drive.google.com\/file\/d\/1GO2Ykfv5ut2Mfoc06Y3QUTFkS7407YA4\/view) [Android](https:\/\/drive.google.com\/file\/d\/18-2hLc-7JAKtd1q00X-5pHQCAdyJg7dZ\/view?usp=sharing)","__index_level_0__":5156}
+{"text":"\n<div class=\"text-center\">\n  <img src=\"\/assets\/images\/screenshot_mobile_d2go1.png\" width=\"40%\"> <img src=\"\/assets\/images\/screenshot_mobile_d2go2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5157}
+{"text":"\n## Video\n### Video Classification\nThis app demonstrates how to use a pre-trained PyTorchVideo model to perform video classification on tested videos, videos from the Photos library, or even real-time videos.","__index_level_0__":5158}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/TorchVideo) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/TorchVideo)","__index_level_0__":5159}
+{"text":"<img src=\"\/assets\/images\/screencast.png\"> [iOS](https:\/\/drive.google.com\/file\/d\/1ijb4UIuF2VQiab4xfAsBwrQXCInvb9wd\/view) [Android](https:\/\/drive.google.com\/file\/d\/193tkZgt5Rlk7u-EQPcvkoFtmOQ14-zCC\/view) [Deep Dive](https:\/\/www.youtube.com\/watch?v=Qb4vDm-ruwI)","__index_level_0__":5160}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/screenshot_mobile_video1.png\" width=\"40%\"> <img src=\"\/assets\/images\/screenshot_mobile_video2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5161}
+{"text":"## Natural Language Processing\n### Text Classification\nThis app demonstrates how to use a pre-trained Reddit model to perform text classification.","__index_level_0__":5163}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/PyTorchDemo) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/PyTorchDemoApp)","__index_level_0__":5164}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/screenshot_mobile_textclassification1.png\" width=\"40%\"> <img src=\"\/assets\/images\/screenshot_mobile_textclassification2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5165}
+{"text":"\n### Machine Translation\nThis app demonstrates how to convert a sequence-to-sequence neural machine translation model trained with the code in the PyTorch NMT tutorial for french to english translation.","__index_level_0__":5166}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/Seq2SeqNMT) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/Seq2SeqNMT)","__index_level_0__":5167}
+{"text":"<img src=\"\/assets\/images\/screencast.png\"> [iOS](https:\/\/drive.google.com\/file\/d\/17Edk-yAyfzijHPR_2ZDAIX7VY-TkQnLf\/view) [Android](https:\/\/drive.google.com\/file\/d\/110KN3Pa9DprkBWnzj8Ppa8KMymhmBI61\/view?usp=sharing)","__index_level_0__":5168}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/screenshot_mobile_machinetranslation1.png\" width=\"40%\"> <img src=\"\/assets\/images\/screenshot_mobile_machinetranslation2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5169}
+{"text":"### Question Answering\nThis app demonstrates how to use the DistilBERT Hugging Face transformer model to answer questions about Pytorch Mobile itself.","__index_level_0__":5170}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/QuestionAnswering) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/QuestionAnswering)","__index_level_0__":5171}
+{"text":"<img src=\"\/assets\/images\/screencast.png\"> [iOS](https:\/\/drive.google.com\/file\/d\/1QIB3yoP4I3zUU0bLCpvUqPV5Kv8f8JvB\/view) [Android](https:\/\/drive.google.com\/file\/d\/10hwGNFo5tylalKwut_CWFPJmV7JRdDKF\/view?usp=sharing)","__index_level_0__":5172}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/screenshot_mobile_qa1.png\" width=\"40%\"> <img src=\"\/assets\/images\/screenshot_mobile_qa2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5173}
+{"text":"\n## Audio\n### Speech Recognition\nThis app demonstrates how to convert Facebook AI's torchaudio-powered wav2vec 2.0, one of the leading models in speech recognition to TorchScript before deploying it.","__index_level_0__":5174}
+{"text":"<img src=\"\/assets\/images\/github_logo_32.png\"> [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/SpeechRecognition) [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/SpeechRecognition)","__index_level_0__":5175}
+{"text":"<div class=\"text-center\">\n  <img src=\"\/assets\/images\/screenshot_mobile_asr1.png\" width=\"40%\"> <img src=\"\/assets\/images\/screenshot_mobile_asr2.png\" width=\"40%\">\n<\/div>","__index_level_0__":5176}
+{"text":"\nWe really hope one of these demo apps stood out for you. For the full list, make sure to visit the [iOS](https:\/\/github.com\/pytorch\/ios-demo-app) and [Android](https:\/\/github.com\/pytorch\/android-demo-app) demo app repos. You should also definitely check out the video [An Overview of the PyTorch Mobile Demo Apps](https:\/\/www.youtube.com\/watch?v=Qb4vDm-ruwI) which provides both an overview of the PyTorch mobile demo apps and a deep dive into the PyTorch Video app for iOS and Android.\n \n source: https:\/\/pytorch.org\/blog\/mobile-demo-apps-overview\/ \n category: pytorch blogs","__index_level_0__":5177}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Accelerating PyTorch Vision Models with Channels Last on CPU\"\nauthor: Mingfei Ma (Intel), Vitaly Fedyunin (Meta), Wei Wei (Meta)\nfeatured-img: '\/assets\/images\/accelerating-pytorch-vision-models-with-channels-last-on-cpu-2.png'\n---","__index_level_0__":5178}
+{"text":"## Overview","__index_level_0__":5179}
+{"text":"Memory formats has significant impact on performance when running vision models, generally Channels Last is a more favorable from performance perspective due to better data locality.","__index_level_0__":5180}
+{"text":"This blog will introduce fundamental concepts of memory formats and demonstrate performance benefits using Channels Last on popular PyTorch vision models on Intel\u00ae Xeon\u00ae Scalable processors.","__index_level_0__":5181}
+{"text":"## Memory Formats Introduction","__index_level_0__":5182}
+{"text":"Memory format refers to data representation that describes how a multidimensional (nD) array is stored in linear (1D) memory address space. The concept of memory format has two aspects:","__index_level_0__":5183}
+{"text":"- **Physical Order** is the layout of data storage in physical memory. For vision models, usually we talk about NCHW, NHWC. These are the descriptions of physical memory layout, also referred as Channels First and Channels Last respectively.\n- **Logical Order** is a convention on how to describe tensor shape and stride. In PyTorch, this convention is NCHW. No matter what the physical order is, tensor shape and stride will always be depicted in the order of NCHW.","__index_level_0__":5184}
+{"text":"Fig-1 is the physical memory layout of a tensor with shape of [1, 3, 4, 4] on both Channels First and Channels Last memory format (channels denoted as R, G, B respectively):","__index_level_0__":5185}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/accelerating-pytorch-vision-models-with-channels-last-on-cpu-1.png\" width=\"70%\">\n<\/p>","__index_level_0__":5186}
+{"text":"<p align=\"center\">\n<b>Fig-1 Physical memory layout of Channels First and Channels Last<\/b>\n<\/p>","__index_level_0__":5187}
+{"text":"## Memory Formats Propagation","__index_level_0__":5188}
+{"text":"The general rule for PyTorch memory format propagation is to preserve the input tensor\u2019s memory format. Which means a Channels First input will generate a Channels First output and a Channels Last input will generate a Channels Last output. ","__index_level_0__":5189}
+{"text":"For Convolution layers, PyTorch uses oneDNN (oneAPI Deep Neural Network Library) by default to achieve optimal performance on Intel CPUs. Since it is physically impossible to achieve highly optimized performance directly with Channels Frist memory format, input and weight are firstly converted to blocked format and then computed. oneDNN may choose different blocked formats according to input shapes, data type and hardware architecture, for vectorization and cache reuse purposes. The blocked format is opaque to PyTorch, so the output needs to be converted back to Channels First. Though blocked format would bring about optimal computing performance, the format conversions may add overhead and therefore offset the performance gain.","__index_level_0__":5190}
+{"text":"On the other hand, oneDNN is optimized for Channels Last memory format to use it for optimal performance directly and PyTorch will simply pass a memory view to oneDNN. Which means the conversion of input and output tensor is saved. Fig-2 indicates memory format propagation behavior of convolution on PyTorch CPU (the solid arrow indicates a memory format conversion, and the dashed arrow indicates a memory view):","__index_level_0__":5191}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/accelerating-pytorch-vision-models-with-channels-last-on-cpu-2.png\" width=\"70%\">\n<\/p>","__index_level_0__":5192}
+{"text":"<p align=\"center\">\n<b>Fig-2 CPU Conv memory format propagation<\/b>\n<\/p>","__index_level_0__":5193}
+{"text":"On PyTorch, the default memory format is Channels First. In case a particular operator doesn't have support on Channels Last, the NHWC input would be treated as a non-contiguous NCHW and therefore fallback to Channels First, which will consume the previous memory bandwidth on CPU and result in suboptimal performance. ","__index_level_0__":5194}
+{"text":"Therefore, it is very important to extend the scope of Channels Last support for optimal performance. And we have implemented Channels Last kernels for the commonly use operators in CV domain, applicable for both inference and training, such as:","__index_level_0__":5195}
+{"text":"- Activations (e.g., ReLU, PReLU, etc.)\n- Convolution (e.g., Conv2d)\n- Normalization (e.g., BatchNorm2d, GroupNorm, etc.)\n- Pooling (e.g., AdaptiveAvgPool2d, MaxPool2d, etc.)\n- Shuffle (e.g., ChannelShuffle, PixelShuffle)","__index_level_0__":5196}
+{"text":"Refer to [Operators-with-Channels-Last-support](https:\/\/github.com\/pytorch\/pytorch\/wiki\/Operators-with-Channels-Last-support) for details.","__index_level_0__":5197}
+{"text":"## Native Level Optimization on Channels Last","__index_level_0__":5198}
+{"text":"As mentioned above, PyTorch uses oneDNN to achieve optimal performance on Intel CPUs for convolutions. The rest of memory format aware operators are optimized at PyTorch native level, which doesn\u2019t require any third-party library support.","__index_level_0__":5199}
+{"text":"- **Cache friendly parallelization scheme:** keep the same parallelization scheme for all the memory format aware operators, this will help increase data locality when passing each layer\u2019s output to the next.\n- **Vectorization on multiple archs:** generally, we can vectorize on the most inner dimension on Channels Last memory format. And each of the vectorized CPU kernels will be generated for both AVX2 and AVX512.","__index_level_0__":5200}
+{"text":"While contributing to Channels Last kernels, we tried our best to optimize Channels First counterparts as well. The fact is some operators are physically impossible to achieve optimal performance on Channels First, such as Convolution, Pooling, etc.","__index_level_0__":5201}
+{"text":"## Run Vision Models on Channels Last","__index_level_0__":5202}
+{"text":"The Channels Last related APIs are documented at [PyTorch memory format tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/memory_format_tutorial.html). Typically, we can convert a 4D tensor from Channels First to Channels Last by:","__index_level_0__":5203}
+{"text":"```python\n# convert x to channels last\n# suppose x\u2019s shape is (N, C, H, W)\n# then x\u2019s stride will be (HWC, 1, WC, C)\nx = x.to(memory_format=torch.channels_last)\n```","__index_level_0__":5204}
+{"text":"To run models on Channels Last memory format, simply need to convert input and model to Channels Last and then you are ready to go. The following is a minimal example showing how to run ResNet50 with TorchVision on Channels Last memory format:","__index_level_0__":5205}
+{"text":"```python\nimport torch\nfrom torchvision.models import resnet50","__index_level_0__":5206}
+{"text":"N, C, H, W = 1, 3, 224, 224\nx = torch.rand(N, C, H, W)\nmodel = resnet50()\nmodel.eval()","__index_level_0__":5207}
+{"text":"# convert input and model to channels last\nx = x.to(memory_format=torch.channels_last)\nmodel = model.to(memory_format=torch.channels_last)\nmodel(x)\n```","__index_level_0__":5208}
+{"text":"The Channels Last optimization is implemented at native kernel level, which means you may apply other functionalities such as torch.fx and torch script together with Channels Last as well.","__index_level_0__":5209}
+{"text":"## Performance Gains","__index_level_0__":5210}
+{"text":"We benchmarked inference performance of TorchVision models on Intel\u00ae Xeon\u00ae Platinum 8380 CPU @ 2.3 GHz, single instance per socket (batch size = 2 x number of physical cores). Results show that Channels Last has 1.3x to 1.8x performance gain over Channels First.","__index_level_0__":5211}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/accelerating-pytorch-vision-models-with-channels-last-on-cpu-3.png\" width=\"100%\">\n<\/p>","__index_level_0__":5212}
+{"text":"The performance gain primarily comes from two aspects:","__index_level_0__":5213}
+{"text":"- For Convolution layers, Channels Last saved the memory format conversion to blocked format for activations, which improves the overall computation efficiency.\n- For Pooling and Upsampling layers, Channels Last can use vectorized logic along the most inner dimension, e.g., \u201cC\u201d, while Channels First can\u2019t.","__index_level_0__":5214}
+{"text":"For memory format non aware layers, Channels Last and Channels First has the same performance.","__index_level_0__":5215}
+{"text":"## Conclusion & Future Work","__index_level_0__":5216}
+{"text":"In this blog we introduced fundamental concepts of Channels Last and demonstrated the performance benefits of CPU using Channels Last on vision models. The current work is limited to 2D models at the current stage, and we will extend the optimization effort to 3D models in near future!","__index_level_0__":5217}
+{"text":"## Acknowledgement","__index_level_0__":5218}
+{"text":"The results presented in this blog is a joint effort of Meta and Intel PyTorch team. Special thanks to Vitaly Fedyunin and Wei Wei from Meta who spent precious time and gave substantial assistance! Together we made one more step on the path of improving the PyTorch CPU eco system.","__index_level_0__":5219}
+{"text":"## References","__index_level_0__":5220}
+{"text":"- [PyTorch memory format tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/memory_format_tutorial.html)\n- [oneDNN guide on memory formats](https:\/\/oneapi-src.github.io\/oneDNN\/dev_guide_understanding_memory_formats.html)\n- [PyTorch operators with Channels Last support](https:\/\/github.com\/pytorch\/pytorch\/wiki\/Operators-with-Channels-Last-support) \n source: https:\/\/pytorch.org\/blog\/accelerating-pytorch-vision-models-with-channels-last-on-cpu\/ \n category: pytorch blogs","__index_level_0__":5221}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Announcing the PyTorch Enterprise Support Program'\nauthor: Team PyTorch\n---","__index_level_0__":5222}
+{"text":"Today, we are excited to announce the [PyTorch Enterprise Support Program](http:\/\/pytorch.org\/enterprise-support-program), a participatory program that enables service providers to develop and offer tailored enterprise-grade support to their customers. This new offering, built in collaboration between Facebook and Microsoft, was created in direct response to feedback from PyTorch enterprise users who are developing models in production at scale for mission-critical applications.","__index_level_0__":5223}
+{"text":"The PyTorch Enterprise Support Program is available to any service provider. It is designed to mutually benefit all program Participants by sharing and improving PyTorch long-term support (LTS), including contributions of hotfixes and other improvements found while working closely with customers and on their systems.","__index_level_0__":5224}
+{"text":"To benefit the open source community, all hotfixes developed by Participants will be tested and fed back to the LTS releases of PyTorch regularly through PyTorch\u2019s standard pull request process. To participate in the program, a service provider must apply and meet a set of program terms and certification requirements. Once accepted, the service provider becomes a program Participant and can offer a packaged PyTorch Enterprise support service with LTS, prioritized troubleshooting, useful integrations, and more.","__index_level_0__":5225}
+{"text":"<div class=\"col-md-5 enterprise-azure-logo-container\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/microsoft-azure.png\" width=\"100%\">\n<\/div>","__index_level_0__":5226}
+{"text":"As one of the founding members and an inaugural member of the PyTorch Enterprise Support Program, Microsoft is launching [PyTorch Enterprise on Microsoft Azure](https:\/\/Aka.ms\/PyTorchEnterpriseHeroBlog) to deliver a reliable production experience for PyTorch users. Microsoft will support each PyTorch release for as long as it is current. In addition, it will support selected releases for two years, enabling a stable production experience. Microsoft Premier and Unified Support customers can access prioritized troubleshooting for hotfixes, bugs, and security patches at no additional cost. Microsoft will extensively test PyTorch releases for performance regression. The latest release of PyTorch will be integrated with [Azure Machine Learning](https:\/\/azure.microsoft.com\/en-us\/services\/machine-learning\/) and other PyTorch add-ons including [ONNX Runtime](https:\/\/www.onnxruntime.ai\/) for faster inference.","__index_level_0__":5227}
+{"text":"PyTorch Enterprise on Microsoft Azure not only benefits its customers, but also the PyTorch community users. All improvements will be tested and fed back to the future release for PyTorch so everyone in the community can use them.","__index_level_0__":5228}
+{"text":"As an organization or PyTorch user, the standard way of researching and deploying with different release versions of PyTorch does not change. If your organization is looking for the managed long-term support, prioritized patches, bug fixes, and additional enterprise-grade support, then you should reach out to service providers participating in the program.","__index_level_0__":5229}
+{"text":"To learn more and participate in the program as a service provider, visit the [PyTorch Enterprise Support Program](http:\/\/pytorch.org\/enterprise-support-program). If you want to learn more about Microsoft\u2019s offering, visit [PyTorch Enterprise on Microsoft Azure](https:\/\/Aka.ms\/PyTorchEnterpriseHeroBlog).","__index_level_0__":5230}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/announcing-pytorch-enterprise\/ \n category: pytorch blogs","__index_level_0__":5232}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Everything You Need To Know About Torchvision\u2019s SSD Implementation'\nauthor: Vasilis Vryniotis\nfeatured-img: 'assets\/images\/prediction-examples.png'\n---","__index_level_0__":5233}
+{"text":"In TorchVision v0.10, we\u2019ve released two new Object Detection models based on the SSD architecture. Our plan is to cover the key implementation details of the algorithms along with information on how they were trained in a two-part article.","__index_level_0__":5234}
+{"text":"In part 1 of the series, we will focus on the original implementation of the SSD algorithm as described on the [Single Shot MultiBox Detector paper](https:\/\/arxiv.org\/abs\/1512.02325). We will briefly give a high-level description of how the algorithm works, then go through its main components, highlight key parts of its code, and finally discuss how we trained the released model. Our goal is to cover all the necessary details to reproduce the model including those optimizations which are not covered on the paper but are part on the [original implementation](https:\/\/github.com\/weiliu89\/caffe\/tree\/ssd).","__index_level_0__":5235}
+{"text":"# How Does SSD Work?","__index_level_0__":5236}
+{"text":"Reading the aforementioned paper is highly recommended but here is a quick oversimplified refresher. Our target is to detect the locations of objects in an image along with their categories. Here is the Figure 5 from the [SSD paper](https:\/\/arxiv.org\/abs\/1512.02325) with prediction examples of the model:","__index_level_0__":5237}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/prediction examples.png\" width=\"100%\">\n<\/div>","__index_level_0__":5238}
+{"text":"The SSD algorithm uses a CNN backbone, passes the input image through it and takes the convolutional outputs from different levels of the network. The list of these outputs are called feature maps. These feature maps are then passed through the Classification and Regression heads which are responsible for predicting the class and the location of the boxes. ","__index_level_0__":5239}
+{"text":"Since the feature maps of each image contain outputs from different levels of the network, their size varies and thus they can capture objects of different dimensions. On top of each, we tile several default boxes which can be thought as our rough prior guesses. For each default box, we predict whether there is an object (along with its class) and its offset (correction over the original location). During training time, we need to first match the ground truth to the default boxes and then we use those matches to estimate our loss. During inference, similar prediction boxes are combined to estimate the final predictions. ","__index_level_0__":5240}
+{"text":"# The SSD Network Architecture","__index_level_0__":5241}
+{"text":"In this section, we will discuss the key components of SSD. Our code follows closely [the paper](https:\/\/arxiv.org\/abs\/1512.02325) and makes use of many of the undocumented optimizations included in [the official implementation](https:\/\/github.com\/weiliu89\/caffe\/tree\/ssd).","__index_level_0__":5242}
+{"text":"### DefaultBoxGenerator","__index_level_0__":5243}
+{"text":"The [DefaultBoxGenerator class](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/anchor_utils.py#L134) is responsible for generating the default boxes of SSD and operates similarly to the [AnchorGenerator](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/anchor_utils.py#L9) of FasterRCNN (for more info on their differences see pages 4-6 of the paper). It produces a set of predefined boxes of specific width and height which are tiled across the image and serve as the first rough prior guesses of where objects might be located. Here is Figure 1 from the SSD paper with a visualization of ground truths and default boxes:","__index_level_0__":5244}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/visualization of ground truths.png\" width=\"100%\">\n<\/div>","__index_level_0__":5245}
+{"text":"The class is parameterized by a set of hyperparameters that control [their shape](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/anchor_utils.py#L139) and [tiling](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/anchor_utils.py#L140-L149). The implementation will provide [automatically good guesses](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/anchor_utils.py#L162-L171) with the default parameters for those who want to experiment with new backbones\/datasets but one can also pass [optimized custom values](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/anchor_utils.py#L144-L147).","__index_level_0__":5246}
+{"text":"### SSDMatcher","__index_level_0__":5247}
+{"text":"The [SSDMatcher class](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/_utils.py#L348) extends the standard [Matcher](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/_utils.py#L227) used by FasterRCNN and it is responsible for matching the default boxes to the ground truth. After estimating the [IoUs of all combinations](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L349), we use the matcher to find for each default box the best [candidate](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/_utils.py#L296) ground truth with overlap higher than the [IoU threshold](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/_utils.py#L350-L351). The SSD version of the matcher has an extra step to ensure that each ground truth is matched with the default box that has the [highest overlap](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/_utils.py#L356-L360). The results of the matcher are used in the loss estimation during the training process of the model.","__index_level_0__":5248}
+{"text":"### Classification and Regression Heads","__index_level_0__":5249}
+{"text":"The [SSDHead class](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L38) is responsible for initializing the Classification and Regression parts of the network. Here are a few notable details about their code:","__index_level_0__":5250}
+{"text":"* Both the [Classification](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L90) and the [Regression](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L99) head inherit from the [same class](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L51) which is responsible for making the predictions for each feature map. \n* Each level of the feature map uses a separate 3x3 Convolution to estimate the [class logits](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L92-L94) and [box locations](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L101-L103). \n* The [number of predictions](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L79) that each head makes per level depends on the number of default boxes and the sizes of the feature maps.","__index_level_0__":5251}
+{"text":"### Backbone Feature Extractor","__index_level_0__":5252}
+{"text":"The [feature extractor](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L413) reconfigures and enhances a standard VGG backbone with extra layers as depicted on the Figure 2 of the SSD paper: ","__index_level_0__":5253}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/feature extractor.png\" width=\"100%\">\n<\/div>","__index_level_0__":5254}
+{"text":"The class supports all VGG models of TorchVision and one can create a similar extractor class for other types of CNNs (see [this example for ResNet](https:\/\/github.com\/pytorch\/vision\/blob\/644bdcdc438c1723714950d0771da76333b53954\/torchvision\/models\/detection\/ssd.py#L600)). Here are a few implementation details of the class:","__index_level_0__":5255}
+{"text":"* [Patching](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L419-L420) the ```ceil_mode parameter``` of the 3rd Maxpool layer is necessary to get the same feature map sizes as the paper. This is due to small differences between PyTorch and the original Caffe implementation of the model. \n* It adds a series of [extra feature layers](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L430-L456)on top of VGG. If the highres parameter is ```True``` during its construction, it will append an [extra convolution](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L457-L464). This is useful for the SSD512 version of the model.\n* As discussed on section 3 of the paper, the fully connected layers of the original VGG are converted to convolutions with the [first one using Atrous](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L469). Moreover maxpool5\u2019s stride and kernel size is [modified](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L468).\n* As described on section 3.1, L2 normalization is used on the [output of conv4_3](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L484) and a set of [learnable weights](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L422-L423) are introduced to control its scaling.","__index_level_0__":5256}
+{"text":"### SSD Algorithm","__index_level_0__":5257}
+{"text":"The final key piece of the implementation is on the [SSD class](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L108). Here are some notable details:","__index_level_0__":5258}
+{"text":"* The algorithm is [parameterized](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L167-L176) by a set of arguments similar to other detection models. The mandatory parameters are: the backbone which is responsible for [estimating the feature maps](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L137-L139), the ```anchor_generator``` which should be a [configured instance](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L140-L141) of the ```DefaultBoxGenerator``` class, the size to which the [input images](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L142-L143) will be resized and the ```num_classes``` for classification [excluding](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L144) the background.\n* If a [head](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L150-L151) is not provided, the constructor will [initialize](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L194) the default ```SSDHead```. To do so, we need to know the number of output channels for each feature map produced by the backbone. Initially we try to [retrieve this information](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L186) from the backbone but if not available we will [dynamically estimate it](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L189).\n* The algorithm [reuses](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L183) the standard [BoxCoder class](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/_utils.py#L129) used by other Detection models. The class is responsible for [encoding and decoding](https:\/\/leimao.github.io\/blog\/Bounding-Box-Encoding-Decoding\/) the bounding boxes and is configured to use the same prior variances as the [original implementation](https:\/\/github.com\/weiliu89\/caffe\/blob\/2c4e4c2899ad7c3a997afef2c1fbac76adca1bad\/examples\/ssd\/ssd_coco.py#L326).\n* Though we reuse the standard [GeneralizedRCNNTransform class](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/transform.py#L64) to resize and normalize the input images, the SSD algorithm [configures](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L203-L204) it to ensure that the image size will remain fixed. ","__index_level_0__":5259}
+{"text":"Here are the two core methods of the implementation:","__index_level_0__":5260}
+{"text":"* The ```compute_loss``` method estimates the standard Multi-box loss as described on page 5 of the SSD paper. It uses the [smooth L1 loss](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L244) for regression and the standard [cross-entropy loss](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L262-L266) with [hard-negative sampling](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L268-L276) for classification. \n* As in all detection models, the forward method currently has different behaviour depending on whether the model is on training or eval mode. It starts by [resizing & normalizing the input images](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L309-L310) and then [passes them through the backbone](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L324-L325) to get the feature maps. The feature maps are then [passed through the head](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L331-L332) to get the predictions and then the method [generates the default boxes](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L334-L335). \n    * If the model is on [training mode](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L339-L352), the forward will estimate the [IoUs of the default boxes with the ground truth](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L349), use the ```SSDmatcher``` to [produce matches](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L350) and finally [estimate the losses](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L352) by calling the ```compute_loss method```.\n    * If the model is on [eval mode](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L353-L355), we first select the best detections by keeping only the ones that [pass the score threshold](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L384), select the [most promising boxes](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L388-L391) and run NMS to [clean up and select](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L401-L403) the best predictions. Finally we [postprocess the predictions](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L355) to resize them to the original image size.","__index_level_0__":5261}
+{"text":"# The SSD300 VGG16 Model","__index_level_0__":5262}
+{"text":"The SSD is a family of models because it can be configured with different backbones and different Head configurations. In this section, we will focus on the provided [SSD pre-trained model](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L522-L523). We will discuss the details of its configuration and the training process used to reproduce the reported results.","__index_level_0__":5263}
+{"text":"### Training process","__index_level_0__":5264}
+{"text":"The model was trained using the COCO dataset and all of its hyper-parameters and scripts can be found in our [references](https:\/\/github.com\/pytorch\/vision\/blob\/e35793a1a4000db1f9f99673437c514e24e65451\/references\/detection\/README.md#ssd300-vgg16) folder. Below we provide details on the most notable aspects of the training process.","__index_level_0__":5265}
+{"text":"### Paper Hyperparameters","__index_level_0__":5266}
+{"text":"In order to achieve the best possible results on COCO, we adopted the hyperparameters described on the section 3 of the paper concerning the optimizer configuration, the weight regularization etc. Moreover we found it useful to adopt the optimizations that appear in the [official implementation](https:\/\/github.com\/weiliu89\/caffe\/blob\/ssd\/examples\/ssd\/ssd_coco.py#L310-L321) concerning the [tiling configuration](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L579-L581) of the DefaultBox generator. This optimization was not described in the paper but it was crucial for improving the detection precision of smaller objects. ","__index_level_0__":5267}
+{"text":"### Data Augmentation","__index_level_0__":5268}
+{"text":"Implementing the [SSD Data Augmentation strategy](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/references\/detection\/transforms.py#L20-L239) as described on page 6 and page 12 of the paper was critical to reproducing the results. More specifically the use of random \u201cZoom In\u201d and \u201cZoom Out\u201d transformations make the model robust to various input sizes and improve its precision on the small and medium objects. Finally since the VGG16 has quite a few parameters, the photometric distortions [included in the augmentations](https:\/\/github.com\/pytorch\/vision\/blob\/43d772067fe77965ec8fc49c799de5cea44b8aa2\/references\/detection\/presets.py#L11-L18) have a regularization effect and help avoid the overfitting. ","__index_level_0__":5269}
+{"text":"### Weight Initialization & Input Scaling","__index_level_0__":5270}
+{"text":"Another aspect that we found beneficial was to follow the [weight initialization scheme](https:\/\/github.com\/intel\/caffe\/blob\/master\/models\/intel_optimized_models\/ssd\/VGGNet\/coco\/SSD_300x300\/train.prototxt) proposed by the paper. To do that, we had to adapt our input scaling method by [undoing the 0-1 scaling](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L583-L587) performed by ```ToTensor()``` and use [pre-trained ImageNet weights](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L24-L26) fitted with this scaling (shoutout to [Max deGroot](https:\/\/github.com\/amdegroot) for providing them in his repo). All the weights of new convolutions were [initialized using Xavier](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L30-L35) and their biases were set to zero. After initialization, the network was [trained end-to-end](https:\/\/github.com\/pytorch\/vision\/blob\/33db2b3ebfdd2f73a9228f430fa7dd91c3b18078\/torchvision\/models\/detection\/ssd.py#L571-L572). ","__index_level_0__":5271}
+{"text":"### LR Scheme","__index_level_0__":5272}
+{"text":"As reported on the paper, after applying aggressive data augmentations it\u2019s necessary to train the models for longer. Our experiments confirm this and we had to tweak the Learning rate, batch sizes and overall steps to achieve the best results. Our [proposed learning scheme](https:\/\/github.com\/pytorch\/vision\/blob\/e35793a1a4000db1f9f99673437c514e24e65451\/references\/detection\/README.md#ssd300-vgg16) is configured to be rather on the safe side, showed signs of plateauing between the steps and thus one is likely to be able to train a similar model by doing only 66% of our epochs.","__index_level_0__":5273}
+{"text":"# Breakdown of Key Accuracy Improvements","__index_level_0__":5274}
+{"text":"It is important to note that implementing a model directly from a paper is an iterative process that circles between coding, training, bug fixing and adapting the configuration until we match the accuracies reported on the paper. Quite often it also involves simplifying the training recipe or enhancing it with more recent methodologies. It is definitely not a linear process where incremental accuracy improvements are achieved by improving a single direction at a time but instead involves exploring different hypothesis, making incremental improvements in different aspects and doing a lot of backtracking. ","__index_level_0__":5275}
+{"text":"With that in mind, below we try to summarize the optimizations that affected our accuracy the most. We did this by grouping together the various experiments in 4 main groups and attributing the experiment improvements to the closest match. Note that the Y-axis of the graph starts from 18 instead from 0 to make the difference between optimizations more visible:","__index_level_0__":5276}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/Key optimizations for improving the mAP of SSD300 VGG16.png\" width=\"100%\">\n<\/div>","__index_level_0__":5277}
+{"text":"| Model Configuration | mAP delta | mAP | \n| ------------- | ------------- |  ------------- |\n| Baseline with \"FasterRCNN-style\" Hyperparams | - | 19.5 | \n| + Paper Hyperparams | 1.6 | 21.1 | \n| + Data Augmentation | 1.8 | 22.9 | \n| + Weight Initialization & Input Scaling | 1 | 23.9 | \n| + LR scheme | 1.2 | 25.1 | ","__index_level_0__":5278}
+{"text":"Our final model achieves an mAP of 25.1 and reproduces exactly the COCO results reported on the paper. Here is a [detailed breakdown](https:\/\/github.com\/pytorch\/vision\/pull\/3403) of the accuracy metrics.","__index_level_0__":5279}
+{"text":"\nWe hope you found the part 1 of the series interesting. On the part 2, we will focus on the implementation of SSDlite and discuss its differences from SSD. Until then, we are looking forward to your feedback.\n \n source: https:\/\/pytorch.org\/blog\/torchvision-ssd-implementation\/ \n category: pytorch blogs","__index_level_0__":5280}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch 1.13 release, including beta versions of functorch and improved support for Apple\u2019s new M1 chips.\"\nauthor: Team PyTorch\nfeatured-img: \"\/assets\/images\/blog-2022-10-25-Pytorch-1.13-Release.png\"\n---","__index_level_0__":5281}
+{"text":"We are excited to announce the release of PyTorch<sup>\u00ae<\/sup> 1.13 ([release note](https:\/\/github.com\/pytorch\/pytorch\/releases\/tag\/v1.13.0))! This includes Stable versions of BetterTransformer. We deprecated CUDA 10.2 and 11.3 and completed migration of CUDA 11.6 and 11.7. Beta includes improved support for Apple M1 chips and functorch, a library that offers composable vmap (vectorization) and autodiff transforms, being included in-tree with the PyTorch release. This release is composed of over 3,749 commits and 467 contributors since 1.12.1. We want to sincerely thank our dedicated community for your contributions.","__index_level_0__":5282}
+{"text":"- The [BetterTransformer](#stable-features) feature set supports fastpath execution for common Transformer models during Inference out-of-the-box, without the need to modify the model. Additional improvements include accelerated add+matmul linear algebra kernels for sizes commonly used in Transformer models and Nested Tensors is now enabled by default.","__index_level_0__":5284}
+{"text":"- Timely [deprecating older CUDA versions](#introduction-of-cuda-116-and-117-and-deprecation-of-cuda-102-and-113) allows us to proceed with introducing the latest CUDA version as they are introduced by Nvidia\u00ae, and hence allows support for C++17 in PyTorch and new NVIDIA Open GPU Kernel Modules.","__index_level_0__":5285}
+{"text":"- Previously, [functorch](#beta-features) was released out-of-tree in a separate package. After installing PyTorch, a user will be able to `import functorch` and use functorch without needing to install another package.","__index_level_0__":5286}
+{"text":"- PyTorch is offering native builds for Apple\u00ae silicon machines that use Apple's new [M1 chip](#beta-support-for-m1-devices) as a beta feature, providing improved support across PyTorch's APIs.","__index_level_0__":5287}
+{"text":"<div class=\"toptable\">\n<table>\n  <thead>\n    <tr>\n      <th>Stable<\/th>\n      <th>Beta<\/th>\n      <th>Prototype<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td><a href=\"#stable-bettertransformer-api\">Better Transformer<\/a><\/td>\n      <td><a href=\"#intel\"> Enable Intel\u00ae VTune\u2122 Profiler\u2019s Instrumentation and Tracing Technology APIs <\/a><\/td>\n      <td><a href=\"#arm\"> Arm\u00ae Compute Library backend support for AWS Graviton <\/a><\/td>\n    <\/tr>\n    <tr>\n      <td><a href=\"#cuda10.2\">CUDA 10.2 and 11.3 CI\/CD Deprecation <\/a><\/td>\n      <td><a href=\"#nnc\">Extend NNC to support channels last and bf16 <\/a><a><\/a><\/td>\n      <td><a href=\"#cudasanitizer\">CUDA Sanitizer <\/a><\/td>\n    <\/tr>\n    <tr>\n      <td>&nbsp;<\/td>\n      <td><a href=\"#beta-functorch\">Functorch now in PyTorch Core Library<\/a><\/td>\n      <td>&nbsp;<\/td>\n    <\/tr>\n    <tr>\n      <td>&nbsp;<\/td>\n      <td><a href=\"#betasupport\"> Beta Support for M1 devices<\/a><\/td>\n      <td>&nbsp;<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n<\/div>","__index_level_0__":5288}
+{"text":"Along with 1.13, we are also releasing major updates to the PyTorch libraries, more details can be found in this [blog](https:\/\/pytorch.org\/blog\/new-library-updates-in-pytorch-1.13\/).","__index_level_0__":5289}
+{"text":"## Stable Features","__index_level_0__":5290}
+{"text":"### (Stable) BetterTransformer API","__index_level_0__":5291}
+{"text":"The [BetterTransformer](https:\/\/pytorch.org\/blog\/a-better-transformer-for-fast-transformer-encoder-inference\/) feature set, first released in PyTorch 1.12, is stable. PyTorch BetterTransformer supports fastpath execution for common Transformer models during Inference out-of-the-box, without the need to modify the model. To complement the improvements in Better Transformer, we have also accelerated add+matmul linear algebra kernels for sizes commonly used in Transformer models.","__index_level_0__":5292}
+{"text":"Reflecting the performance benefits for many NLP users, Nested Tensors use for Better Transformer is now enabled by default. To ensure compatibility, a mask check is performed to ensure a contiguous mask is supplied. In Transformer Encoder, the mask check for src_key_padding_mask may be suppressed by setting mask_check=False. This accelerates processing for users than can guarantee that only aligned masks are provided. Finally, better error messages are provided to diagnose incorrect inputs, together with improved diagnostics why fastpath execution cannot be used.","__index_level_0__":5293}
+{"text":"Better Transformer is directly integrated into the PyTorch TorchText library, enabling TorchText users to transparently and automatically take advantage of BetterTransformer speed and efficiency performance. ([Tutorial](https:\/\/pytorch.org\/tutorials\/beginner\/bettertransformer_tutorial.html))","__index_level_0__":5294}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/blog-2022-10-25-Pytorch-1.13-Release.png\" width=\"90%\">\n<\/p>","__index_level_0__":5295}
+{"text":"<a name=\"cuda10.2\"> <\/a>","__index_level_0__":5296}
+{"text":"<p align=\"left\">\n<b>Figure:<\/b> BetterTransformer fastpath execution is now stable and enables sparsity optimization using Nested Tensor representation as default\n<\/p>","__index_level_0__":5297}
+{"text":"### Introduction of CUDA 11.6 and 11.7 and deprecation of CUDA 10.2 and 11.3","__index_level_0__":5298}
+{"text":"Timely deprecating older CUDA versions allows us to proceed with introducing the latest CUDA version as they are introduced by Nvidia\u00ae, and hence allows developers to use the latest features of CUDA and benefit from correctness fixes provided by the latest version.","__index_level_0__":5299}
+{"text":"Decommissioning of CUDA 10.2. CUDA 11 is the first CUDA version to support C++17. Hence decommissioning legacy CUDA 10.2 was a major step in adding support for C++17 in PyTorch. It also helps to improve PyTorch code by eliminating legacy CUDA 10.2 specific instructions.","__index_level_0__":5300}
+{"text":"Decommissioning of CUDA 11.3 and introduction of CUDA 11.7 brings compatibility support for the new NVIDIA Open GPU Kernel Modules and another significant highlight is the lazy loading support. CUDA 11.7 is shipped with cuDNN 8.5.0 which contains a number of optimizations accelerating transformer-based models, 30% reduction in library size , and various improvements in the runtime fusion engine. Learn more on CUDA 11.7 with our [release notes](https:\/\/docs.nvidia.com\/cuda\/cuda-toolkit-release-notes\/index.html).","__index_level_0__":5301}
+{"text":"## Beta Features","__index_level_0__":5302}
+{"text":"### (Beta) functorch","__index_level_0__":5303}
+{"text":"Inspired by [Google\u00ae JAX](https:\/\/github.com\/google\/jax), functorch is a library that offers composable vmap (vectorization) and autodiff transforms. It enables advanced autodiff use cases that would otherwise be tricky to express in PyTorch. Examples include:","__index_level_0__":5304}
+{"text":"<ul>\n  <li><a href=\"https:\/\/pytorch.org\/functorch\/1.13\/notebooks\/ensembling.html\" target=\"_blank\">model ensembling<\/a><\/li>\n  <li><a href=\"https:\/\/pytorch.org\/functorch\/1.13\/notebooks\/jacobians_hessians.html\" target=\"_blank\">efficiently computing jacobians and hessians<\/a><\/li>\n  <li><a href=\"https:\/\/pytorch.org\/functorch\/1.13\/notebooks\/per_sample_grads.html\" target=\"_blank\">computing per-sample-gradients (or other per-sample quantities)<\/a>\n<\/li>\n<\/ul>","__index_level_0__":5305}
+{"text":"<a name=\"intel\"><\/a>\nWe\u2019re excited to announce that, as a first step towards closer integration with PyTorch, functorch has moved to inside the PyTorch library and no longer requires the installation of a separate functorch package. After installing PyTorch via conda or pip, you\u2019ll be able to `import functorch\u2019 in your program. Learn more with our [detailed instructions](https:\/\/pytorch.org\/functorch\/1.13\/install.html), [nightly](https:\/\/pytorch.org\/functorch\/nightly\/) and [release notes](https:\/\/github.com\/pytorch\/pytorch\/releases).","__index_level_0__":5306}
+{"text":"### (Beta) Intel\u00ae VTune\u2122 Profiler's Instrumentation and Tracing Technology APIs (ITT) integration","__index_level_0__":5307}
+{"text":"PyTorch users are able to visualize op-level timeline of PyTorch scripts execution in Intel\u00ae VTune\u2122 Profiler when they need to analyze per-op performance with low-level performance metrics on Intel platforms.","__index_level_0__":5308}
+{"text":"```python\nwith torch.autograd.profiler.emit_itt():\n    for i in range(10):\n        torch.itt.range_push('step_{}'.format(i))\n        model(input)\n        torch.itt.range_pop()\n```","__index_level_0__":5309}
+{"text":"<a name=\"nnc\"> <\/a>\nLearn more with our [tutorial](https:\/\/pytorch.org\/tutorials\/recipes\/profile_with_itt.html).","__index_level_0__":5310}
+{"text":"### (Beta) NNC: Add BF16 and Channels last support","__index_level_0__":5311}
+{"text":"TorchScript graph-mode inference performance on x86 CPU is boosted by adding channels last and BF16 support to NNC. PyTorch users may benefit from channels last optimization on most popular x86 CPUs and benefit from BF16 optimization on Intel Cooper Lake Processor and Sapphire Rapids Processor. >2X geomean performance boost is observed on broad vision models with these two optimizations on Intel Cooper Lake Processor.","__index_level_0__":5312}
+{"text":"The performance benefit can be obtained with existing TorchScript, channels last and BF16 Autocast APIs. See code snippet below. We will migrate the optimizations in NNC to the new PyTorch DL Compiler TorchInductor.","__index_level_0__":5313}
+{"text":"<a name=\"betasupport\"> <\/a>","__index_level_0__":5314}
+{"text":"```python\nimport torch\nimport torchvision.models as models\nmodel = models.resnet50(pretrained=True)\n# Convert the model to channels-last\nmodel = model.to(memory_format=torch.channels_last)\nmodel.eval()\ndata = torch.rand(1, 3, 224, 224)\n# Convert the data to channels-lastdata = data.to(memory_format=torch.channels_last)\n# Enable autocast to run with BF16\nwith torch.cpu.amp.autocast(), torch.no_grad():\n# Trace the model\nmodel = torch.jit.trace(model, torch.rand(1, 3, 224, 224))\n\tmodel = torch.jit.freeze(model)\n\t# Run the traced model\n\tmodel(data)\n```","__index_level_0__":5315}
+{"text":"### (Beta) Support for M1 Devices","__index_level_0__":5316}
+{"text":"Since v1.12, PyTorch has been offering native builds for Apple\u00ae silicon machines that use Apple's new M1 chip as a prototype feature. In this release, we bring this feature to beta, providing improved support across PyTorch's APIs.","__index_level_0__":5317}
+{"text":"We now run tests for all submodules except `torch.distributed` on M1 macOS 12.6 instances. With this improved testing, we were able to fix features such as cpp extension and convolution correctness for certain inputs.","__index_level_0__":5318}
+{"text":"To get started, just install PyTorch v1.13 on your Apple silicon Mac running macOS 12 or later with a native version (arm64) of Python. Learn more with our [release notes](https:\/\/github.com\/pytorch\/pytorch\/releases).","__index_level_0__":5319}
+{"text":"## Prototype Features","__index_level_0__":5320}
+{"text":"<a name=\"arm\"><\/a>","__index_level_0__":5321}
+{"text":"### (Prototype) Arm\u00ae Compute Library (ACL) backend support for AWS Graviton","__index_level_0__":5322}
+{"text":"We achieved substantial improvements for CV and NLP inference on aarch64 cpu with Arm Compute Library (acl) to enable acl backend for pytorch and torch-xla modules. Highlights include:\n<a name=\"cudasanitizer\"> <\/a>","__index_level_0__":5323}
+{"text":"- Enabled mkldnn + acl as the default backend for aarch64 torch wheel.\n- Enabled mkldnn matmul operator for aarch64 bf16 device.\n- Brought TensorFlow xla+acl feature into torch-xla. We enhanced the TensorFlow xla with Arm Compute Library runtime for aarch64 cpu. These changes are included in TensorFlow master and then the upcoming TF 2.10. Once the torch-xla repo is updated for the tensorflow commit, it will have compiling support for torch-xla. We observed ~2.5-3x improvement for MLPerf Bert inference compared to the torch 1.12 wheel on Graviton3.","__index_level_0__":5324}
+{"text":"### (Prototype) CUDA Sanitizer","__index_level_0__":5325}
+{"text":"When enabled, the sanitizer begins to analyze low-level CUDA operations invoked as a result of the user\u2019s PyTorch code to detect data race errors caused by unsynchronized data access from different CUDA streams. The errors found are then printed along with stack traces of faulty accesses, much like [Thread Sanitizer](https:\/\/clang.llvm.org\/docs\/ThreadSanitizer.html) does. An example of a simple error and the output produced by the sanitizer can be viewed [here](https:\/\/gist.github.com\/sypneiwski\/5989d634f7090913b80012be835e811d). It will be especially useful for machine learning applications, where corrupted data can be easy to miss for a human and the errors may not always manifest themselves; the sanitizer will always be able to detect them.","__index_level_0__":5326}
+{"text":"### (Prototype) Limited Python 3.11 support","__index_level_0__":5327}
+{"text":"Binaries for Linux with Python 3.11 support are available to download via pip. Please follow the instructions on the [get started page](https:\/\/pytorch.org\/get-started\/locally\/). Please note that Python 3.11 support is only a preview. In particular, features including Distributed, Profiler, FX and JIT might not be fully functional yet.\n \n source: https:\/\/pytorch.org\/blog\/PyTorch-1.13-release\/ \n category: pytorch blogs","__index_level_0__":5328}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Celebrate PyTorch 2.0 with New Performance Features for AI Developers\"\nauthor: Intel\n---","__index_level_0__":5329}
+{"text":"Congratulations to the PyTorch Foundation for its release of **PyTorch 2.0**! In this blog, I discuss the four features for which Intel made significant contributions to PyTorch 2.0:","__index_level_0__":5330}
+{"text":"1. TorchInductor\n2. GNN\n3. INT8 Inference Optimization\n4. oneDNN Graph API","__index_level_0__":5331}
+{"text":"We at Intel are delighted to be part of the PyTorch community and appreciate the collaboration with and feedback from our colleagues at [Meta](http:\/\/www.meta.com\/) as we co-developed these features.","__index_level_0__":5332}
+{"text":"\nLet\u2019s get started.","__index_level_0__":5333}
+{"text":"\n## 1. TorchInductor CPU FP32 Inference Optimized","__index_level_0__":5334}
+{"text":"\nAs part of the PyTorch 2.0 compilation stack, TorchInductor CPU backend optimization brings notable performance improvements via graph compilation over the PyTorch eager mode.","__index_level_0__":5335}
+{"text":"\nThe TorchInductor CPU backend is sped up by leveraging the technologies from the [Intel\u00ae Extension for PyTorch](http:\/\/github.com\/intel\/intel-extension-for-pytorch) for Conv\/GEMM ops with post-op fusion and weight prepacking, and PyTorch ATen CPU kernels for memory-bound ops with explicit vectorization on top of OpenMP*-based thread parallelization.","__index_level_0__":5336}
+{"text":"\nWith these optimizations on top of the powerful loop fusions in TorchInductor codegen, we achieved up to a **1.7x** FP32 inference performance boost over three representative deep learning benchmarks: TorchBench, HuggingFace, and timm1. Training and low-precision support are under development.","__index_level_0__":5337}
+{"text":"\n### See the Improvements","__index_level_0__":5338}
+{"text":"\nThe performance improvements on various backends are tracked on this [TouchInductor CPU Performance Dashboard](http:\/\/github.com\/pytorch\/pytorch\/issues\/93531#issuecomment-1457373890).","__index_level_0__":5339}
+{"text":"\n## Improve Graph Neural Network (GNN) in PyG for Inference and Training Performance on CPU","__index_level_0__":5340}
+{"text":"\nGNN is a powerful tool to analyze graph structure data. This feature is designed to improve GNN inference and training performance on Intel\u00ae CPUs, including the new 4th Gen Intel\u00ae Xeon\u00ae Scalable processors.","__index_level_0__":5341}
+{"text":"\nPyTorch Geometric (PyG) is a very popular library built upon PyTorch to perform GNN workflows. Currently on CPU, GNN models of PyG run slowly due to the lack of GNN-related sparse matrix multiplication operations (i.e., SpMM_reduce) and the lack of several critical kernel-level optimizations (scatter\/gather, etc.) tuned for GNN compute.","__index_level_0__":5342}
+{"text":"\nTo address this, optimizations are provided for message passing between adjacent neural network nodes:","__index_level_0__":5343}
+{"text":"* **scatter_reduce:** performance hotspot in message-passing when the edge index is stored in coordinate format (COO).\n* **gather:** backward computation of scatter_reduce, specially tuned for the GNN compute when the index is an expanded tensor.\n* **torch.sparse.mm with reduce flag:** performance hotspot in message-passing when the edge index is stored in compressed sparse row (CSR). Supported reduce flag for: sum, mean, amax, amin.","__index_level_0__":5344}
+{"text":"End-to-end performance benchmark results for both inference and training on 3rd Gen Intel\u00ae Xeon\u00ae Scalable processors 8380 platform and on 4th Gen 8480+ platform are discussed in [Accelerating PyG on Intel CPUs](http:\/\/www.pyg.org\/ns-newsarticle-accelerating-pyg-on-intel-cpus).","__index_level_0__":5345}
+{"text":"\n## Optimize int8 Inference with Unified Quantization Backend for x86 CPU Platforms  ","__index_level_0__":5346}
+{"text":"\nThe new X86 quantization backend is a combination of [FBGEMM](http:\/\/github.com\/pytorch\/FBGEMM) (Facebook General Matrix-Matrix Multiplication) and [oneAPI Deep Neural Network Library (oneDNN](http:\/\/spec.oneapi.io\/versions\/latest\/elements\/oneDNN\/source\/index.html)) backends and replaces FBGEMM as the default quantization backend for x86 platforms. The result: better end-to-end int8 inference performance than FBGEMM.","__index_level_0__":5347}
+{"text":"\nUsers access the x86 quantization backend by default for x86 platforms, and the selection between different kernels is automatically done behind the scenes. The rules of selection are based on prior performance testing data done by Intel during feature development. Thus, the x86 backend replaces FBGEMM and may offer better performance, depending on the use case.","__index_level_0__":5348}
+{"text":"\nThe selection rules are:","__index_level_0__":5349}
+{"text":"* On platforms without VNNI (e.g., Intel\u00ae Core\u2122 i7 processors), FBGEMM is always used.\n* On platforms with VNNI (e.g., 2nd-4th Gen Intel\u00ae Xeon\u00ae Scalable processors and future platforms):\n    * For linear, FBGEMM is always used.\n    * For convolution layers, FBGEMM is used for depth-wise convolution whose layers > 100; otherwise, oneDNN is used.","__index_level_0__":5350}
+{"text":"Note that as the kernels continue to evolve.","__index_level_0__":5351}
+{"text":"\nThe selection rules above are subject to change to achieve better performance. Performance metrics for through-put speed-up ratios of unified x86 backend vs. pure FBGEMM are discussed in [[RFC] Unified quantization backend for x86 CPU platforms #83888](http:\/\/github.com\/pytorch\/pytorch\/issues\/83888).","__index_level_0__":5352}
+{"text":"\n## Leverage oneDNN Graph API to Accelerate Inference on CPU ","__index_level_0__":5353}
+{"text":"\n[oneDNN Graph API](http:\/\/spec.oneapi.io\/onednn-graph\/latest\/introduction.html) extends [oneDNN](http:\/\/spec.oneapi.io\/versions\/latest\/elements\/oneDNN\/source\/index.html) with a flexible graph API to maximize the optimization opportunity for generating efficient code on Intel\u00ae AI hardware. It automatically identifies the graph partitions to be accelerated via fusion. The [fusion patterns](http:\/\/github.com\/oneapi-src\/oneDNN\/blob\/dev-graph\/doc\/programming_model\/ops_and_patterns.md#fusion-patterns) focus on fusing compute-intensive operations such as convolution, matmul, and their neighbor operations for both inference and training use cases.","__index_level_0__":5354}
+{"text":"\nCurrently, BFloat16 and Float32 datatypes are supported and only inference workloads can be optimized.  BF16 is only optimized on machines with Intel\u00ae Advanced Vector Extensions 512 (Intel\u00ae AVX-512) BF16 support.","__index_level_0__":5355}
+{"text":"\nFew or no modifications are needed in PyTorch to support newer oneDNN Graph fusions\/optimized kernels. To use oneDNN Graph, users can:","__index_level_0__":5356}
+{"text":"* Either use the API _torch.jit.enable_onednn_fusion(True)_ before JIT tracing a model, OR \u2026\n* Use its context manager, viz. _with torch.jit.fuser(\u201cfuser3\u201d)._\n* For accelerating [BFloat16 inference](http:\/\/github.com\/pytorch\/pytorch\/tree\/master\/torch\/csrc\/jit\/codegen\/onednn#example-with-bfloat16), we rely on eager-mode AMP (Automatic Mixed Precision) support in PyTorch and disable JIT mode\u2019s AMP.","__index_level_0__":5357}
+{"text":"See the [PyTorch performance tuning guide](http:\/\/pytorch.org\/tutorials\/recipes\/recipes\/tuning_guide.html#use-onednn-graph-with-torchscript-for-inference).","__index_level_0__":5358}
+{"text":"\n## Next Steps","__index_level_0__":5359}
+{"text":"\n### Get the Software","__index_level_0__":5360}
+{"text":"\n[Try out PyTorch 2.0](http:\/\/pytorch.org\/get-started\/locally\/) and realize the performance benefits for yourself from these Intel-contributed features.","__index_level_0__":5361}
+{"text":"\nWe encourage you to check out Intel\u2019s other [AI Tools](https:\/\/www.intel.com\/content\/www\/us\/en\/developer\/topic-technology\/artificial-intelligence\/tools.html) and [Framework](https:\/\/www.intel.com\/content\/www\/us\/en\/developer\/tools\/frameworks\/overview.html) optimizations and learn about the open, standards-based [oneAPI](https:\/\/www.intel.com\/content\/www\/us\/en\/developer\/tools\/oneapi\/overview.html) multiarchitecture, multivendor programming model that forms the foundation of Intel\u2019s AI software portfolio.","__index_level_0__":5362}
+{"text":"\nFor more details about 4th Gen Intel Xeon Scalable processor, visit [AI Platform](https:\/\/www.intel.com\/content\/www\/us\/en\/developer\/topic-technology\/artificial-intelligence\/platform.html) where you can learn about how Intel is empowering developers to run high-performance, efficient end-to-end AI pipelines.","__index_level_0__":5363}
+{"text":"\n### PyTorch Resources","__index_level_0__":5364}
+{"text":"* [PyTorch Get Started](http:\/\/pytorch.org\/get-started\/pytorch-2.0\/)\n* [Dev Discussions](http:\/\/dev-discuss.pytorch.org\/t\/pytorch-release-2-0-execution-update\/1077)\n* [Documentation](http:\/\/pytorch.org\/docs\/2.0\/)\n \n source: https:\/\/pytorch.org\/blog\/celebrate-pytorch-2.0\/ \n category: pytorch blogs","__index_level_0__":5365}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"What Every User Should Know About Mixed Precision Training in PyTorch\"\nauthor: Syed Ahmed, Christian Sarofeen, Mike Ruberry, Eddie Yan, Natalia Gimelshein, Michael Carilli, Szymon Migacz, Piotr Bialecki, Paulius Micikevicius, Dusan Stosic, Dong Yang, and Naoya Maruyama\nfeatured-img: ''\n---","__index_level_0__":5366}
+{"text":"Efficient training of modern neural networks often relies on using lower precision data types. Peak float16 matrix multiplication and convolution performance is 16x faster than peak float32 performance on A100 GPUs. And since the float16 and bfloat16 data types are only half the size of float32 they can double the performance of bandwidth-bound kernels and reduce the memory required to train a network, allowing for larger models, larger batches, or larger inputs. Using a module like [torch.amp](https:\/\/pytorch.org\/docs\/master\/amp.html) (short for \u201cAutomated Mixed Precision\u201d) makes it easy to get the speed and memory usage benefits of lower precision data types while preserving convergence behavior.","__index_level_0__":5367}
+{"text":"Going faster and using less memory is always advantageous \u2013 deep learning practitioners can test more model architectures and hyperparameters, and larger, more powerful models can be trained. Training very large models like those described in [Narayanan et al.](https:\/\/arxiv.org\/pdf\/2104.04473.pdf) and [Brown et al.](https:\/\/arxiv.org\/pdf\/2005.14165.pdf) (which take thousands of GPUs months to train even with expert handwritten optimizations) is infeasible without using mixed precision.","__index_level_0__":5368}
+{"text":"We\u2019ve talked about mixed precision techniques before ([here](https:\/\/pytorch.org\/blog\/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision\/), [here](https:\/\/docs.nvidia.com\/deeplearning\/performance\/mixed-precision-training\/index.html), and [here](https:\/\/developer.nvidia.com\/automatic-mixed-precision)), and this blog post is a summary of those techniques and an introduction if you\u2019re new to mixed precision.","__index_level_0__":5369}
+{"text":"## Mixed Precision Training in Practice","__index_level_0__":5370}
+{"text":"Mixed precision training techniques \u2013 the use of the lower precision float16 or bfloat16 data types alongside the float32 data type \u2013 are broadly applicable and effective. See Figure 1 for a sampling of models successfully trained with mixed precision, and Figures 2 and 3 for example speedups using torch.amp.","__index_level_0__":5371}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/mixed-precision-training-figure1.png\" width=\"80%\">\n<\/p>","__index_level_0__":5372}
+{"text":"<p align=\"center\">\n Figure 1: Sampling of DL Workloads Successfully Trained with float16 (<a href=\"https:\/\/nvlabs.github.io\/eccv2020-mixed-precision-tutorial\/files\/dusan_stosic-training-neural-networks-with-tensor-cores.pdf\">Source<\/a>).\n<\/p>","__index_level_0__":5373}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/mixed-precision-training-figure2.png\" width=\"80%\">\n<\/p>","__index_level_0__":5374}
+{"text":"<p align=\"center\">\n Figure 2: Performance of mixed precision training using torch.amp on NVIDIA 8xV100 vs. float32 training on 8xV100 GPU. Bars represent the speedup factor of torch.amp over float32. \n(Higher is better.) (<a href=\"https:\/\/pytorch.org\/blog\/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision\/\">Source<\/a>).\n<\/p>","__index_level_0__":5375}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/mixed-precision-training-figure3.png\" width=\"80%\">\n<\/p>","__index_level_0__":5376}
+{"text":"<p align=\"center\">\n Figure 3. Performance of mixed precision training using torch.amp on NVIDIA 8xA100 vs. 8xV100 GPU. Bars represent the speedup factor of A100 over V100.\n(Higher is Better.) (<a href=\"https:\/\/pytorch.org\/blog\/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision\/\">Source<\/a>).\n<\/p>","__index_level_0__":5377}
+{"text":"See the [NVIDIA Deep Learning Examples repository](https:\/\/github.com\/NVIDIA\/DeepLearningExamples) for more sample mixed precision workloads.","__index_level_0__":5378}
+{"text":"Similar performance charts can be seen in [3D medical image analysis](https:\/\/nvlabs.github.io\/eccv2020-mixed-precision-tutorial\/files\/dong_yang-mixed-precision-training-for-3d-medical-image-analysis.pdf), [gaze estimation](https:\/\/nvlabs.github.io\/eccv2020-mixed-precision-tutorial\/files\/shalini_de_mello-mixed-precision-training-for-faze.pdf), [video synthesis](https:\/\/nvlabs.github.io\/eccv2020-mixed-precision-tutorial\/files\/tingchun_wang-mixed-precision-vid2vid.pdf), [conditional GANs](https:\/\/nvlabs.github.io\/eccv2020-mixed-precision-tutorial\/files\/mingyu_liu-amp-imaginaire.pdf), and [convolutional LSTMs](https:\/\/nvlabs.github.io\/eccv2020-mixed-precision-tutorial\/files\/wonmin_byeon-mixed-precision-training-for-convolutional-tensor-train-lstm.pdf). [Huang et al](https:\/\/pytorch.org\/blog\/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision\/). showed that mixed precision training is 1.5x to 5.5x faster over float32 on V100 GPUs, and an additional 1.3x to 2.5x faster on A100 GPUs on a variety of networks. On very large networks the need for mixed precision is even more evident. [Narayanan et al](https:\/\/arxiv.org\/pdf\/2104.04473.pdf). reports that it would take 34 days to train GPT-3 175B on 1024 A100 GPUs (with a batch size of 1536), but it\u2019s estimated it would take over a year using float32!","__index_level_0__":5379}
+{"text":"## Getting Started With Mixed Precision Using torch.amp","__index_level_0__":5380}
+{"text":"torch.amp, introduced in PyTorch 1.6, makes it easy to leverage mixed precision training using the float16 or bfloat16 dtypes. See this [blog post](https:\/\/pytorch.org\/blog\/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision\/), [tutorial](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/amp_recipe.html), and [documentation](https:\/\/pytorch.org\/docs\/master\/amp.html) for more details. Figure 4 shows an example of applying AMP with grad scaling to a network.","__index_level_0__":5381}
+{"text":"```console\nimport torch\n# Creates once at the beginning of training\nscaler = torch.cuda.amp.GradScaler()","__index_level_0__":5382}
+{"text":"for data, label in data_iter:\n   optimizer.zero_grad()\n   # Casts operations to mixed precision\n   with torch.amp.autocast(device_type=\u201ccuda\u201d, dtype=torch.float16):\n      loss = model(data)","__index_level_0__":5383}
+{"text":"   # Scales the loss, and calls backward()\n   # to create scaled gradients\n   scaler.scale(loss).backward()","__index_level_0__":5384}
+{"text":"   # Unscales gradients and calls\n   # or skips optimizer.step()\n   scaler.step(optimizer)","__index_level_0__":5385}
+{"text":"   # Updates the scale for next iteration\n   scaler.update()\n```","__index_level_0__":5386}
+{"text":"<p align=\"center\">\n Figure 4: AMP recipe\n<\/p>","__index_level_0__":5387}
+{"text":"### Picking The Right Approach","__index_level_0__":5388}
+{"text":"Out-of-the-box mixed precision training with either float16 or bfloat16 is effective at speeding up the convergence of many deep learning models, but some models may require more careful numerical accuracy management. Here are some options:","__index_level_0__":5389}
+{"text":"- Full float32 precision. Floating point tensors and modules are created in float32 precision by default in PyTorch, but this is a historic artifact not representative of training most modern deep learning networks. It\u2019s rare that networks need this much numerical accuracy.\n- Enabling TensorFloat32 (TF32) mode. On Ampere and later CUDA devices matrix multiplications and convolutions can use the TensorFloat32 (TF32) mode for faster but slightly less accurate computations. See the [Accelerating AI Training with NVIDIA TF32 Tensor Cores](https:\/\/developer.nvidia.com\/blog\/accelerating-ai-training-with-tf32-tensor-cores\/) blog post for more details. By default PyTorch enables TF32 mode for convolutions but not matrix multiplications, and unless a network requires full float32 precision we recommend enabling this setting for matrix multiplications, too (see the documentation [here](https:\/\/pytorch.org\/docs\/master\/generated\/torch.set_float32_matmul_precision.html?highlight=precision#torch.set_float32_matmul_precision) for how to do so). It can significantly speed up computations with typically negligible loss of numerical accuracy.\n- Using torch.amp with bfloat16 or float16. Both these low precision floating point data types are usually comparably fast, but some networks may only converge with one vs the other. If a network requires more precision it may need to use float16, and if a network requires more dynamic range it may need to use bfloat16, whose dynamic range is equal to that of float32. If overflows are observed, for example, then we suggest trying bfloat16.","__index_level_0__":5390}
+{"text":"There are even more advanced options than those presented here, like using torch.amp\u2019s autocasting for only parts of a model, or managing mixed precision directly. These topics are largely beyond the scope of this blog post, but see the \u201cBest Practices\u201d section below.","__index_level_0__":5391}
+{"text":"### Best Practices","__index_level_0__":5392}
+{"text":"We strongly recommend using mixed precision with torch.amp or the TF32 mode (on Ampere and later CUDA devices) whenever possible when training a network. If one of those approaches doesn\u2019t work, however, we recommend the following:","__index_level_0__":5393}
+{"text":"- High Performance Computing (HPC) applications, regression tasks, and generative networks may simply require full float32 IEEE precision to converge as expected.\n- Try selectively applying torch.amp. In particular we recommend first disabling it on regions performing operations from the torch.linalg module or when doing pre- or post-processing. These operations are often especially sensitive. Note that TF32 mode is a global switch and can\u2019t be used selectively on regions of a network. Enable TF32 first to check if a network\u2019s operators are sensitive to the mode, otherwise disable it.\n- If you encounter type mismatches while using torch.amp we don\u2019t suggest inserting manual casts to start. This error is indicative of something being off with the network, and it\u2019s usually worth investigating first.\n- Figure out by experimentation if your network is sensitive to range and\/or precision of a format. For example [fine-tuning bfloat16-pretrained models in float16](https:\/\/github.com\/huggingface\/transformers\/pull\/10956) can easily run into range issues in float16 because of the potentially large range from training in bfloat16, so users should stick with bfloat16 fine-tuning if the model was trained in bfloat16.\n- The performance gain of mixed precision training can depend on multiple factors (e.g. compute-bound vs memory-bound problems) and users should use the [tuning guide](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/tuning_guide.html) to remove other bottlenecks in their training scripts. Although having similar theoretical performance benefits, BF16 and FP16 can have different speeds in practice. It\u2019s recommended to try the mentioned formats and use the one with best speed while maintaining the desired numeric behavior.","__index_level_0__":5394}
+{"text":"For more details, refer to the [AMP Tutorial](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/amp_recipe.html), [Training Neural Networks with Tensor Cores](https:\/\/nvlabs.github.io\/eccv2020-mixed-precision-tutorial\/.), and see the post \u201c[More In-Depth Details of Floating Point Precision](https:\/\/dev-discuss.pytorch.org\/t\/more-in-depth-details-of-floating-point-precision\/654)\" on PyTorch Dev Discussion.","__index_level_0__":5395}
+{"text":"## Conclusion","__index_level_0__":5396}
+{"text":"Mixed precision training is an essential tool for training deep learning models on modern hardware, and it will become even more important in the future as the performance gap between lower precision operations and float32 continues to grow on newer hardware, as reflected in Figure 5.","__index_level_0__":5397}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/mixed-precision-training-figure5.png\" width=\"80%\">\n<\/p>","__index_level_0__":5398}
+{"text":"<p align=\"center\">\nFigure 5: Relative peak throughput of float16 (FP16) vs float32 matrix multiplications on Volta and Ampere GPUs. On Ampere relative peak throughput for the TensorFloat32 (TF32) mode and bfloat16 matrix multiplications are shown, too. The relative peak throughput of low precision data types like float16 and bfloat16 vs. float32 matrix multiplications is expected to grow as new hardware is released.\n<\/p>","__index_level_0__":5399}
+{"text":"PyTorch\u2019s torch.amp module makes it easy to get started with mixed precision, and we highly recommend using it to train faster and reduce memory usage. torch.amp supports both float16 and bfloat16 mixed precision.","__index_level_0__":5400}
+{"text":"There are still some networks that are tricky to train with mixed precision, and for these networks we recommend trying TF32 accelerated matrix multiplications on Ampere and later CUDA hardware. Networks are rarely so precision sensitive that they require full float32 precision for every operation.","__index_level_0__":5401}
+{"text":"If you have questions or suggestions for torch.amp or mixed precision support in PyTorch then let us know by posting to the [mixed precision category on the PyTorch Forums](https:\/\/discuss.pytorch.org\/c\/mixed-precision\/27) or [filing an issue on the PyTorch GitHub page](https:\/\/github.com\/pytorch\/pytorch\/issues\/new\/choose).\n \n source: https:\/\/pytorch.org\/blog\/what-every-user-should-know-about-mixed-precision-training-in-pytorch\/ \n category: pytorch blogs","__index_level_0__":5402}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Everything you need to know about TorchVision\u2019s MobileNetV3 implementation'\nauthor: Vasilis Vryniotis and Francisco Massa\n---","__index_level_0__":5403}
+{"text":"In TorchVision v0.9, we released a series of [new mobile-friendly models](https:\/\/pytorch.org\/blog\/ml-models-torchvision-v0.9\/) that can be used for Classification, Object Detection and Semantic Segmentation. In this article, we will dig deep into the code of the models, share notable implementation details, explain how we configured and trained them, and highlight important tradeoffs we made during their tuning. Our goal is to disclose technical details that typically remain undocumented in the original papers and repos of the models.","__index_level_0__":5404}
+{"text":"### Network Architecture","__index_level_0__":5405}
+{"text":"The implementation of the [MobileNetV3 architecture](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py) follows closely the [original paper](https:\/\/arxiv.org\/abs\/1905.02244). It is customizable and offers different configurations for building Classification, Object Detection and Semantic Segmentation backbones. It was designed to follow a similar structure to MobileNetV2 and the two share [common building blocks](https:\/\/github.com\/pytorch\/vision\/blob\/cac8a97b0bd14eddeff56f87a890d5cc85776e18\/torchvision\/models\/mobilenetv2.py#L32).","__index_level_0__":5406}
+{"text":"Off-the-shelf, we offer the two variants described on the paper: the [Large](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L196-L214) and the [Small](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L215-L229). Both are constructed using the same code with the only difference being their configuration which describes the number of blocks, their sizes, their activation functions etc.","__index_level_0__":5407}
+{"text":"### Configuration parameters","__index_level_0__":5408}
+{"text":"Even though one can write a [custom InvertedResidual setting](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L105) and pass it to the MobileNetV3 class directly, for the majority of applications we can adapt the existing configs by passing parameters to the [model building methods](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L253). Some of the key configuration parameters are the following:","__index_level_0__":5409}
+{"text":"- The `width_mult` [parameter](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L188) is a multiplier that affects the number of channels of the model. The default value is 1 and by increasing or decreasing it one can change the number of filters of all convolutions, including the ones of the first and last layers. The implementation ensures that the number of filters is always a [multiple of 8](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L56-L57). This is a hardware optimization trick which allows for faster vectorization of operations.","__index_level_0__":5410}
+{"text":"- The `reduced_tail` [parameter](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L188) halves the number of channels on the [last blocks](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L210-L214) of the network. This version is used by some Object Detection and Semantic Segmentation models. It\u2019s a speed optimization which is described on the [MobileNetV3 paper](https:\/\/arxiv.org\/abs\/1905.02244) and reportedly leads to a 15% latency reduction without a significant negative effect on accuracy.","__index_level_0__":5411}
+{"text":"- The `dilated` [parameter](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L188) affects the [last 3](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L210-L212) InvertedResidual blocks of the model and turns their normal depthwise Convolutions to Atrous Convolutions. This is used to control the output stride of these blocks and has a [significant positive effect](https:\/\/arxiv.org\/abs\/1706.05587) on the accuracy of Semantic Segmentation models.","__index_level_0__":5412}
+{"text":"### Implementation details","__index_level_0__":5413}
+{"text":"Below we provide additional information on some notable implementation details of the architecture.\nThe [MobileNetV3 class](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L101) is responsible for building a network out of the provided configuration. Here are some implementation details of the class:","__index_level_0__":5414}
+{"text":"- The last convolution block expands the output of the last InvertedResidual block by a [factor of 6](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L149). The implementation is aligned with the Large and Small configurations described on the paper and can adapt to different values of the multiplier parameter.","__index_level_0__":5415}
+{"text":"- Similarly to other models such as MobileNetV2, a dropout layer is placed just before the final Linear layer of the classifier.","__index_level_0__":5416}
+{"text":"The [InvertedResidual class](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L60) is the main building block of the network. Here are some notable implementation details of the block along with its visualization which comes from Figure 4 of the paper:","__index_level_0__":5417}
+{"text":"- There is no [expansion step](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L73-L76) if the input channels and the expanded channels are the same. This happens on the first convolution block of the network.","__index_level_0__":5418}
+{"text":"- There is always a [projection step](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L86-L88) even when the expanded channels are the same as the output channels.","__index_level_0__":5419}
+{"text":"- The activation method of the depthwise block is placed [before](https:\/\/github.com\/pytorch\/vision\/blob\/11bf27e37190b320216c349e39b085fb33aefed1\/torchvision\/models\/mobilenetv3.py#L82-L84) the Squeeze-and-Excite layer as this improves marginally the accuracy.","__index_level_0__":5420}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/mobilenet-v3-block.png\" width=\"100%\">\n<\/div>","__index_level_0__":5421}
+{"text":"### Classification","__index_level_0__":5422}
+{"text":"In this section we provide benchmarks of the pre-trained models and details on how they were configured, trained and quantized.","__index_level_0__":5423}
+{"text":"**Benchmarks**","__index_level_0__":5424}
+{"text":"Here is how to initialize the pre-trained models:\n```\nlarge = torchvision.models.mobilenet_v3_large(pretrained=True, width_mult=1.0,  reduced_tail=False, dilated=False)\nsmall = torchvision.models.mobilenet_v3_small(pretrained=True)\nquantized = torchvision.models.quantization.mobilenet_v3_large(pretrained=True)\n```","__index_level_0__":5425}
+{"text":"Below we have the detailed benchmarks between new and selected previous models. As we can see MobileNetV3-Large is a viable replacement of ResNet50 for users who are willing to sacrifice a bit of accuracy for a roughly 6x speed-up:","__index_level_0__":5426}
+{"text":"| Model                       | Acc@1  | Acc@5  | Inference on CPU (sec) | # Params (M) |\n|-----------------------------|--------:|--------:|------------------------:|--------------:|\n| MobileNetV3-Large           | 74.042 | 91.340 |                 0.0411 |         5.48 |\n| MobileNetV3-Small           | 67.668 | 87.402 |                 0.0165 |         2.54 |\n| Quantized MobileNetV3-Large | 73.004 | 90.858 |                 0.0162 |         2.96 |\n| MobileNetV2                 | 71.880 | 90.290 |                 0.0608 |         3.50 |\n| ResNet50                    | 76.150 | 92.870 |                 0.2545 |        25.56 |\n| ResNet18                    | 69.760 | 89.080 |                 0.1032 |        11.69 |","__index_level_0__":5427}
+{"text":"Note that the inference times are measured on CPU. They are not absolute benchmarks, but they allow for relative comparisons between models.","__index_level_0__":5428}
+{"text":"**Training process**","__index_level_0__":5429}
+{"text":"All pre-trained models are configured with a width multiplier of 1, have full tails, are non-dilated, and were fitted on ImageNet. Both the Large and Small variants were trained using the same hyper-parameters and scripts which can be found in our [references](https:\/\/github.com\/pytorch\/vision\/tree\/c2ab0c59f42babf9ad01aa616cd8a901daac86dd\/references\/classification#mobilenetv3-large--small) folder. Below we provide details on the most notable aspects of the training process.","__index_level_0__":5430}
+{"text":" **Achieving fast and stable training**","__index_level_0__":5431}
+{"text":"[Configuring RMSProp](https:\/\/github.com\/pytorch\/vision\/blob\/c2ab0c59f42babf9ad01aa616cd8a901daac86dd\/references\/classification\/train.py#L172-L173) correctly was crucial to achieve fast training with numerical stability. The authors of the paper used TensorFlow in their experiments and in their runs they reported using [quite high](https:\/\/github.com\/tensorflow\/models\/tree\/master\/research\/slim\/nets\/mobilenet#v3) `rmsprop_epsilon` comparing to the default. Typically this hyper-parameter takes small values as it\u2019s used to avoid zero denominators, but in this specific model choosing the right value seems important to avoid numerical instabilities in the loss.","__index_level_0__":5432}
+{"text":"Another important detail is that though PyTorch\u2019s and TensorFlow\u2019s RMSProp implementations typically behave similarly, there are [a few differences](https:\/\/github.com\/pytorch\/pytorch\/issues\/32545) with the most notable in our setup being how the epsilon hyperparameter is handled. More specifically, PyTorch adds the epsilon [outside of the square root calculation](https:\/\/github.com\/tensorflow\/tensorflow\/blob\/v2.5.0\/tensorflow\/python\/training\/rmsprop.py#L25) while TensorFlow [adds it inside](https:\/\/github.com\/tensorflow\/tensorflow\/blob\/v2.5.0\/tensorflow\/python\/training\/rmsprop.py#L25). The result of this implementation detail is that one needs to adjust the epsilon value while porting the hyper parameter of the paper. A reasonable approximation can be taken with the formula `PyTorch_eps = sqrt(TF_eps)`.","__index_level_0__":5433}
+{"text":"**Increasing our accuracy by tuning hyperparameters & improving our training recipe**","__index_level_0__":5434}
+{"text":"After configuring the optimizer to achieve fast and stable training, we turned into optimizing the accuracy of the model. There are a few techniques that helped us achieve this. First of all, to avoid overfitting we augmented out data using the AutoAugment algorithm, followed by RandomErasing. Additionally we tuned parameters such as the weight decay using cross validation. We also found beneficial to perform [weight averaging](https:\/\/github.com\/pytorch\/vision\/blob\/674e8140042c2a3cbb1eb9ebad1fa49501599130\/references\/classification\/utils.py#L259) across different epoch checkpoints after the end of the training. Finally, though not used in our published training recipe, we found that using Label Smoothing, Stochastic Depth and LR noise injection improve the overall accuracy by over [1.5 points](https:\/\/rwightman.github.io\/pytorch-image-models\/training_hparam_examples\/#mobilenetv3-large-100-75766-top-1-92542-top-5).","__index_level_0__":5435}
+{"text":"The graph and table depict a simplified summary of the most important iterations for improving the accuracy of the MobileNetV3 Large variant. Note that the actual number of iterations done while training the model was significantly larger and that the progress in accuracy was not always monotonically increasing. Also note that the Y-axis of the graph starts from 70% instead from 0% to make the difference between iterations more visible:","__index_level_0__":5436}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/key-iterations-for-improving-the-accuracyof-mobilenetV3.png\" width=\"100%\">\n<\/div>","__index_level_0__":5437}
+{"text":"| Iteration                                       | Acc@1  | Acc@5  |\n|-------------------------------------------------|--------:|--------:|\n| Baseline with \"MobileNetV2-style\" Hyperparams   | 71.542 | 90.068 |\n| + RMSProp with default eps                      | 70.684 |  89.38 |\n| + RMSProp with adjusted eps & LR scheme         | 71.764 | 90.178 |\n| + Data Augmentation & Tuned Hyperparams         | 73.86  | 91.292 |\n| + Checkpoint Averaging                          | 74.028 | 91.382 |\n| + Label Smoothing & Stochastic Depth & LR noise | 75.536 | 92.368 |","__index_level_0__":5438}
+{"text":"Note that once we\u2019ve achieved an acceptable accuracy, we verified the model performance on the hold-out test dataset which hasn't been used before for training or hyper-parameter tuning. This process helps us detect overfitting and is always performed for all pre-trained models prior their release.","__index_level_0__":5439}
+{"text":"**Quantization**","__index_level_0__":5440}
+{"text":"We currently offer quantized weights for the QNNPACK backend of the [MobileNetV3-Large variant](https:\/\/github.com\/pytorch\/vision\/blob\/b94a4014a68d08f37697f4672729571a46f0042d\/torchvision\/models\/quantization\/mobilenetv3.py#L115) which provides a speed-up of 2.5x. To quantize the model, Quantized Aware Training (QAT) was used. The hyper parameters and the scripts used to train the model can be found in our [references](https:\/\/github.com\/pytorch\/vision\/tree\/c2ab0c59f42babf9ad01aa616cd8a901daac86dd\/references\/classification#quantized) folder.","__index_level_0__":5441}
+{"text":"Note that QAT allows us to model the effects of quantization and adjust the weights so that we can improve the model accuracy. This translates to an accuracy increase of 1.8 points comparing to simple post-training quantization:","__index_level_0__":5442}
+{"text":"| Quantization Status        | Acc@1  | Acc@5  |\n|----------------------------|--------:|--------:|\n| Non-quantized              | 74.042 | 91.340 |\n| Quantized Aware Training   | 73.004 | 90.858 |\n| Post-training Quantization | 71.160 | 89.834 |","__index_level_0__":5443}
+{"text":"### Object Detection","__index_level_0__":5444}
+{"text":"In this section, we will first provide benchmarks of the released models, and then discuss how the MobileNetV3-Large backbone was used in a Feature Pyramid Network along with the FasterRCNN detector to perform Object Detection. We will also explain how the network was trained and tuned alongside with any tradeoffs we had to make. We will not cover details about how it was used with [SSDlite](https:\/\/github.com\/pytorch\/vision\/blob\/b94a4014a68d08f37697f4672729571a46f0042d\/torchvision\/models\/detection\/ssdlite.py) as this will be discussed on a future article.","__index_level_0__":5445}
+{"text":"**Benchmarks**","__index_level_0__":5446}
+{"text":"Here is how the models are initialized:\n```\nhigh_res = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_fpn(pretrained=True) \nlow_res = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_320_fpn(pretrained=True)\n```","__index_level_0__":5447}
+{"text":"Below are some benchmarks between new and selected previous models. As we can see the high resolution Faster R-CNN with MobileNetV3-Large FPN backbone seems a viable replacement of the equivalent ResNet50 model for those users who are willing to sacrifice few accuracy points for a 5x speed-up:","__index_level_0__":5448}
+{"text":"| Model                                            | mAP  | Inference on CPU (sec) | # Params (M) |\n|--------------------------------------------------|------:|------------------------:|--------------:|\n| Faster R-CNN MobileNetV3-Large FPN (High-Res)    | 32.8 |                 0.8409 |        19.39 |\n| Faster R-CNN MobileNetV3-Large 320 FPN (Low-Res) | 22.8 |                 0.1679 |        19.39 |\n| Faster R-CNN ResNet-50 FPN                       | 37.0 |                 4.1514 |        41.76 |\n| RetinaNet ResNet-50 FPN                          | 36.4 |                 4.8825 |        34.01 |","__index_level_0__":5449}
+{"text":"**Implementation details**","__index_level_0__":5450}
+{"text":"The Detector uses a FPN-style backbone which extracts features from different convolutions of the MobileNetV3 model. [By default](https:\/\/github.com\/pytorch\/vision\/blob\/eca37cf735064702189ff5d5b1428cbe25ab2bcf\/torchvision\/models\/detection\/backbone_utils.py#L165-L166) the pre-trained model uses the output of the 13th InvertedResidual block and the output of the Convolution prior to the pooling layer but the implementation supports using the outputs of [more stages](https:\/\/github.com\/pytorch\/vision\/blob\/eca37cf735064702189ff5d5b1428cbe25ab2bcf\/torchvision\/models\/detection\/backbone_utils.py#L147-L150).","__index_level_0__":5451}
+{"text":"All feature maps extracted from the network have their output projected down to [256 channels](https:\/\/github.com\/pytorch\/vision\/blob\/eca37cf735064702189ff5d5b1428cbe25ab2bcf\/torchvision\/models\/detection\/backbone_utils.py#L160) by the FPN block as this greatly improves the speed of the network. These feature maps provided by the FPN backbone are used by the FasterRCNN detector to provide box and class predictions at [different scales](https:\/\/github.com\/pytorch\/vision\/blob\/7af30ee9ab64039d04150d118e8b72473184fd6e\/torchvision\/models\/detection\/faster_rcnn.py#L382-L389).","__index_level_0__":5452}
+{"text":"**Training & Tuning process**","__index_level_0__":5453}
+{"text":"We currently offer two pre-trained models capable of doing object detection at different resolutions. Both models were trained on the COCO dataset using the same hyper-parameters and scripts which can be found in our [references](https:\/\/github.com\/pytorch\/vision\/tree\/e35793a1a4000db1f9f99673437c514e24e65451\/references\/detection#faster-r-cnn-mobilenetv3-large-fpn) folder.","__index_level_0__":5454}
+{"text":"The [High Resolution detector](https:\/\/github.com\/pytorch\/vision\/blob\/7af30ee9ab64039d04150d118e8b72473184fd6e\/torchvision\/models\/detection\/faster_rcnn.py#L398-L399) was trained with images of 800-1333px, while the mobile-friendly [Low Resolution detector](https:\/\/github.com\/pytorch\/vision\/blob\/7af30ee9ab64039d04150d118e8b72473184fd6e\/torchvision\/models\/detection\/faster_rcnn.py#L398-L399) was trained with images of 320-640px. The reason why we provide two separate sets of pre-trained weights is because training a detector directly on the smaller images leads to a 5 mAP increase in precision comparing to passing small images to the pre-trained high-res model. Both backbones were initialized with weights fitted on ImageNet and the [3 last stages](https:\/\/github.com\/pytorch\/vision\/blob\/7af30ee9ab64039d04150d118e8b72473184fd6e\/torchvision\/models\/detection\/faster_rcnn.py#L377-L378) of their weights where fined-tuned during the training process.","__index_level_0__":5455}
+{"text":"An additional speed optimization can be applied on the mobile-friendly model by [tuning the RPN NMS thresholds](https:\/\/github.com\/pytorch\/vision\/blob\/7af30ee9ab64039d04150d118e8b72473184fd6e\/torchvision\/models\/detection\/faster_rcnn.py#L423-L424). By sacrificing only 0.2 mAP of precision we were able to improve the CPU speed of the model by roughly 45%. The details of the optimization can be seen below:","__index_level_0__":5456}
+{"text":"| Tuning Status | mAP  | Inference on CPU (sec) |\n|---------------|------:|------------------------:|\n| Before        | 23.0 |                 0.2904 |\n| After         | 22.8 |                 0.1679 |","__index_level_0__":5457}
+{"text":"Below we provide some examples of visualizing the predictions of the Faster R-CNN MobileNetV3-Large FPN model:","__index_level_0__":5458}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/detection.png\" width=\"100%\">\n<\/div>","__index_level_0__":5459}
+{"text":"### Semantic Segmentation","__index_level_0__":5460}
+{"text":"In this section we will start by providing some benchmarks of the released pre-trained models. Then we will discuss how a MobileNetV3-Large backbone was combined with segmentation heads such as [LR-ASPP](https:\/\/arxiv.org\/abs\/1905.02244), [DeepLabV3](https:\/\/arxiv.org\/abs\/1706.05587) and the [FCN](https:\/\/arxiv.org\/abs\/1411.4038) to conduct Semantic Segmentation. We will also explain how the network was trained and propose a few optional optimization techniques for speed critical applications.","__index_level_0__":5461}
+{"text":"**Benchmarks**","__index_level_0__":5462}
+{"text":"This is how to initialize the pre-trained models:","__index_level_0__":5463}
+{"text":"```\nlraspp = torchvision.models.segmentation.lraspp_mobilenet_v3_large(pretrained=True) \ndeeplabv3 = torchvision.models.segmentation.deeplabv3_mobilenet_v3_large(pretrained=True)\n```","__index_level_0__":5464}
+{"text":"Below are the detailed benchmarks between new and selected existing models. As we can see, the DeepLabV3 with a MobileNetV3-Large backbone is a viable replacement of FCN with ResNet50 for the majority of applications as it achieves similar accuracy with a 8.5x speed-up. We also observe that the LR-ASPP network supersedes the equivalent FCN in all metrics:","__index_level_0__":5465}
+{"text":"| Model                                | mIoU | Global Pixel Acc | Inference on CPU (sec) | # Params (M) |\n|--------------------------------------|------:|------------------:|------------------------:|--------------:|\n| LR-ASPP MobileNetV3-Large            | 57.9 |             91.2 |                 0.3278 |         3.22 |\n| DeepLabV3 MobileNetV3-Large          | 60.3 |             91.2 |                 0.5869 |        11.03 |\n| FCN MobileNetV3-Large (not released) | 57.8 |             90.9 |                 0.3702 |         5.05 |\n| DeepLabV3 ResNet50                   | 66.4 |             92.4 |                 6.3531 |        39.64 |\n| FCN ResNet50                         | 60.5 |             91.4 |                 5.0146 |        32.96 |","__index_level_0__":5466}
+{"text":"### Implementation details","__index_level_0__":5467}
+{"text":"In this section we will discuss important implementation details of tested segmentation heads. Note that all models described in this section use a dilated MobileNetV3-Large backbone.","__index_level_0__":5468}
+{"text":"**LR-ASPP**","__index_level_0__":5469}
+{"text":"The LR-ASPP is the Lite variant of the Reduced Atrous Spatial Pyramid Pooling model proposed by the authors of the MobileNetV3 paper. Unlike the other segmentation models in TorchVision, it does not make use of an [auxiliary loss](https:\/\/github.com\/pytorch\/vision\/blob\/b94a4014a68d08f37697f4672729571a46f0042d\/torchvision\/models\/segmentation\/segmentation.py#L185-L186). Instead it uses [low and high-level features](https:\/\/github.com\/pytorch\/vision\/blob\/b94a4014a68d08f37697f4672729571a46f0042d\/torchvision\/models\/segmentation\/segmentation.py#L92-L100) with output strides of 8 and 16 respectively.","__index_level_0__":5470}
+{"text":"Unlike the paper where a 49x49 AveragePooling layer with variable strides is used, [our implementation](https:\/\/github.com\/pytorch\/vision\/blob\/e2db2eddbb1699a59fbb5ccbec912979048ef3bf\/torchvision\/models\/segmentation\/lraspp.py#L53) uses an `AdaptiveAvgPool2d` layer to process the global features. This is because the authors of the paper tailored the head to the Cityscapes dataset while our focus is to provide a general purpose implementation that can work on multiple datasets. Finally our implementation always has a bilinear interpolation [before returning the output](https:\/\/github.com\/pytorch\/vision\/blob\/e2db2eddbb1699a59fbb5ccbec912979048ef3bf\/torchvision\/models\/segmentation\/lraspp.py#L35) to ensure that the sizes of the input and output images match exactly.","__index_level_0__":5471}
+{"text":"**DeepLabV3 & FCN**","__index_level_0__":5472}
+{"text":"The combination of MobileNetV3 with DeepLabV3 and FCN follows closely the ones of other models and the stage estimation for these methods is identical to LR-ASPP. The only notable difference is that instead of using high and low level features, [we attach](https:\/\/github.com\/pytorch\/vision\/blob\/b94a4014a68d08f37697f4672729571a46f0042d\/torchvision\/models\/segmentation\/segmentation.py#L37-L45) the normal loss to the feature map with output stride 16 and an auxiliary loss on the feature map with output stride 8.","__index_level_0__":5473}
+{"text":"Finally we should note that the FCN version of the model was not released because it was completely superseded by the LR-ASPP both in terms of speed and accuracy. The [pre-trained weights](https:\/\/github.com\/pytorch\/vision\/pull\/3276\/commits\/1641d5f4c7d41f534444fab340c598d61a91bd12#diff-ccff7af514d99eeb40416c8b9ec30f032d1a3f450aaa4057958ca39ab174452eL17) are still available and can be used with minimal changes to the code.","__index_level_0__":5474}
+{"text":"### Training & Tuning process","__index_level_0__":5475}
+{"text":"We currently offer two MobileNetV3 pre-trained models capable of doing semantic segmentation: the LR-ASPP and the DeepLabV3. The backbones of the models were [initialized with ImageNet weights](https:\/\/github.com\/pytorch\/vision\/blob\/b94a4014a68d08f37697f4672729571a46f0042d\/torchvision\/models\/segmentation\/segmentation.py#L89-L90) and trained end-to-end. Both architectures were trained on the COCO dataset using the same scripts with similar hyper-parameters. Their details can be found in our [references](https:\/\/github.com\/pytorch\/vision\/tree\/a78d0d83d0a499fe8480d7a9f493676e746c4699\/references\/segmentation#deeplabv3_mobilenet_v3_large) folder.","__index_level_0__":5476}
+{"text":"Normally, during inference the images are [resized to 520 pixels](https:\/\/github.com\/pytorch\/vision\/blob\/a78d0d83d0a499fe8480d7a9f493676e746c4699\/references\/segmentation\/train.py#L30-L33). An optional speed optimization is to construct a Low Res configuration of the model by using the High-Res pre-trained weights and reducing the inference resizing to 320 pixels. This will improve the CPU execution times by roughly 60% while sacrificing a couple of mIoU points. The detailed numbers of this optimization can be found on the table below:","__index_level_0__":5477}
+{"text":"| Low-Res Configuration | mIoU Difference | Speed Improvement | mIoU | Global Pixel Acc | Inference on CPU (sec) |\n|--------------------------------------|-----------------:|-------------------:|------:|------------------:|------------------------:|\n| LR-ASPP MobileNetV3-Large|            -2.1 |            65.26% | 55.8 |             90.3 |                 0.1139 |\n| DeepLabV3 MobileNetV3-Large          |            -3.8 |            63.86% | 56.5 |             90.3 |                 0.2121 |\n| FCN MobileNetV3-Large (not released) |            -3.0 |            57.57% | 54.8 |             90.1 |                 0.1571 |","__index_level_0__":5478}
+{"text":"Here are some examples of visualizing the predictions of the LR-ASPP MobileNetV3-Large model:","__index_level_0__":5479}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/segmentation.png\" width=\"100%\">\n<\/div>","__index_level_0__":5480}
+{"text":"We hope that you found this article interesting. We are looking forward to your feedback to see if this is the type of content you would like us to publish more often. If the community finds that such posts are useful, we will be happy to publish more articles that cover the implementation details of newly introduced Machine Learning models.\n \n source: https:\/\/pytorch.org\/blog\/torchvision-mobilenet-v3-implementation\/ \n category: pytorch blogs","__index_level_0__":5481}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch strengthens its governance by joining the Linux Foundation\"\nauthor: Soumith Chintala\nfeatured-img: \"\/assets\/images\/pytorch-foundation-blog-image.jpg\"\n---","__index_level_0__":5482}
+{"text":"Today, I am proud to announce that PyTorch is moving to the [Linux Foundation (LF)](https:\/\/www.linuxfoundation.org\/) as a top-level project under the name PyTorch Foundation. The [core mission](https:\/\/www.linuxfoundation.org\/about\/) of the Linux Foundation is the collaborative development of open source software. With a governing board of leaders from AMD, Amazon Web Services (AWS), Google Cloud, Meta, Microsoft Azure and NVIDIA, this model aligns with where PyTorch stands today and what it needs to travel forward. The creation of the PyTorch Foundation will ensure business decisions are being made in a transparent and open manner by a diverse group of members for years to come. The technical decisions remain in control of individual maintainers. I\u2019m excited that the Linux Foundation will be our new home as they have notable experience supporting large open-source projects like ours such as Kubernetes and NodeJS. At this pivotal moment, I want to take a look back at how we started, share why we are moving, and what\u2019s ahead.  ","__index_level_0__":5483}
+{"text":"This January, PyTorch celebrated its 5 year anniversary! I reflected on what it meant to me in this [tweet thread](https:\/\/soumith.ch\/posts\/2022\/01\/pytorch-retro\/), and [this](https:\/\/www.youtube.com\/watch?v=r7qB7mKJOFk) conversation with my colleagues Mike Schroepfer, Lin Qiao, and Yann LeCun. When we started PyTorch development in 2016, it was a collective effort by a band of people from the [Lua]Torch community with a big chunk of people and funding from Meta and individuals contributing from NVIDIA, Twitter and other entities.","__index_level_0__":5484}
+{"text":"Since 2017, PyTorch has grown far beyond our initial vision. With over [2,400 contributors](https:\/\/github.com\/pytorch\/pytorch\/graphs\/contributors) who have built nearly 154,000 projects using PyTorch as a foundation, PyTorch has become one of the primary platforms for AI research, as well as commercial production use. We\u2019ve seen its impact across industry and academia, from large companies to numerous university courses at Stanford, NYU, EPFL, Oxford, and other academic institutions. As a maintainer of PyTorch, the journey has been extremely fulfilling, with the impact of the project seen in various fields from self-driving cars to healthcare to aerospace.","__index_level_0__":5485}
+{"text":"As PyTorch grew, many companies have made foundational investments around it. While Meta remains the largest contributor to PyTorch, companies such as AMD, Amazon Web Services (AWS), Google Cloud,  HuggingFace,  Lightning AI, Microsoft Azure, Nvidia, and many others have made significant investments, including both technical contributions and community building efforts. They\u2019ve established teams around PyTorch or filled significant voids within the PyTorch community and sent countless contributions to the PyTorch core and to the ecosystem around it \u2014 PyTorch is an important part of their future. With PyTorch continuing to grow as a multi-stakeholder project, it\u2019s time to move to a broader open-source foundation. ","__index_level_0__":5486}
+{"text":"The business governance of PyTorch was fairly unstructured for quite some time since launch \u2013 we operated like a scrappy startup. Team members at Meta spent the time and energy to structure this properly and organize PyTorch into an organizationally more healthy entity. Meta helped PyTorch with introducing many structures, such as [Contributor License  Agreements](https:\/\/pytorch.org\/blog\/a-contributor-license-agreement-for-pytorch\/), [Branding Guidelines](https:\/\/pytorch.org\/assets\/brand-guidelines\/PyTorch-Brand-Guidelines.pdf), and Trademark registration. Keeping PyTorch\u2019s organizational health up to check is essential and beneficial for the community. The next stage of our organizational progress is to support the interests of multiple stakeholders, hence moving to a foundation is good. We chose the Linux Foundation as it has vast organization experience hosting large multi-stakeholder open-source projects with the right balance of organizational structure and finding specific solutions for these projects.","__index_level_0__":5487}
+{"text":"Simultaneously, the technical governance of PyTorch has been a loosely structured community model of open-source development \u2014 A set of people maintaining PyTorch by area with their responsibility often tied to their individual identity rather than their employment. While we kept a codified list at the [PyTorch - Maintainers](https:\/\/pytorch.org\/docs\/stable\/community\/persons_of_interest.html) page, the technical governance was not formalized nor codified. As PyTorch scales as a community, the next step is to structure and codify. The [PyTorch Technical Governance](https:\/\/pytorch.org\/docs\/master\/community\/governance.html) now supports a hierarchical maintainer structure and clear outlining of processes around day to day work and escalations. This doesn\u2019t change how we run things, but it does add discipline and openness that at our scale feels essential and timely.","__index_level_0__":5488}
+{"text":"It\u2019s been an exciting journey since 2016. I am grateful for the experiences and people I\u2019ve met along the way. PyTorch started with a small group of contributors which have grown and diversified over the years, all bringing in new ideas and innovations that would not have been possible without our community. We want to continue the open-source spirit \u2013 for the community and by the community. Thank you to our contributors, maintainers, users, supporters and new foundation members. We look forward to the next chapter of PyTorch with the PyTorch Foundation.","__index_level_0__":5489}
+{"text":" \n source: https:\/\/pytorch.org\/blog\/PyTorchfoundation\/ \n category: pytorch blogs","__index_level_0__":5490}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Fast Beam Search Decoding in PyTorch with TorchAudio and Flashlight Text\"\nauthor: Caroline Chen, Jacob Kahn (@jacob_d_kahn)\nfeatured-img: \"\/assets\/images\/fast-beam-search-decoding-in-pytorch-with-torchaudio-and-flashlight-text-6.png\"\n---","__index_level_0__":5491}
+{"text":"Beam search decoding with industry-leading speed from [Flashlight Text](https:\/\/github.com\/flashlight\/text) (part of the [Flashlight](https:\/\/arxiv.org\/abs\/2201.12465) ML framework) is now available with official support in [TorchAudio](https:\/\/pytorch.org\/audio\/0.12.0\/models.decoder.html#ctcdecoder), bringing high-performance beam search and text utilities for speech and text applications built on top of PyTorch. The current integration supports CTC-style decoding, but it can be used for *any modeling setting that outputs token-level probability distributions over time steps*.","__index_level_0__":5492}
+{"text":"## A brief beam search refresher","__index_level_0__":5493}
+{"text":"In speech and language settings, *beam search* is an efficient, greedy algorithm that can convert sequences of *continuous values* (i.e. probabilities or scores) into *graphs* or *sequences* (i.e. tokens, word-pieces, words) using *optional constraints* on valid sequences (i.e. a lexicon), *optional external scoring* (i.e. an LM which scores valid sequences), and other *score adjustments* for particular sequences.","__index_level_0__":5494}
+{"text":"In the example that follows, we'll consider \u2014 a token set of {\u03f5, a, b}, where \u03f5 is a special token that we can imagine denotes a space between words or a pause in speech. Graphics here and below are taken from Awni Hannun's excellent [distill.pub writeup](https:\/\/distill.pub\/2017\/ctc\/) on CTC and beam search.","__index_level_0__":5495}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/fast-beam-search-decoding-in-pytorch-with-torchaudio-and-flashlight-text-1.jpeg\" width=\"70%\">\n<\/p>","__index_level_0__":5496}
+{"text":"With a greedy-like approach, beam search considers the next viable token given an existing sequence of tokens \u2014 in the example above, a, b, b is a valid sequence, but a, b, a is not. We *rank* each possible next token at each step of the beam search according to a scoring function. Scoring functions (s) typically looks something like:","__index_level_0__":5497}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/fast-beam-search-decoding-in-pytorch-with-torchaudio-and-flashlight-text-2.jpeg\" width=\"80%\">\n<\/p>","__index_level_0__":5498}
+{"text":"Where **\u0177** is a potential path\/sequence of tokens, **x** is the input *<strong>(P(\u0177&#124;x)<\/strong>* represents the model's predictions over time), and \ud835\udefc is a weight on the language model probability *<strong>(P(y)<\/strong>* the probability of the sequence under the language model). Some scoring functions add *<strong>\ud835\udf37<\/strong>* which adjusts a score based on the length of the predicted sequence **&#124;\u0177&#124;**. This particular scoring function is used in [FAIR's prior work](https:\/\/arxiv.org\/pdf\/1911.08460.pdf) on end-to-end ASR, and there are many variations on scoring functions which can vary across application areas.","__index_level_0__":5499}
+{"text":"Given a particular sequence, to assess the next viable token in that sequence (perhaps constrained by a set of allowed words or sequences, such as a lexicon of words), the beam search algorithm scores the sequence with each candidate token added, and sorts token candidates based on those scores. For efficiency and since the number of paths is exponential in the token set size, the *<strong>top-k<\/strong>* highest-scoring candidates are kept \u2014 *<strong>k<\/strong>* represents the *<strong>beam size<\/strong>*.","__index_level_0__":5500}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/fast-beam-search-decoding-in-pytorch-with-torchaudio-and-flashlight-text-3.jpeg\" width=\"100%\">\n<\/p>","__index_level_0__":5501}
+{"text":"<p align=\"center\">There are many other nuances with how beam search can progress: similar hypothesis sequences can be \u201cmerged\u201d, for instance.\n<\/p>","__index_level_0__":5502}
+{"text":"The scoring function can be further augmented to up\/down-weight token insertion or long or short words. Scoring with *stronger external language* models, while incurring computational cost, can also significantly improve performance; this is frequently referred to as *LM fusion*. There are many other knobs to tune for decoding \u2014 these are documented in [TorchAudio\u2019s documentation](https:\/\/pytorch.org\/audio\/0.12.0\/models.decoder.html#ctcdecoder) and explored further in [TorchAudio\u2019s ASR Inference tutorial](https:\/\/pytorch.org\/audio\/0.12.0\/tutorials\/asr_inference_with_ctc_decoder_tutorial.html#beam-search-decoder-parameters). Since decoding is quite efficient, parameters can be easily swept and tuned.","__index_level_0__":5503}
+{"text":"Beam search has been used in ASR extensively over the years in far too many works to cite, and in strong, recent results and systems including [wav2vec 2.0](https:\/\/proceedings.neurips.cc\/paper\/2020\/file\/92d1e1eb1cd6f9fba3227870bb6d7f07-Paper.pdf) and [NVIDIA's NeMo](https:\/\/developer.nvidia.com\/nvidia-nemo).","__index_level_0__":5504}
+{"text":"## Why beam search?","__index_level_0__":5505}
+{"text":"Beam search remains a fast competitor to heavier-weight decoding approaches such as [RNN-Transducer](https:\/\/arxiv.org\/pdf\/1211.3711.pdf) that Google has invested in putting [on-device](https:\/\/ai.googleblog.com\/2019\/03\/an-all-neural-on-device-speech.html) and has shown strong results with on [common benchmarks](https:\/\/arxiv.org\/pdf\/2010.10504.pdf). Autoregressive text models at scale can benefit from beam search as well. Among other things, beam search gives:","__index_level_0__":5506}
+{"text":"- A flexible performance\/latency tradeoff \u2014 by adjusting beam size and the external LM, users can sacrifice latency for accuracy or pay for more accurate results with a small latency cost. Decoding with no external LM can improve results at very little performance cost.\n- Portability without retraining \u2014 existing neural models can benefit from multiple decoding setups and plug-and-play with external LMs without training or fine-tuning.\n- A compelling complexity\/accuracy tradeoff \u2014 adding beam search to an existing modeling pipeline incurs little additional complexity and can improve performance.","__index_level_0__":5507}
+{"text":"## Performance Benchmarks","__index_level_0__":5508}
+{"text":"Today's most commonly-used beam search decoding libraries today that support external language model integration include Kensho's [pyctcdecode](https:\/\/github.com\/kensho-technologies\/pyctcdecode), NVIDIA's [NeMo toolkit](https:\/\/github.com\/NVIDIA\/NeMo\/tree\/stable\/scripts\/asr_language_modeling). We benchmark the TorchAudio + Flashlight decoder against them with a *wav2vec 2.0* base model trained on 100 hours of audio evaluated on [LibriSpeech](https:\/\/www.openslr.org\/12) dev-other with the official [KenLM](https:\/\/github.com\/kpu\/kenlm\/) 3-gram LM. Benchmarks were run on Intel E5-2698 CPUs on a single thread. All computation was in-memory \u2014 KenLM memory mapping was disabled as it wasn't widely supported.","__index_level_0__":5509}
+{"text":"When benchmarking, we measure the *time-to-WER (word error rate)* \u2014 because of subtle differences in the implementation of decoding algorithms and the complex relationships between parameters and decoding speed, some hyperparameters differed across runs. To fairly assess performance, we first sweep for parameters that achieve a baseline WER, minimizing beam size if possible.","__index_level_0__":5510}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/fast-beam-search-decoding-in-pytorch-with-torchaudio-and-flashlight-text-4.jpeg\" width=\"70%\">\n<\/p>","__index_level_0__":5511}
+{"text":"<p align=\"center\">\nDecoding performance on Librispeech dev-other of a pretrained wav2vec 2.0 model. TorchAudio + Flashlight decoding outperforms by an order of magnitude at low WERs.\n<\/p>","__index_level_0__":5512}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/fast-beam-search-decoding-in-pytorch-with-torchaudio-and-flashlight-text-5.jpeg\" width=\"70%\">\n<\/p>","__index_level_0__":5513}
+{"text":"<p align=\"center\">\nTime-to-WER results, deferring to smaller beam size, across decoders. The TorchAudio + Flashlight decoder scales far better with larger beam sizes and at lower WERs.\n<\/p>","__index_level_0__":5514}
+{"text":"## TorchAudio API and Usage","__index_level_0__":5515}
+{"text":"TorchAudio provides a Python API for CTC beam search decoding, with support for the following:","__index_level_0__":5516}
+{"text":"- lexicon and lexicon-free decoding\n- KenLM n-gram language model integration\n- character and word-piece decoding\n- sample pretrained LibriSpeech KenLM models and corresponding lexicon and token files\n- various customizable beam search parameters (beam size, pruning threshold, LM weight...)","__index_level_0__":5517}
+{"text":"To set up the decoder, use the factory function torchaudio.models.decoder.ctc_decoder","__index_level_0__":5518}
+{"text":"```python\nfrom torchaudio.models.decoder import ctc_decoder, download_pretrained_files\nfiles = download_pretrained_files(\"librispeech-4-gram\")\ndecoder = ctc_decoder(\n   lexicon=files.lexicon,\n   tokens=files.tokens,\n   lm=files.lm,\n   nbest=1,\n   ... additional optional customizable args ...\n)\n```","__index_level_0__":5519}
+{"text":"Given emissions of shape *(batch, time, num_tokens)*, the decoder will compute and return a List of batch Lists, each consisting of the nbest hypotheses corresponding to the emissions. Each hypothesis can be further broken down into tokens, words (if a lexicon is provided), score, and timesteps components.","__index_level_0__":5520}
+{"text":"```python\nemissions = acoustic_model(waveforms)  # (B, T, N)\nbatch_hypotheses = decoder(emissions)  # List[List[CTCHypothesis]]","__index_level_0__":5521}
+{"text":"# transcript for a lexicon decoder\ntranscripts = [\" \".join(hypo[0].words) for hypo in batch_hypotheses]","__index_level_0__":5522}
+{"text":"# transcript for a lexicon free decoder, splitting by sil token\nbatch_tokens = [decoder.idxs_to_tokens(hypo[0].tokens) for hypo in batch_hypotheses]\ntranscripts = [\"\".join(tokens) for tokens in batch_tokens]\n```","__index_level_0__":5523}
+{"text":"Please refer to the [documentation](https:\/\/pytorch.org\/audio\/stable\/models.decoder.html#ctcdecoder) for more API details, and the tutorial ([ASR Inference Decoding](https:\/\/pytorch.org\/audio\/main\/tutorials\/asr_inference_with_ctc_decoder_tutorial.html)) or sample [inference script](https:\/\/github.com\/pytorch\/audio\/tree\/main\/examples\/asr\/librispeech_ctc_decoder) for more usage examples.","__index_level_0__":5524}
+{"text":"## Upcoming Improvements","__index_level_0__":5525}
+{"text":"**Full NNLM support** \u2014 decoding with large neural language models (e.g. transformers) remains somewhat unexplored at scale. Already supported in Flashlight, we plan to add support in TorchAudio, allowing users to use custom decoder-compatible LMs. Custom word level language models are already available in the nightly TorchAudio build, and is slated to be released in TorchAudio 0.13.","__index_level_0__":5526}
+{"text":"**Autoregressive\/seq2seq decoding** \u2014 Flashlight Text also supports [sequence-to-sequence (seq2seq) decoding](https:\/\/github.com\/flashlight\/text\/blob\/main\/flashlight\/lib\/text\/decoder\/LexiconSeq2SeqDecoder.h) for autoregressive models, which we hope to add bindings for and add to TorchAudio and TorchText with efficient GPU implementations as well.","__index_level_0__":5527}
+{"text":"**Better build support** \u2014 to benefit from improvements in Flashlight Text, TorchAudio will directly submodule Flashlight Text to make upstreaming modifications and improvements easier. This is already in effect in the nightly TorchAudio build, and is slated to be released in TorchAudio 0.13.","__index_level_0__":5528}
+{"text":"## Citation","__index_level_0__":5529}
+{"text":"To cite the decoder, please use the following:","__index_level_0__":5530}
+{"text":"```python\n@inproceedings{kahn2022flashlight,\n  title={Flashlight: Enabling innovation in tools for machine learning},\n  author={Kahn, Jacob D and Pratap, Vineel and Likhomanenko, Tatiana and Xu, Qiantong and Hannun, Awni and Cai, Jeff and Tomasello, Paden and Lee, Ann and Grave, Edouard and Avidov, Gilad and others},\n  booktitle={International Conference on Machine Learning},\n  pages={10557--10574},\n  year={2022},\n  organization={PMLR}\n}\n```\n```python\n@inproceedings{yang2022torchaudio,\n  title={Torchaudio: Building blocks for audio and speech processing},\n  author={Yang, Yao-Yuan and Hira, Moto and Ni, Zhaoheng and Astafurov, Artyom and Chen, Caroline and Puhrsch, Christian and Pollack, David and Genzel, Dmitriy and Greenberg, Donny and Yang, Edward Z and others},\n  booktitle={ICASSP 2022-2022 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},\n  pages={6982--6986},\n  year={2022},\n  organization={IEEE}\n}\n``` \n source: https:\/\/pytorch.org\/blog\/fast-beam-search-decoding-in-pytorch-with-torchaudio-and-flashlight-text\/ \n category: pytorch blogs","__index_level_0__":5531}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'New PyTorch Library Releases in PyTorch 1.9, including TorchVision, TorchAudio, and more'\nauthor: Team PyTorch \n---","__index_level_0__":5532}
+{"text":"Today, we are announcing updates to a number of PyTorch libraries, alongside the [PyTorch 1.9 release](https:\/\/pytorch.org\/blog\/pytorch-1.9-released\/). The updates include new releases for the domain libraries including TorchVision, TorchText and TorchAudio. These releases, along with the PyTorch 1.9 release, include a number of new features and improvements that will provide a broad set of updates for the PyTorch community.","__index_level_0__":5533}
+{"text":"Some highlights include:","__index_level_0__":5534}
+{"text":"* **TorchVision** - Added new SSD and SSDLite models, quantized kernels for object detection, GPU Jpeg decoding, and iOS support. See [release notes](https:\/\/github.com\/pytorch\/vision\/releases) here.\n* **TorchAudio** - Added wav2vec 2.0 model deployable in non-Python environments (including C++, Android, and iOS). Many performance improvements in lfilter, spectral operations, resampling. Added options for quality control in sampling (i.e. Kaiser window support). Initiated the migration of complex tensors operations. Improved autograd support. See [release notes](https:\/\/github.com\/pytorch\/audio\/releases) here.\n* **TorchText** - Added a new high-performance Vocab module that provides common functional APIs for NLP workflows. See [release notes](https:\/\/github.com\/pytorch\/text\/releases) here.","__index_level_0__":5535}
+{"text":"We\u2019d like to thank the community for their support and work on this latest release.","__index_level_0__":5536}
+{"text":"Features in PyTorch releases are classified as Stable, Beta, and Prototype. You can learn more about the definitions in [this blog post](https:\/\/pytorch.org\/blog\/pytorch-feature-classification-changes\/). ","__index_level_0__":5537}
+{"text":"# TorchVision 0.10","__index_level_0__":5538}
+{"text":"### (Stable) Quantized kernels for object detection \nThe forward pass of the nms and roi_align operators now support tensors with a quantized dtype, which can help lower the memory footprint of object detection models, particularly on mobile environments. For more details, refer to [the documentation](https:\/\/pytorch.org\/vision\/stable\/ops.html#torchvision.ops.roi_align). ","__index_level_0__":5539}
+{"text":"### (Stable) Speed optimizations for Tensor transforms \nThe resize and flip transforms have been optimized and its runtime improved by up to 5x on the CPU. ","__index_level_0__":5540}
+{"text":"### (Stable) Documentation improvements \nSignificant improvements were made to the documentation. In particular, a new gallery of examples is available. These examples visually illustrate how each transform acts on an image, and also properly documents and illustrates the output of the segmentation models.","__index_level_0__":5541}
+{"text":"The example gallery will be extended in the future to provide more comprehensive examples and serve as a reference for common torchvision tasks. For more details, refer to [the documentation](https:\/\/pytorch.org\/vision\/stable\/auto_examples\/index.html).","__index_level_0__":5542}
+{"text":"### (Beta) New models for detection \n[SSD](https:\/\/arxiv.org\/abs\/1512.02325) and [SSDlite](https:\/\/arxiv.org\/abs\/1801.04381) are two popular object detection architectures that are efficient in terms of speed and provide good results for low resolution pictures. In this release, we provide implementations for the original SSD model with VGG16 backbone and for its mobile-friendly variant SSDlite with MobileNetV3-Large backbone.","__index_level_0__":5543}
+{"text":"The models were pre-trained on COCO train2017 and can be used as follows:","__index_level_0__":5544}
+{"text":"```python\nimport torch\nimport torchvision","__index_level_0__":5545}
+{"text":"# Original SSD variant\nx = [torch.rand(3, 300, 300), torch.rand(3, 500, 400)]\nm_detector = torchvision.models.detection.ssd300_vgg16(pretrained=True)\nm_detector.eval()\npredictions = m_detector(x)","__index_level_0__":5546}
+{"text":"# Mobile-friendly SSDlite variant\nx = [torch.rand(3, 320, 320), torch.rand(3, 500, 400)]\nm_detector = torchvision.models.detection.ssdlite320_mobilenet_v3_large(pretrained=True)\nm_detector.eval()\npredictions = m_detector(x)\n```","__index_level_0__":5547}
+{"text":"The following accuracies can be obtained on COCO val2017 (full results available in [#3403](https:\/\/github.com\/pytorch\/vision\/pull\/3403) and [#3757](https:\/\/github.com\/pytorch\/vision\/pull\/3757)):","__index_level_0__":5548}
+{"text":"\n {:.table.table-striped.table-bordered}\n| Model | mAP | mAP@50 | mAP@75 |\n| ------------- | ------------- |  ------------- |  ------------- |\n| SSD300 VGG16 | 25.1 | 41.5 | 26.2 | \n| SSDlite320 MobileNetV3-Large | 21.3 | 34.3 | 22.1 |","__index_level_0__":5549}
+{"text":"\nFor more details, refer to [the documentation](https:\/\/pytorch.org\/vision\/stable\/models.html#id37).","__index_level_0__":5550}
+{"text":"### (Beta) JPEG decoding on the GPU \nDecoding jpegs is now possible on GPUs with the use of [nvjpeg](https:\/\/developer.nvidia.com\/nvjpeg), which should be readily available in your CUDA setup. The decoding time of a single image should be about 2 to 3 times faster than with libjpeg on CPU. While the resulting tensor will be stored on the GPU device, the input raw tensor still needs to reside on the host (CPU), because the first stages of the decoding process take place on the host:\nfrom torchvision.io.image import read_file, decode_jpeg","__index_level_0__":5551}
+{"text":"```python\ndata = read_file('path_to_image.jpg')  # raw data is on CPU\nimg = decode_jpeg(data, device='cuda')  # decoded image in on GPU\n```\nFor more details, see [the documentation](https:\/\/pytorch.org\/vision\/stable\/io.html#torchvision.io.decode_jpeg).","__index_level_0__":5552}
+{"text":"### (Beta) iOS support \nTorchVision 0.10 now provides pre-compiled iOS binaries for its C++ operators, which means you can run Faster R-CNN and Mask R-CNN on iOS. An example app on how to build a program leveraging those ops can be found [here](https:\/\/github.com\/pytorch\/vision\/tree\/master\/ios\/VisionTestApp). ","__index_level_0__":5553}
+{"text":"# TorchAudio 0.9.0","__index_level_0__":5554}
+{"text":"### (Stable) Complex Tensor Migration \nTorchAudio has functions that handle complex-valued tensors. These functions follow a convention to use an extra dimension to represent real and imaginary parts. In PyTorch 1.6, the native complex type was introduced. As its API is getting stable, torchaudio has started to migrate to the native complex type. ","__index_level_0__":5555}
+{"text":"In this release, we added support for native complex tensors, and you can opt-in to use them. Using the native complex types, we have verified that affected functions continue to support autograd and TorchScript, moreover, switching to native complex types improves their performance. For more details, refer to [pytorch\/audio#1337](https:\/\/github.com\/pytorch\/audio\/issues\/1337). ","__index_level_0__":5556}
+{"text":"### (Stable) Filtering Improvement \nIn release 0.8, we added the C++ implementation of the core part of ```lfilter``` for CPU, which improved the performance. In this release, we optimized some internal operations of the CPU implementation for further performance improvement. We also added autograd support to both CPU and GPU. Now ```lfilter``` and all the ```biquad``` filters (```biquad```, ```band_biquad```, ```bass_biquad```, ```treble_biquad```, ```allpass_biquad```, ```lowpass_biquad```, ```highpass_biquad```, ```bandpass_biquad```, ```equalizer_biquad``` and ```bandrefect_biquad```) benefit from the performance improvement and support autograd. We also moved the implementation of overdrive to C++ for performance improvement. For more details, refer to [the documentation](https:\/\/pytorch.org\/audio\/0.9.0\/functional.html#lfilter).\n \n### (Stable) Improved Autograd Support \nAlong with the work of Complex Tensor Migration and Filtering Improvement, we also added autograd tests to transforms. `lfilter`, `biquad` and its variants, and most transforms are now guaranteed to support autograd. For more details, refer to [the release note](https:\/\/github.com\/pytorch\/audio\/releases).","__index_level_0__":5557}
+{"text":"### (Stable) Improved Windows Support \nTorchaudio implements some operations in C++ for reasons such as performance and integration with third-party libraries. These C++ components were only available on Linux and macOS. In this release, we have added support to Windows. With this, the efficient filtering implementation mentioned above is also available on Windows.","__index_level_0__":5558}
+{"text":"However, please note that not all the C++ components are available for Windows. \u201csox_io\u201d backend and ```torchaudio.functional.compute_kaldi_pitch``` are not supported. ","__index_level_0__":5559}
+{"text":"### (Stable) I\/O Functions Migration \nSince the 0.6 release, we have continuously improved I\/O functionality. Specifically, in 0.8 we changed the default backend from \u201csox\u201d to \u201csox_io\u201d and applied the same switch to API of the \u201csoundfile\u201d backend. The 0.9 release concludes this migration by removing the deprecated backends. For more details, please refer to [#903](https:\/\/github.com\/pytorch\/audio\/issues\/903). ","__index_level_0__":5560}
+{"text":"### (Beta) Wav2Vec2.0 Model\nWe have added the model architectures from [Wav2Vec2.0](https:\/\/arxiv.org\/abs\/2006.11477). You can import fine-tuned models parameters published on [fairseq](https:\/\/github.com\/pytorch\/fairseq\/tree\/master\/examples\/wav2vec) and [Hugging Face Hub](https:\/\/huggingface.co\/models?filter=wav2vec2). Our model definition supports TorchScript, and it is possible to deploy the model to non-Python environments, such as C++, [Android](https:\/\/github.com\/pytorch\/android-demo-app\/tree\/master\/SpeechRecognition) and [iOS](https:\/\/github.com\/pytorch\/ios-demo-app\/tree\/master\/SpeechRecognition). ","__index_level_0__":5561}
+{"text":"The following code snippet illustrates such a use case. Please check out our [c++ example directory](https:\/\/github.com\/pytorch\/audio\/tree\/master\/examples\/libtorchaudio) for the complete example. Currently, it is designed for running inference. If you would like more support for training, please file a feature request.","__index_level_0__":5562}
+{"text":"```python\n# Import fine-tuned model from Hugging Face Hub\nimport transformers\nfrom torchaudio.models.wav2vec2.utils import import_huggingface_model","__index_level_0__":5563}
+{"text":"original = Wav2Vec2ForCTC.from_pretrained(\"facebook\/wav2vec2-base-960h\")\nimported = import_huggingface_model(original)\n```","__index_level_0__":5564}
+{"text":"```python\n# Import fine-tuned model from fairseq\nimport fairseq\nfrom torchaudio.models.wav2vec2.utils import import_fairseq_model","__index_level_0__":5565}
+{"text":"original, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(\n    [\"wav2vec_small_960h.pt\"], arg_overrides={'data': \"<data_dir>\"})\nimported = import_fairseq_model(original[0].w2v_encoder)\n```","__index_level_0__":5566}
+{"text":"```python\n# Build uninitialized model and load state dict\nfrom torchaudio.models import wav2vec2_base","__index_level_0__":5567}
+{"text":"model = wav2vec2_base(num_out=32)\nmodel.load_state_dict(imported.state_dict())","__index_level_0__":5568}
+{"text":"# Quantize \/ script \/ optimize for mobile\nquantized_model = torch.quantization.quantize_dynamic(\n    model, qconfig_spec={torch.nn.Linear}, dtype=torch.qint8)\nscripted_model = torch.jit.script(quantized_model)\noptimized_model = optimize_for_mobile(scripted_model)\noptimized_model.save(\"model_for_deployment.pt\")\n```","__index_level_0__":5569}
+{"text":"For more details, see [the documentation](https:\/\/pytorch.org\/audio\/0.9.0\/models.html#wav2vec2-0). ","__index_level_0__":5570}
+{"text":"### (Beta) Resampling Improvement \nIn release 0.8, we vectorized the operation in ```torchaudio.compliance.kaldi.resample_waveform```, which improved the performance of ```resample_waveform``` and ```torchaudio.transforms.Resample```. In this release, we have further revised the way the resampling algorithm is implemented. ","__index_level_0__":5571}
+{"text":"We have:\n*  Added Kaiser Window support for a wider range of resampling quality.\n*  Added ```rolloff``` parameter for anti-aliasing control.\n*  Added the mechanism to precompute the kernel and cache it in ```torchaudio.transforms.Resample``` for even faster operation.\n*  Moved the implementation from ```torchaudio.compliance.kaldi.resample_waveform``` to ```torchaudio.functional.resample``` and deprecated ```torchaudio.compliance.kaldi.resample_waveform```.","__index_level_0__":5572}
+{"text":"For more details, see [the documentation](https:\/\/pytorch.org\/audio\/0.9.0\/transforms.html#resample). ","__index_level_0__":5573}
+{"text":"### (Prototype) RNN Transducer Loss \nThe RNN transducer loss is used in training RNN transducer models, which is a popular architecture for speech recognition tasks. The prototype loss in torchaudio currently supports autograd, torchscript, float16 and float32, and can also be run on both CPU and CUDA. For more details, please refer to [the documentation](https:\/\/pytorch.org\/audio\/master\/rnnt_loss.html).","__index_level_0__":5574}
+{"text":"# TorchText 0.10.0","__index_level_0__":5575}
+{"text":"### (Beta) New Vocab Module \nIn this release, we introduce a new Vocab module that replaces the current Vocab class. The new Vocab provides common functional APIs for NLP workflows. This module is backed by an efficient C++ implementation that reduces batch look-up time by up-to ~85% (refer to summary of [#1248](https:\/\/github.com\/pytorch\/text\/pull\/1248) and [#1290](https:\/\/github.com\/pytorch\/text\/pull\/1290) for further information on benchmarks), and provides support for TorchScript. We provide accompanying factory functions that can be used to build the Vocab object either through a python ordered dictionary or an Iterator that yields lists of tokens.","__index_level_0__":5576}
+{"text":"```python\n#creating Vocab from text file\nimport io\nfrom torchtext.vocab import build_vocab_from_iterator\n#generator that yield list of tokens\ndef yield_tokens(file_path):\n   with io.open(file_path, encoding = 'utf-8') as f:\n      for line in f:\n          yield line.strip().split()\n#get Vocab object\nvocab_obj = build_vocab_from_iterator(yield_tokens(file_path), specials=[\"<unk>\"])","__index_level_0__":5577}
+{"text":"#creating Vocab through ordered dict\nfrom torchtext.vocab import vocab\nfrom collections import Counter, OrderedDict\ncounter = Counter([\"a\", \"a\", \"b\", \"b\", \"b\"])\nsorted_by_freq_tuples = sorted(counter.items(), key=lambda x: x[1], reverse=True)\nordered_dict = OrderedDict(sorted_by_freq_tuples)\nvocab_obj = vocab(ordered_dict)","__index_level_0__":5578}
+{"text":"#common API usage","__index_level_0__":5579}
+{"text":"#look-up index\nvocab_obj[\"a\"]","__index_level_0__":5580}
+{"text":"#batch look-up indices\nvocab_obj.looup_indices([\"a\",\"b\"])\n#support forward API of PyTorch nn Modules\nvocab_obj([\"a\",\"b\"])","__index_level_0__":5581}
+{"text":"#batch look-up tokens\nvocab_obj.lookup_tokens([0,1])","__index_level_0__":5582}
+{"text":"#set default index to return when token not found\nvocab_obj.set_default_index(0)\nvocab_obj[\"out_of_vocabulary\"] #prints 0\n```","__index_level_0__":5583}
+{"text":"For more details, refer to [the documentation](https:\/\/pytorch.org\/text\/stable\/vocab.html). ","__index_level_0__":5584}
+{"text":"Thanks for reading. If you\u2019re interested in these updates and want to join the PyTorch community, we encourage you to join [the discussion](https:\/\/discuss.pytorch.org\/) forums and [open GitHub issues](https:\/\/github.com\/pytorch\/pytorch\/issues). To get the latest news from PyTorch, follow us on [Facebook](https:\/\/www.facebook.com\/pytorch\/), [Twitter](https:\/\/twitter.com\/PyTorch), [Medium](https:\/\/medium.com\/pytorch), [YouTube](https:\/\/www.youtube.com\/pytorch) or [LinkedIn](https:\/\/www.linkedin.com\/company\/pytorch).  ","__index_level_0__":5585}
+{"text":"-Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.9-new-library-releases\/ \n category: pytorch blogs","__index_level_0__":5587}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Everything You Need To Know About Torchvision\u2019s SSDlite Implementation'\nauthor: Vasilis Vryniotis\nfeatured-img: 'assets\/images\/mAP-of-SSD320-MobileNetV3-Large.png'\n---","__index_level_0__":5588}
+{"text":"In the [previous article](https:\/\/pytorch.org\/blog\/torchvision-ssd-implementation\/), we\u2019ve discussed how the SSD algorithm works, covered its implementation details and presented its training process. If you have not read the previous blog post, I encourage you to check it out before continuing.","__index_level_0__":5589}
+{"text":"In this part 2 of the series, we will focus on the mobile-friendly variant of SSD called SSDlite. Our plan is to first go through the main components of the algorithm highlighting the parts that differ from the original SSD, then discuss how the released model was trained and finally provide detailed benchmarks for all the new Object Detection models that we explored.","__index_level_0__":5590}
+{"text":"# The SSDlite Network Architecture","__index_level_0__":5591}
+{"text":"The SSDlite is an adaptation of SSD which was first briefly introduced on the [MobileNetV2 paper](https:\/\/arxiv.org\/abs\/1801.04381) and later reused on the [MobileNetV3 paper](https:\/\/arxiv.org\/abs\/1905.02244). Because the main focus of the two papers was to introduce novel CNN architectures, most of the implementation details of SSDlite were not clarified. Our code follows all the details presented on the two papers and where necessary fills the gaps from the [official implementation](https:\/\/github.com\/tensorflow\/models\/tree\/238922e98dd0e8254b5c0921b241a1f5a151782f\/research\/object_detection). ","__index_level_0__":5592}
+{"text":"As noted before, the SSD is a family of models because one can configure it with different backbones (such as VGG, MobileNetV3 etc) and different Heads (such as using regular convolutions, separable convolutions etc). Thus many of the SSD components remain the same in SSDlite. Below we discuss only those that are different","__index_level_0__":5593}
+{"text":"## Classification and Regression Heads","__index_level_0__":5594}
+{"text":"Following the Section 6.2 of the MobileNetV2 paper, SSDlite replaces the regular convolutions used on the original Heads with separable convolutions. Consequently, our implementation introduces [new heads](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L65-L95) that use [3x3 Depthwise convolutions and 1x1 projections](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L26-L36). Since all other components of the SSD method remain the same, to create an SSDlite model our implementation [initializes the SSDlite head](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L222-L223) and passes it directly to the SSD constructor.","__index_level_0__":5595}
+{"text":"## Backbone Feature Extractor","__index_level_0__":5596}
+{"text":"Our implementation introduces a new class for building MobileNet [feature extractors](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L98). Following the Section 6.3 of the MobileNetV3 paper, the backbone returns the [output of the expansion layer](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L106) of the Inverted Bottleneck block which has an output stride of 16 and the [output of the layer just before the pooling](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L107) which has an output stride of 32. Moreover, all [extra blocks](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L111-L116) of the backbone are replaced with [lightweight equivalents](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L39-L54) which use a 1x1 compression, a separable 3x3 convolution with stride 2 and a 1x1 expansion. Finally to ensure that the heads have enough prediction power even when small [width multipliers](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L99) are used, the [minimum depth](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L110) size of all convolutions is controlled by the ```min_depth``` hyperparameter.","__index_level_0__":5597}
+{"text":"# The SSDlite320 MobileNetV3-Large model","__index_level_0__":5598}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/ssdlite-pre-trained.png\" width=\"100%\">\n<\/div>","__index_level_0__":5599}
+{"text":"This section discusses the configuration of the provided [SSDlite pre-trained](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L159-L162) model along with the training processes followed to replicate the paper results as closely as possible. ","__index_level_0__":5600}
+{"text":"## Training process","__index_level_0__":5601}
+{"text":"All of the hyperparameters and scripts used to train the model on the COCO dataset can be found in our [references](https:\/\/github.com\/pytorch\/vision\/blob\/e35793a1a4000db1f9f99673437c514e24e65451\/references\/detection\/README.md#ssdlite320-mobilenetv3-large) folder. Here we discuss the most notable details of the training process.","__index_level_0__":5602}
+{"text":"### Tuned Hyperparameters","__index_level_0__":5603}
+{"text":"Though the papers don\u2019t provide any information on the hyperparameters used for training the models (such as regularization, learning rate and the batch size), the parameters listed in the [configuration files](https:\/\/github.com\/tensorflow\/models\/blob\/238922e98dd0e8254b5c0921b241a1f5a151782f\/research\/object_detection\/samples\/configs\/ssdlite_mobilenet_v3_large_320x320_coco.config) on the official repo were good starting points and using cross validation we adjusted them to their optimal values. All the above gave us a significant boost over the baseline SSD configuration.","__index_level_0__":5604}
+{"text":"### Data Augmentation","__index_level_0__":5605}
+{"text":"Key important difference of SSDlite comparing to SSD is that the backbone of the first has only a fraction of the weights of the latter. This is why in SSDlite, the Data Augmentation focuses more on making the model robust to objects of variable sizes than trying to avoid overfitting. Consequently, SSDlite [uses only a subset](https:\/\/github.com\/pytorch\/vision\/blob\/43d772067fe77965ec8fc49c799de5cea44b8aa2\/references\/detection\/presets.py#L19-L24) of the SSD transformations and this way it avoids the over-regularization of the model.","__index_level_0__":5606}
+{"text":"### LR Scheme","__index_level_0__":5607}
+{"text":"Due to the reliance on Data Augmentation to make the model robust to small and medium sized objects, we found that it is particularly beneficial for the training recipe to use large number of epochs. More specifically by using roughly 3x more epochs than SSD we are able to increase our precision by 4.2mAP points and by using a 6x multiplier we improve by 4.9mAP. Increasing further the epochs seems to yield diminishing returns and makes the training too slow and impractical, nevertheless based on the [model configuration](https:\/\/github.com\/tensorflow\/models\/blob\/238922e98dd0e8254b5c0921b241a1f5a151782f\/research\/object_detection\/samples\/configs\/ssdlite_mobilenet_v3_large_320x320_coco.config#L154) it seems that the authors of the paper used an equivalent *16x multiplier*. ","__index_level_0__":5608}
+{"text":"### Weight Initialization & Input Scaling & ReLU6","__index_level_0__":5609}
+{"text":"A set of final optimizations that brought our implementation very close to the official one and helped us bridge the accuracy gap was training the backbone [from scratch](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L139-L141) instead of initializing from ImageNet, adapting our [weight initialization scheme](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L57-L62), changing our [Input Scaling](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L216-L219) and replacing all standard ReLUs added on the SSDlite heads with ReLU6. Note that since we trained the model from random weights, we additionally applied the speed optimization described on the paper of using a [reduced tail](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L196-L197) on the backbone.","__index_level_0__":5610}
+{"text":"### Implementation Differences","__index_level_0__":5611}
+{"text":"Comparing the above implementation with the one on the official repo, we\u2019ve identified a few differences. Most of them are minor and they are related to how we initialize the weights (for example [Normal initialization](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/torchvision\/models\/detection\/ssdlite.py#L57-L62) vs [Truncated Normal](https:\/\/github.com\/tensorflow\/models\/blob\/238922e98dd0e8254b5c0921b241a1f5a151782f\/research\/object_detection\/samples\/configs\/ssdlite_mobilenet_v3_large_320x320_coco.config#L104-L107)), how we parameterize the LR Scheduling (for example [smaller](https:\/\/github.com\/pytorch\/vision\/blob\/b6f733046c9259f354d060cd808241a558d7d596\/references\/detection\/engine.py#L21-L22) vs [larger](https:\/\/github.com\/tensorflow\/models\/blob\/238922e98dd0e8254b5c0921b241a1f5a151782f\/research\/object_detection\/samples\/configs\/ssdlite_mobilenet_v3_large_320x320_coco.config#L169-L170) warmup rate, [shorter](https:\/\/github.com\/pytorch\/vision\/tree\/master\/references\/detection#ssdlite320-mobilenetv3-large) vs [longer](https:\/\/github.com\/tensorflow\/models\/blob\/238922e98dd0e8254b5c0921b241a1f5a151782f\/research\/object_detection\/samples\/configs\/ssdlite_mobilenet_v3_large_320x320_coco.config#L154) training) etc. The biggest known difference lies in the way we compute the Classification loss. More specifically the implementation of SSDlite with MobileNetV3 backbone on the official repo [doesn\u2019t use the SSD\u2019s Multibox loss](https:\/\/github.com\/tensorflow\/models\/blob\/238922e98dd0e8254b5c0921b241a1f5a151782f\/research\/object_detection\/samples\/configs\/ssdlite_mobilenet_v3_large_320x320_coco.config#L121-L124) but instead uses RetinaNet\u2019s [focal loss](https:\/\/arxiv.org\/abs\/1708.02002). This is a rather significant deviation from the paper and since TorchVision already offers a full implementation of RetinaNet, we decided to implement SSDlite using the normal Multi-box SSD loss.","__index_level_0__":5612}
+{"text":"## Break down of key accuracy improvements","__index_level_0__":5613}
+{"text":"As discussed in previous articles, reproducing research papers and porting them to code is not a journey of monotonically increasing accuracies, especially in cases where the full training and implementation details are not known. Typically the process involves lots of backtracking as one needs to identify those implementation details and parameters that have significant impact on the accuracy from those that don\u2019t. Below we try to visualize the most important iterations that improved our accuracy from the baseline:","__index_level_0__":5614}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/mAP-of-SSD320-MobileNetV3-Large.png\" width=\"100%\">\n<\/div>","__index_level_0__":5615}
+{"text":"\n  {:.table.table-striped.table-bordered}\n| **Iteration** | **mAP** | \n| ------------- | ------------- |\n| Baseline with \"SSD-style\" Hyperparams | 10.6 | \n| + Tuned Hyperparams | 14.2 | \n| + SSDlite Data Augmentation | 15.2 |\n| + 3x LR Scheme | 19.4 |\n| + 6x LR Scheme | 20.1 | \n| + Weight Initialization & Input Scaling & ReLU6 | 21.3 | ","__index_level_0__":5616}
+{"text":"The order of optimizations presented above is accurate, though a bit idealized in some cases. For example, though different schedulers were tested during the Hyperparameter tuning phase, none of them provided significant improvements and thus we maintained the MultiStepLR which was used in the baseline. Nevertheless while later experimenting with different LR Schemes, we found it beneficial to switch to CosineAnnealingLR, as it required less configuration. Consequently, we believe that the main takeaway from the above summary should be that even by starting with a correct implementation and a set of optimal hyperparams from a model of the same family, there is always accuracy points to be found by optimizing the training recipe and tuning the implementation. Admittedly the above is a rather extreme case where the accuracy doubled, but still in many cases there is a large number of optimizations that can help us push the accuracy significantly. ","__index_level_0__":5617}
+{"text":"# Benchmarks","__index_level_0__":5618}
+{"text":"Here is how to initialize the two pre-trained models:","__index_level_0__":5619}
+{"text":"```python\nssdlite = torchvision.models.detection.ssdlite320_mobilenet_v3_large(pretrained=True)\nssd = torchvision.models.detection.ssd300_vgg16(pretrained=True)\n```","__index_level_0__":5620}
+{"text":"Below are the benchmarks between the new and selected previous detection models:","__index_level_0__":5621}
+{"text":"  {:.table.table-striped.table-bordered}\n| **Model** | **mAP** | **Inference on CPU (sec)** | **# Params (M)** |\n| ------------- | ------------- | ------------- | ------------- |\n| SSDlite320 MobileNetV3-Large | 21.3 | 0.0911 | 3.44 |\n| SSD300 VGG16 | 25.1 | 0.8303 | 35.64 |\n| SSD512 VGG16 (not released) | 28.8| 2.2494 | 37.08 |\n| SSD512 ResNet50 (not released) | 30.2 | 1.1137 | 42.70 |\n| Faster R-CNN MobileNetV3-Large 320 FPN (Low-Res) | 22.8 | 0.1679 | 19.39|\n| Faster R-CNN MobileNetV3-Large FPN (High-Res) | 32.8 | 0.8409 | 19.39 |","__index_level_0__":5622}
+{"text":"As we can see, the SSDlite320 MobileNetV3-Large model is by far the fastest and smallest model and thus it\u2019s an excellent candidate for real-world mobile applications. Though its accuracy is lower than the pre-trained low-resolution Faster R-CNN equivalent, the SSDlite framework is adaptable and one can boost its accuracy by introducing heavier heads with more convolutions. ","__index_level_0__":5623}
+{"text":"On the other hand, the SSD300 VGG16 model is rather slow and less accurate. This is mainly because of its VGG16 backbone. Though extremely important and influential, the VGG architecture is nowadays quite outdated. Thus though the specific model has historical and research value and hence it\u2019s included in TorchVision, we recommend to users who want high-resolution detectors for real world applications to either combine SSD with alternative backbones (see this [example](https:\/\/github.com\/pytorch\/vision\/pull\/3760) on how to create one) or use one of the Faster R-CNN pre-trained models.","__index_level_0__":5624}
+{"text":"\nWe hope you enjoyed the 2nd and final part of the SSD series. We are looking forward to your feedback.\n \n source: https:\/\/pytorch.org\/blog\/torchvision-ssdlite-implementation\/ \n category: pytorch blogs","__index_level_0__":5625}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Announcing PyTorch Annual Hackathon 2021'\nauthor: Team PyTorch\nfeatured-img: 'assets\/images\/social_hackathon21.png'\n---","__index_level_0__":5626}
+{"text":"We\u2019re excited to announce the PyTorch Annual Hackathon 2021! This year, we\u2019re looking to support the community in creating innovative PyTorch tools, libraries, and applications. 2021 is the third year we\u2019re hosting this Hackathon, and we welcome you to join the PyTorch community and put your machine learning skills into action. Submissions start on September 8 and end on November 3. Good luck to everyone!","__index_level_0__":5627}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.baseurl }}\/assets\/images\/pytorch_hackathon_2021.gif\" width=\"100%\">\n<\/div>","__index_level_0__":5628}
+{"text":"## Submission Categories\nYou can enter your PyTorch projects into three categories:","__index_level_0__":5629}
+{"text":"* **PyTorch Responsible AI Development Tools & Libraries** - Build an AI development tool or library that helps develop AI models and applications responsibly. These tools, libraries, and apps need to support a researcher or developer to factor in fairness, security, and privacy throughout the entire machine learning development process of data gathering, model training, model validation, inferences, monitoring, and more. ","__index_level_0__":5630}
+{"text":"* **Web and Mobile Applications Powered by PyTorch** - Build an application with the web, mobile interface, and\/or embedded device powered by PyTorch so the end users can interact with it. The submission must be built on PyTorch or use PyTorch-based libraries such as torchvision, torchtext, and fast.ai.","__index_level_0__":5631}
+{"text":"* **PyTorch Developer Tools & Libraries** - Build a creative, useful, and well-implemented tool or library for improving the productivity and efficiency of PyTorch researchers and developers. The submission must be a machine learning algorithm, model, or application built using PyTorch or PyTorch-based libraries.","__index_level_0__":5632}
+{"text":"## Prizes\nSubmissions will be judged on the idea\u2019s quality, originality, implementation, and potential impact.","__index_level_0__":5633}
+{"text":"* **First-Place Winners** in each category of the Hackathon will receive $5,000 in cash, along with a 30-minute call with the PyTorch development team. ","__index_level_0__":5634}
+{"text":"* **Second-Place Winners** will receive $3,000.","__index_level_0__":5635}
+{"text":"\n* **Third-Place Winners** will receive $2,000.","__index_level_0__":5636}
+{"text":"All winners will also receive the opportunity to create blog posts that will be featured throughout PyTorch channels as well as an exclusive Github badge. Honorable Mentions will also be awarded to the following three highest-scoring entries in each category and will receive $1,000 each.","__index_level_0__":5637}
+{"text":"## Cloud Computing Credits\nRequest $100 in credits from Amazon Web Services or Google Cloud for your computing costs. Please allow 3 business days for your request to be reviewed. Credits will be provided to verified registrants until the supplies run out. For more information, see https:\/\/pytorch2021.devpost.com\/details\/sponsors. ","__index_level_0__":5638}
+{"text":"## 2020 Winning Projects","__index_level_0__":5639}
+{"text":"[DeMask](https:\/\/devpost.com\/software\/asteroid-the-pytorch-based-source-separation-toolkit) won first place in the PyTorch Developer Tools category. Built using Asteroid, a PyTorch-based audio source separation toolkit, DeMask is an end-to-end model for enhancing speech while wearing face masks.","__index_level_0__":5640}
+{"text":"[Q&Aid](https:\/\/devpost.com\/software\/pytorchxai) won first place in the Web\/Mobile Applications Powered by PyTorch category. Backed by PyTorch core algorithms and models, Q&Aid is a conceptual health care chatbot aimed at making health care diagnoses and facilitating communication between patients and doctors.","__index_level_0__":5641}
+{"text":"[FairTorch](https:\/\/devpost.com\/software\/a-qeysp1) won first place in the PyTorch Responsible AI Development Tools category. FairTorch is a PyTorch fairness library that lets developers add constraints to their models to equalize metrics across subgroups by simply adding a few lines of code.","__index_level_0__":5642}
+{"text":"## How to Join\nIf you\u2019re interested in joining this year\u2019s PyTorch Hackathon, register at [http:\/\/pytorch2021.devpost.com](http:\/\/pytorch2021.devpost.com).\n \n source: https:\/\/pytorch.org\/blog\/pytorch-hackathon-2021\/ \n category: pytorch blogs","__index_level_0__":5643}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Accelerated Generative Diffusion Models with PyTorch 2\"\nauthor: Grigory Sizov, Michael Gschwind, Hamid Shojanazeri, Driss Guessous, Daniel Haziza, Christian Puhrsch\n---","__index_level_0__":5644}
+{"text":"**TL;DR**: PyTorch 2.0 nightly offers out-of-the-box performance improvement for Generative Diffusion models by using the new `torch.compile()` compiler and optimized implementations of Multihead Attention integrated with PyTorch 2.","__index_level_0__":5645}
+{"text":"## Introduction","__index_level_0__":5646}
+{"text":"A large part of the recent progress in Generative AI came from denoising diffusion models, which allow producing high quality images and videos from text prompts. This family includes Imagen, DALLE, Latent Diffusion, and others. However, all models in this family share a common drawback: generation is rather slow, due to the iterative nature of the sampling process by which the images are produced. This makes it important to optimize the code running inside the sampling loop. ","__index_level_0__":5647}
+{"text":"We took an open source implementation of a popular text-to-image diffusion model as a starting point and accelerated its generation using two optimizations available in PyTorch 2: compilation and fast attention implementation. Together with a few minor memory processing improvements in the code these optimizations give up to 49% inference speedup relative to the original implementation without [xFormers](https:\/\/github.com\/facebookresearch\/xformers), and 39% inference speedup relative to using the original code with xFormers (excluding the compilation time), depending on the GPU architecture and batch size. Importantly, the speedup comes without a need to install xFormers or any other extra dependencies. ","__index_level_0__":5648}
+{"text":"The table below shows the improvement in runtime between the original implementation with xFormers installed and our optimized version with PyTorch-integrated memory efficient attention (originally developed for and released in the [xFormers](https:\/\/github.com\/facebookresearch\/xformers) library)  and PyTorch compilation. The compilation time is excluded.","__index_level_0__":5649}
+{"text":"**Runtime improvement in % compared to original+xFormers**","__index_level_0__":5650}
+{"text":"See the absolute runtime numbers in section \u201cBenchmarking setup and results summary\u201d","__index_level_0__":5651}
+{"text":"\n<table class=\"table table-bordered\">\n<thead>\n  <tr>\n   <td scope=\"col\"><strong>GPU<\/strong>\n   <\/td>\n   <td scope=\"col\"><strong>Batch size 1<\/strong>\n   <\/td>\n   <td scope=\"col\"><strong>Batch size 2<\/strong>\n   <\/td>\n   <td scope=\"col\"><strong>Batch size 4<\/strong>\n   <\/td>\n  <\/tr>\n<\/thead>\n  <tr>\n   <td><strong>P100 (no compilation)<\/strong>\n   <\/td>\n   <td>-3.8\n   <\/td>\n   <td>0.44\n   <\/td>\n   <td>5.47\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>T4<\/strong>\n   <\/td>\n   <td>2.12\n   <\/td>\n   <td>10.51\n   <\/td>\n   <td>14.2\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>A10<\/strong>\n   <\/td>\n   <td>-2.34\n   <\/td>\n   <td>8.99\n   <\/td>\n   <td>10.57\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>V100<\/strong>\n   <\/td>\n   <td>18.63\n   <\/td>\n   <td>6.39\n   <\/td>\n   <td>10.43\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>A100<\/strong>\n   <\/td>\n   <td>38.5\n   <\/td>\n   <td>20.33\n   <\/td>\n   <td>12.17\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":5652}
+{"text":"\nOne can notice the following:","__index_level_0__":5653}
+{"text":"* The improvements are significant for powerful GPUs like A100 and V100. For those GPUs the improvement is most pronounced for batch size 1\n* For less powerful GPUs we observe smaller speedups (or in two cases slight regressions). The batch size trend is reversed here: improvement is larger for larger batches","__index_level_0__":5655}
+{"text":"In the following sections we describe the applied optimizations and provide detailed benchmarking data, comparing the generation time with various optimization features on\/off.","__index_level_0__":5656}
+{"text":"Specifically, we benchmark 5 configurations and the plots below compare their absolute performance for different GPUs and batch sizes. For definitions of these configurations see section \u201cBenchmarking setup and results\u201d.","__index_level_0__":5657}
+{"text":"![Benchmark of denoising diffusion text-to-image generation across GPU architectures, batch size 1](\/assets\/images\/2023-04-11-accelerated-generative-diffusion-models1.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":5659}
+{"text":"![Benchmark of denoising diffusion text-to-image generation across GPU architectures, batch size 2](\/assets\/images\/2023-04-11-accelerated-generative-diffusion-models2.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":5660}
+{"text":"![Benchmark of denoising diffusion text-to-image generation across GPU architectures, batch size 1](\/assets\/images\/2023-04-11-accelerated-generative-diffusion-models3.png){:style=\"max-height:800px; width:100%\"}  ","__index_level_0__":5661}
+{"text":"\n## Optimizations ","__index_level_0__":5663}
+{"text":"Here we\u2019ll go into more detail about the optimizations introduced into the model code. These optimizations rely on features of PyTorch 2.0 which has been released recently. ","__index_level_0__":5664}
+{"text":"\n### Optimized Attention","__index_level_0__":5665}
+{"text":"One part of the code which we optimized is the scaled dot-product attention. Attention is known to be a heavy operation: naive implementation materializes the attention matrix, leading to time and memory complexity quadratic in sequence length. It is common for diffusion models to use attention (`CrossAttention`) as part of Transformer blocks in multiple parts of the U-Net. Since the U-Net runs at every sampling step, this becomes a critical point to optimize. Instead of custom attention implementation one can use `torch.nn.MultiheadAttention,` which in PyTorch 2 has optimized attention implementation is integrated into it. This optimization schematically boils down to the following pseudocode:","__index_level_0__":5666}
+{"text":"```\nclass CrossAttention(nn.Module):\n    def __init__(self, ...):\n        # Create matrices: Q, K, V, out_proj\n        ...\n    def forward(self, x, context=None, mask=None):\n       # Compute out = SoftMax(Q*K\/sqrt(d))V\n       # Return out_proj(out)\n       \u2026\n```","__index_level_0__":5668}
+{"text":"gets replaced with","__index_level_0__":5669}
+{"text":"```\nclass CrossAttention(nn.Module):\n    def __init__(self, ...):\n        self.mha = nn.MultiheadAttention(...)\n    def forward(self, x, context):\n\treturn self.mha(x, context, context)\n```","__index_level_0__":5670}
+{"text":"\nThe optimized implementation of attention was available already in PyTorch 1.13 (see [here](https:\/\/pytorch.org\/blog\/a-better-transformer-for-fast-transformer-encoder-inference\/)) and widely adopted (see e.g. [HuggingFace transformers library example](https:\/\/medium.com\/pytorch\/bettertransformer-out-of-the-box-performance-for-huggingface-transformers-3fbe27d50ab2)). In particular, it integrates memory-efficient attention from the [xFormers](https:\/\/github.com\/facebookresearch\/xformers) library and flash attention from [https:\/\/arxiv.org\/abs\/2205.14135](https:\/\/arxiv.org\/abs\/2205.14135). PyTorch 2.0 expands this to additional attention functions such as cross attention and custom kernels for further acceleration, making it applicable to diffusion models.","__index_level_0__":5671}
+{"text":"Flash attention is available on GPUs with compute capability SM 7.5 or SM 8.x - for example, on T4, A10, and A100, which are included in our benchmark (you can check compute capability of each NVIDIA GPU [here](https:\/\/developer.nvidia.com\/cuda-gpus#compute)). However, in our tests on A100 the memory efficient attention performed better than flash attention for the particular case of diffusion models, due to the small number of attention heads and small batch size.  PyTorch understands this and in this case chooses memory efficient attention over flash attention when both are available (see the logic [here](https:\/\/github.com\/pytorch\/pytorch\/blob\/d8e795ecd53670682bd3b2e5ff1f378402b147d5\/aten\/src\/ATen\/native\/transformers\/cuda\/sdp_utils.h#L33-L71)). For full control over the attention backends (memory-efficient attention, flash attention, \u201cvanilla math\u201d, or any future ones), power users can enable and disable them manually with the help of the context manager [torch.backends.cuda.sdp_kernel](https:\/\/pytorch.org\/docs\/master\/backends.html#torch.backends.cuda.sdp_kernel). ","__index_level_0__":5672}
+{"text":"\n### Compilation","__index_level_0__":5673}
+{"text":"Compilation is a [new feature of PyTorch 2.0](https:\/\/pytorch.org\/get-started\/pytorch-2.0\/#user-experience), enabling significant speedups with a very simple user experience. To invoke the default behavior, simply wrap a PyTorch module or a function into `torch.compile`:","__index_level_0__":5674}
+{"text":"\n```\nmodel = torch.compile(model)\n```","__index_level_0__":5675}
+{"text":"\nPyTorch compiler then turns Python code into a set of instructions which can be executed efficiently without Python overhead. The compilation happens dynamically the first time the code is executed. With the default behavior, under the hood PyTorch utilized [TorchDynamo](https:\/\/pytorch.org\/docs\/master\/dynamo\/index.html) to compile the code and [TorchInductor](https:\/\/dev-discuss.pytorch.org\/t\/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes\/747) to further optimize it. See [this tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/dynamo_tutorial.html) for more details.","__index_level_0__":5676}
+{"text":"Although the one-liner above is enough for compilation, certain modifications in the code can squeeze a larger speedup. In particular, one should avoid so-called graph breaks - places in the code which PyTorch can\u2019t compile. As opposed to previous PyTorch compilation approaches (like TorchScript), PyTorch 2 compiler doesn\u2019t break in this case. Instead it falls back on eager execution - so the code runs, but with reduced performance. We introduced a few minor changes to the model code to get rid of graph breaks. This included eliminating functions from libraries not supported by the compiler, such as `inspect.isfunction` and `einops.rearrange`. See this [doc](https:\/\/pytorch.org\/docs\/master\/dynamo\/faq.html#identifying-the-cause-of-a-graph-break) to learn more about graph breaks and how to eliminate them.","__index_level_0__":5677}
+{"text":"Theoretically, one can apply `torch.compile `on the whole diffusion sampling loop. However, in practice it is enough to just compile the U-Net. The reason is that `torch.compile` doesn\u2019t yet have a loop analyzer and would recompile the code for each iteration of the sampling loop. Moreover, compiled sampler code is likely to generate graph breaks - so one would need to adjust it if one wants to get a good performance from the compiled version.","__index_level_0__":5678}
+{"text":"Note that compilation [requires GPU compute capability >= SM 7.0](https:\/\/github.com\/openai\/triton\/blob\/b5d32896b1f89fc44a82f8df3bb010934c53f4f5\/README.md?plain=1#L66-L68) to run in non-eager mode. This covers all GPUs in our benchmarks -  T4, V100, A10, A100 - except for P100 (see the [full list](https:\/\/developer.nvidia.com\/cuda-gpus#compute)). ","__index_level_0__":5679}
+{"text":"\n### Other optimizations","__index_level_0__":5680}
+{"text":"In addition, we have improved efficiency of GPU memory operations by eliminating some common pitfalls, e.g. creating a tensor on GPU directly rather than creating it on CPU and later moving to GPU. The places where such optimizations were necessary were determined by line-profiling and looking at CPU\/GPU traces and [Flame Graphs](https:\/\/github.com\/brendangregg\/FlameGraph).","__index_level_0__":5681}
+{"text":"\n## Benchmarking setup and results summary","__index_level_0__":5682}
+{"text":"We have two versions of code to compare: _original_ and _optimized_. On top of this, several optimization features (xFormers, PyTorch memory efficient attention, compilation) can be turned on\/off. Overall, as mentioned in the introduction, we will be benchmarking 5 configurations:","__index_level_0__":5683}
+{"text":"* _Original code without xFormers_\n* _Original code with xFormers_\n* _Optimized code with vanilla math attention backend and no compilation_\n* _Optimized code with memory-efficient attention backend and no compilation_\n* _Optimized code with memory-efficient attention backend and compilation_","__index_level_0__":5685}
+{"text":"As the _original version_ we took the version of the code which uses PyTorch 1.12 and a custom implementation of attention. The _optimized version_ uses `nn.MultiheadAttention` in `CrossAttention` and PyTorch 2.0.0.dev20230111+cu117. It also has a few other minor optimizations in PyTorch-related code. ","__index_level_0__":5686}
+{"text":"The table below shows runtime of each version of the code in seconds, and the percentage improvement compared to the _original with xFormers. _The compilation time is excluded.","__index_level_0__":5687}
+{"text":"**Runtimes for batch size 1. In parenthesis - relative improvement with respect to the \u201cOriginal with xFormers\u201d row**","__index_level_0__":5688}
+{"text":"\n<table class=\"table table-bordered\">\n<thead>\n  <tr>\n   <td><strong>Configuration<\/strong>\n   <\/td>\n   <td><strong>P100<\/strong>\n   <\/td>\n   <td><strong>T4<\/strong>\n   <\/td>\n   <td><strong>A10<\/strong>\n   <\/td>\n   <td><strong>V100<\/strong>\n   <\/td>\n   <td><strong>A100<\/strong>\n   <\/td>\n  <\/tr>\n<\/thead>\n  <tr>\n   <td><strong>Original without xFormers<\/strong>\n   <\/td>\n   <td>30.4s (-19.3%)\n   <\/td>\n   <td>29.8s (-77.3%)\n   <\/td>\n   <td>13.0s (-83.9%)\n   <\/td>\n   <td>10.9s (-33.1%)\n   <\/td>\n   <td>8.0s (-19.3%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Original with xFormers<\/strong>\n   <\/td>\n   <td><strong>25.5s<\/strong> (0.0%)\n   <\/td>\n   <td>16.8s (0.0%)\n   <\/td>\n   <td><strong>7.1s<\/strong> (0.0%)\n   <\/td>\n   <td>8.2s (0.0%)\n   <\/td>\n   <td>6.7s (0.0%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Optimized with vanilla math attention, no compilation<\/strong>\n   <\/td>\n   <td>27.3s (-7.0%)\n   <\/td>\n   <td>19.9s (-18.7%)\n   <\/td>\n   <td>13.2s (-87.2%)\n   <\/td>\n   <td>7.5s (8.7%)\n   <\/td>\n   <td>5.7s (15.1%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Optimized with mem. efficient attention, no compilation<\/strong>\n   <\/td>\n   <td>26.5s (-3.8%)\n   <\/td>\n   <td>16.8s (0.2%)\n   <\/td>\n   <td><strong>7.1s<\/strong> (-0.8%)\n   <\/td>\n   <td>6.9s (16.0%)\n   <\/td>\n   <td>5.3s (20.6%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Optimized with mem. efficient attention and compilation<\/strong>\n   <\/td>\n   <td>-\n   <\/td>\n   <td><strong>16.4s <\/strong>(2.1%)\n   <\/td>\n   <td>7.2s (-2.3%)\n   <\/td>\n   <td><strong>6.6s<\/strong> (18.6%)\n   <\/td>\n   <td><strong>4.1s<\/strong> (38.5%)\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":5689}
+{"text":"\n**Runtimes for batch size 2**","__index_level_0__":5690}
+{"text":"\n<table class=\"table table-bordered\">\n<thead>\n  <tr>\n   <td><strong>Configuration<\/strong>\n   <\/td>\n   <td><strong>P100<\/strong>\n   <\/td>\n   <td><strong>T4<\/strong>\n   <\/td>\n   <td><strong>A10<\/strong>\n   <\/td>\n   <td><strong>V100<\/strong>\n   <\/td>\n   <td><strong>A100<\/strong>\n   <\/td>\n  <\/tr>\n<\/thead>\n  <tr>\n   <td><strong>Original without xFormers<\/strong>\n   <\/td>\n   <td>58.0s (-21.6%)\n   <\/td>\n   <td>57.6s (-84.0%)\n   <\/td>\n   <td>24.4s (-95.2%)\n   <\/td>\n   <td>18.6s (-63.0%)\n   <\/td>\n   <td>12.0s (-50.6%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Original with xFormers<\/strong>\n   <\/td>\n   <td>47.7s (0.0%)\n   <\/td>\n   <td>31.3s (0.0%)\n   <\/td>\n   <td>12.5s (0.0%)\n   <\/td>\n   <td>11.4s (0.0%)\n   <\/td>\n   <td>8.0s (0.0%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Optimized with vanilla math attention, no compilation<\/strong>\n   <\/td>\n   <td>49.3s (-3.5%)\n   <\/td>\n   <td>37.9s (-21.0%)\n   <\/td>\n   <td>17.8s (-42.2%)\n   <\/td>\n   <td>12.7s (-10.7%)\n   <\/td>\n   <td>7.8s (1.8%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Optimized with mem. efficient attention, no compilation<\/strong>\n   <\/td>\n   <td><strong>47.5s <\/strong>(0.4%)\n   <\/td>\n   <td>31.2s (0.5%)\n   <\/td>\n   <td>12.2s (2.6%)\n   <\/td>\n   <td>11.5s (-0.7%)\n   <\/td>\n   <td>7.0s (12.6%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Optimized with mem. efficient attention and compilation<\/strong>\n   <\/td>\n   <td>-\n   <\/td>\n   <td><strong>28.0s<\/strong> (10.5%)\n   <\/td>\n   <td><strong>11.4s<\/strong> (9.0%)\n   <\/td>\n   <td><strong>10.7s <\/strong>(6.4%)\n   <\/td>\n   <td><strong>6.4s<\/strong> (20.3%)\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":5691}
+{"text":"\n**Runtimes for batch size 4**","__index_level_0__":5692}
+{"text":"\n<table class=\"table table-bordered\">\n<thead>\n  <tr>\n   <td><strong>Configuration<\/strong>\n   <\/td>\n   <td><strong>P100<\/strong>\n   <\/td>\n   <td><strong>T4<\/strong>\n   <\/td>\n   <td><strong>A10<\/strong>\n   <\/td>\n   <td><strong>V100<\/strong>\n   <\/td>\n   <td><strong>A100<\/strong>\n   <\/td>\n  <\/tr>\n<\/thead>\n  <tr>\n   <td><strong>Original without xFormers<\/strong>\n   <\/td>\n   <td>117.9s (-20.0%)\n   <\/td>\n   <td>112.4s (-81.8%)\n   <\/td>\n   <td>47.2s (-101.7%)\n   <\/td>\n   <td>35.8s (-71.9%)\n   <\/td>\n   <td>22.8s (-78.9%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Original with xFormers<\/strong>\n   <\/td>\n   <td>98.3s (0.0%)\n   <\/td>\n   <td>61.8s (0.0%)\n   <\/td>\n   <td>23.4s (0.0%)\n   <\/td>\n   <td>20.8s (0.0%)\n   <\/td>\n   <td>12.7s (0.0%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Optimized with vanilla math attention, no compilation<\/strong>\n   <\/td>\n   <td>101.1s (-2.9%)\n   <\/td>\n   <td>73.0s (-18.0%)\n   <\/td>\n   <td>28.3s (-21.0%)\n   <\/td>\n   <td>23.3s (-11.9%)\n   <\/td>\n   <td>14.5s (-13.9%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Optimized with mem. efficient attention, no compilation<\/strong>\n   <\/td>\n   <td><strong>92.9s <\/strong>(5.5%)\n   <\/td>\n   <td>61.1s (1.2%)\n   <\/td>\n   <td>23.9s (-1.9%)\n   <\/td>\n   <td>20.8s (-0.1%)\n   <\/td>\n   <td>12.8s (-0.9%)\n   <\/td>\n  <\/tr>\n  <tr>\n   <td><strong>Optimized with mem. efficient attention and compilation<\/strong>\n   <\/td>\n   <td>-\n   <\/td>\n   <td><strong>53.1s <\/strong>(14.2%)\n   <\/td>\n   <td><strong>20.9s<\/strong> (10.6%)\n   <\/td>\n   <td><strong>18.6s<\/strong> (10.4%)\n   <\/td>\n   <td><strong>11.2s<\/strong> (12.2%)\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":5693}
+{"text":"\nTo minimize fluctuations and external influence on the performance of the benchmarked code, we ran each version of the code one after another, and then repeated this sequence 10 times: A, B, C, D, E,  A, B, \u2026 So the results of a typical run would look like the one in the picture below.. Note that one shouldn\u2019t rely on comparison of absolute run times between different graphs, but comparison of run times_ inside_ one graph is pretty reliable, thanks to our benchmarking setup.","__index_level_0__":5694}
+{"text":"\n![Denoising diffusion model generation benchmarks](\/assets\/images\/2023-04-11-accelerated-generative-diffusion-models4.png){:style=\"max-height:700px\"}  ","__index_level_0__":5696}
+{"text":"\nEach run of text-to-image generation script produces several batches, the number of which is regulated by the CLI parameter `--n_iter`. In the benchmarks we used `n_iter = 2`, but introduced an additional \u201cwarm-up\u201d iteration, which doesn\u2019t contribute to the run time. This was necessary for the runs with compilation, because compilation happens the first time the code runs, and so the first iteration is much longer than all subsequent. To make comparison fair, we also introduced this additional \u201cwarm-up\u201d iteration to all other runs. ","__index_level_0__":5697}
+{"text":"The numbers in the table above are for number of iterations 2 (plus a \u201cwarm-up one\u201d), prompt \u201dA photo\u201d, seed 1, PLMS sampler, and autocast turned on.","__index_level_0__":5698}
+{"text":"Benchmarks were done using P100, V100, A100, A10 and T4 GPUs. The T4 benchmarks were done in Google Colab Pro. The A10 benchmarks were done on g5.4xlarge AWS instances with 1 GPU.","__index_level_0__":5699}
+{"text":"\n## Conclusions and next steps","__index_level_0__":5700}
+{"text":"We have shown that new features of PyTorch 2 - compiler and optimized attention implementation - give performance improvements exceeding or comparable with what previously required installation of an external dependency (xFormers). PyTorch achieved this, in particular, by integrating memory efficient attention from xFormers into its codebase. This is a significant improvement for user experience, given that xFormers, being a state-of-the-art library, in many scenarios requires custom installation process and long builds.","__index_level_0__":5701}
+{"text":"There are a few natural directions in which this work can be continued:\t","__index_level_0__":5702}
+{"text":"* The optimizations we implemented and described here are only benchmarked for text-to-image inference so far. It would be interesting to see how they affect training performance. PyTorch compilation can be directly applied to training; enabling training with PyTorch optimized attention is on the roadmap\n* We intentionally minimized changes to the original model code. Further profiling and optimization can probably bring more improvements\n* At the moment compilation is applied only to the U-Net model inside the sampler. Since there is a lot happening outside of U-Net (e.g. operations directly in the sampling loop), it would be beneficial to compile the whole sampler. However, this would require analysis of the compilation process to avoid recompilation at every sampling step\n* Current code only applies compilation within the PLMS sampler, but it should be trivial to extend it to other samplers\n* Besides text-to-image generation, diffusion models are also applied to other tasks - image-to-image and inpainting. It would be interesting to measure how their performance improves from PyTorch 2 optimizations ","__index_level_0__":5704}
+{"text":"See if you can increase performance of open source diffusion models using the methods we described, and share the results! ","__index_level_0__":5705}
+{"text":"\n## Resources","__index_level_0__":5706}
+{"text":"* PyTorch 2.0 overview, which has a lot of information on `torch.compile:` [https:\/\/pytorch.org\/get-started\/pytorch-2.0\/](https:\/\/pytorch.org\/get-started\/pytorch-2.0\/) \n* Tutorial on `torch.compile`: [https:\/\/pytorch.org\/tutorials\/intermediate\/torch_compile_tutorial.html](https:\/\/pytorch.org\/tutorials\/intermediate\/torch_compile_tutorial.html)\n* General compilation troubleshooting: [https:\/\/pytorch.org\/docs\/master\/dynamo\/troubleshooting.html](https:\/\/pytorch.org\/docs\/master\/dynamo\/troubleshooting.html)\n* Details on graph breaks: [https:\/\/pytorch.org\/docs\/master\/dynamo\/faq.html#identifying-the-cause-of-a-graph-break](https:\/\/pytorch.org\/docs\/master\/dynamo\/faq.html#identifying-the-cause-of-a-graph-break)\n* Details on guards: [https:\/\/pytorch.org\/docs\/master\/dynamo\/guards-overview.html](https:\/\/pytorch.org\/docs\/master\/dynamo\/guards-overview.html)\n* Video deep dive on TorchDynamo [https:\/\/www.youtube.com\/watch?v=egZB5Uxki0I](https:\/\/www.youtube.com\/watch?v=egZB5Uxki0I) \n* Tutorial on optimized attention in PyTorch 1.12: [https:\/\/pytorch.org\/tutorials\/beginner\/bettertransformer_tutorial.html](https:\/\/pytorch.org\/tutorials\/beginner\/bettertransformer_tutorial.html) ","__index_level_0__":5708}
+{"text":"\n## Acknowledgements","__index_level_0__":5709}
+{"text":"We would like to thank Geeta Chauhan, Natalia Gimelshein, Patrick Labatut, Bert Maher, Mark Saroufim, Michael Voznesensky and Francisco Massa for their valuable advice and early feedback on the text.","__index_level_0__":5710}
+{"text":"Special thanks to Yudong Tao initiating the work on using PyTorch native attention in diffusion models.\n \n source: https:\/\/pytorch.org\/blog\/accelerated-generative-diffusion-models\/ \n category: pytorch blogs","__index_level_0__":5711}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"New Library Updates in PyTorch 2.0\"\n---","__index_level_0__":5712}
+{"text":"We are bringing a number of improvements to the current PyTorch libraries, alongside the [PyTorch 2.0 release](\/blog\/pytorch-2.0-release\/). These updates demonstrate our focus on developing common and extensible APIs across all domains to make it easier for our community to build ecosystem projects on PyTorch. ","__index_level_0__":5714}
+{"text":"Along with 2.0, we are also releasing a series of beta updates to the PyTorch domain libraries, including those that are in-tree, and separate libraries including TorchAudio, TorchVision, and TorchText. An update for TorchX is also being released as it moves to community supported mode. Please find the list of the latest stable versions and updates below.","__index_level_0__":5715}
+{"text":"**Latest Stable Library Versions (<a href=\"https:\/\/pytorch.org\/docs\/stable\/index.html\">Full List<\/a>)**\n<table class=\"table table-bordered\">\n  <tr>\n   <td>TorchArrow 0.1.0\n   <\/td>\n   <td>TorchRec 0.4.0\n   <\/td>\n   <td>TorchVision 0.15\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>TorchAudio 2.0\n   <\/td>\n   <td>TorchServe 0.7.1\n   <\/td>\n   <td>TorchX 0.4.0\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>TorchData 0.6.0\n   <\/td>\n   <td>TorchText 0.15.0\n   <\/td>\n   <td>PyTorch on XLA Devices 1.14\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":5716}
+{"text":"\n*To see [prior versions](https:\/\/pytorch.org\/docs\/stable\/index.html) or (unstable) nightlies, click on versions in the top left menu above \u2018Search Docs\u2019.","__index_level_0__":5717}
+{"text":"\n## TorchAudio ","__index_level_0__":5718}
+{"text":"### [Beta] Data augmentation operators","__index_level_0__":5719}
+{"text":"The release adds several data augmentation operators under torchaudio.functional and torchaudio.transforms:\n* torchaudio.functional.add_noise\n* torchaudio.functional.convolve\n* torchaudio.functional.deemphasis\n* torchaudio.functional.fftconvolve\n* torchaudio.functional.preemphasis\n* torchaudio.functional.speed\n* torchaudio.transforms.AddNoise\n* torchaudio.transforms.Convolve\n* torchaudio.transforms.Deemphasis\n* torchaudio.transforms.FFTConvolve\n* torchaudio.transforms.Preemphasis\n* torchaudio.transforms.Speed\n* torchaudio.transforms.SpeedPerturbation","__index_level_0__":5720}
+{"text":"The operators can be used to synthetically diversify training data to improve the generalizability of downstream models.","__index_level_0__":5721}
+{"text":"For usage details, please refer to the [functional](https:\/\/pytorch.org\/audio\/2.0.0\/functional.html) and [transform](https:\/\/pytorch.org\/audio\/2.0.0\/transforms.html) documentation and [Audio Data Augmentation](https:\/\/pytorch.org\/audio\/2.0.0\/tutorials\/audio_data_augmentation_tutorial.html) tutorial.","__index_level_0__":5722}
+{"text":"\n### [Beta] WavLM and XLS-R models","__index_level_0__":5723}
+{"text":"The release adds two self-supervised learning models for speech and audio.","__index_level_0__":5724}
+{"text":"* [WavLM](https:\/\/ieeexplore.ieee.org\/document\/9814838) that is robust to noise and reverberation.\n* [XLS-R](https:\/\/arxiv.org\/abs\/2111.09296) that is trained on cross-lingual datasets.","__index_level_0__":5725}
+{"text":"Besides the model architectures, torchaudio also supports corresponding pre-trained pipelines:","__index_level_0__":5726}
+{"text":"* torchaudio.pipelines.WAVLM_BASE\n* torchaudio.pipelines.WAVLM_BASE_PLUS\n* torchaudio.pipelines.WAVLM_LARGE\n* torchaudio.pipelines.WAV2VEC_XLSR_300M\n* torchaudio.pipelines.WAV2VEC_XLSR_1B\n* torchaudio.pipelines.WAV2VEC_XLSR_2B","__index_level_0__":5727}
+{"text":"For usage details, please refer to the [factory function](https:\/\/pytorch.org\/audio\/2.0.0\/generated\/torchaudio.models.Wav2Vec2Model.html#factory-functions) and [pre-trained pipelines](https:\/\/pytorch.org\/audio\/2.0.0\/pipelines.html#id3) documentation.","__index_level_0__":5728}
+{"text":"\n## TorchRL  ","__index_level_0__":5729}
+{"text":"The initial release of torchrl includes several features that span across the entire RL domain. TorchRL can already be used in online, offline, multi-agent, multi-task and distributed RL settings, among others. See below:","__index_level_0__":5730}
+{"text":"\n### [Beta] Environment wrappers and transforms","__index_level_0__":5731}
+{"text":"torchrl.envs includes several wrappers around common environment libraries. This allows users to swap one library with another without effort. These wrappers build an interface between these simulators and torchrl:","__index_level_0__":5732}
+{"text":"* dm_control: \n* Gym\n* Brax\n* EnvPool\n* Jumanji\n* Habitat","__index_level_0__":5733}
+{"text":"It also comes with many commonly used transforms and vectorized environment utilities that allow for a fast execution across simulation libraries. Please refer to the [documentation](https:\/\/pytorch.org\/rl\/reference\/envs.html) for more detail.","__index_level_0__":5734}
+{"text":"\n### [Beta] Datacollectors","__index_level_0__":5735}
+{"text":"Data collection in RL is made easy via the usage of single process or multiprocessed\/distributed data collectors that execute the policy in the environment over a desired duration and deliver samples according to the user\u2019s needs. These can be found in torchrl.collectors and are documented [here](https:\/\/pytorch.org\/rl\/reference\/collectors.html).","__index_level_0__":5736}
+{"text":"\n### [Beta] Objective modules","__index_level_0__":5737}
+{"text":"Several objective functions are included in torchrl.objectives, among which: ","__index_level_0__":5738}
+{"text":"* A generic PPOLoss class and derived ClipPPOLoss and KLPPOLoss\n* SACLoss and DiscreteSACLoss\n* DDPGLoss\n* DQNLoss\n* REDQLoss\n* A2CLoss\n* TD3Loss\n* ReinforceLoss\n* Dreamer","__index_level_0__":5739}
+{"text":"Vectorized value function operators also appear in the library. Check the documentation [here](https:\/\/pytorch.org\/rl\/reference\/objectives.html).","__index_level_0__":5740}
+{"text":"\n### [Beta] Models and exploration strategies","__index_level_0__":5741}
+{"text":"We provide multiple models, modules and exploration strategies. Get a detailed description in [the doc](https:\/\/pytorch.org\/rl\/reference\/modules.html).","__index_level_0__":5742}
+{"text":"\n### [Beta] Composable replay buffer","__index_level_0__":5743}
+{"text":"A composable replay buffer class is provided that can be used to store data in multiple contexts including single and multi-agent, on and off-policy and many more.. Components include:","__index_level_0__":5744}
+{"text":"* Storages (list, physical or memory-based contiguous storages)\n* Samplers (Prioritized, sampler without repetition)\n* Writers\n* Possibility to add transforms","__index_level_0__":5745}
+{"text":"Replay buffers and other data utilities are documented [here](https:\/\/pytorch.org\/rl\/reference\/data.html).","__index_level_0__":5746}
+{"text":"\n### [Beta] Logging tools and trainer","__index_level_0__":5747}
+{"text":"We support multiple logging tools including tensorboard, wandb and mlflow.","__index_level_0__":5748}
+{"text":"We provide a generic Trainer class that allows for easy code recycling and checkpointing.","__index_level_0__":5749}
+{"text":"These features are documented [here](https:\/\/pytorch.org\/rl\/reference\/trainers.html).","__index_level_0__":5750}
+{"text":"\n## TensorDict","__index_level_0__":5751}
+{"text":"TensorDict is a new data carrier for PyTorch.","__index_level_0__":5752}
+{"text":"\n### [Beta] TensorDict: specialized dictionary for PyTorch","__index_level_0__":5753}
+{"text":"TensorDict allows you to execute many common operations across batches of tensors carried by a single container. TensorDict supports many shape and device or storage operations, and  can readily be used in distributed settings. Check the [documentation](https:\/\/pytorch-labs.github.io\/tensordict\/) to know more.","__index_level_0__":5754}
+{"text":"\n### [Beta] @tensorclass: a dataclass for PyTorch","__index_level_0__":5755}
+{"text":"Like TensorDict, [tensorclass](https:\/\/pytorch-labs.github.io\/tensordict\/reference\/prototype.html) provides the opportunity to write dataclasses with built-in torch features such as shape or device operations. ","__index_level_0__":5756}
+{"text":"\n### [Beta] tensordict.nn: specialized modules for TensorDict","__index_level_0__":5757}
+{"text":"The [tensordict.nn module](https:\/\/pytorch-labs.github.io\/tensordict\/reference\/nn.html) provides specialized nn.Module subclasses that make it easy to build arbitrarily complex graphs that can be executed with TensorDict inputs. It is compatible with the latest PyTorch features such as functorch, torch.fx and torch.compile.","__index_level_0__":5758}
+{"text":"\n## TorchRec","__index_level_0__":5759}
+{"text":"\n### [Beta] KeyedJaggedTensor All-to-All Redesign and Input Dist Fusion","__index_level_0__":5760}
+{"text":"We observed performance regression due to a bottleneck in sparse data distribution for models that have multiple, large KJTs to redistribute. ","__index_level_0__":5761}
+{"text":"To combat this we altered the comms pattern to transport the minimum data required in the initial collective to support the collective calls for the actual KJT tensor data. This data sent in the initial collective, \u2018splits\u2019 means more data is transmitted over the comms stream overall, but the CPU is blocked for significantly shorter amounts of time leading to better overall QPS.","__index_level_0__":5762}
+{"text":"Furthermore, we altered the TorchRec train pipeline to group the initial collective calls for the splits together before launching the more expensive KJT tensor collective calls. This fusion minimizes the CPU blocked time as launching each subsequent input distribution is no longer dependent on the previous input distribution.","__index_level_0__":5763}
+{"text":"With this feature, variable batch sizes are now natively supported across ranks. These features are documented [here](https:\/\/github.com\/pytorch\/torchrec\/commit\/d0d23bef8aef5a79a1061fbc842c97bb68b91463).","__index_level_0__":5764}
+{"text":"\n## TorchVision ","__index_level_0__":5765}
+{"text":"\n### [Beta] Extending TorchVision\u2019s Transforms to Object Detection, Segmentation & Video tasks ","__index_level_0__":5766}
+{"text":"TorchVision is extending its Transforms API! Here is what\u2019s new:","__index_level_0__":5767}
+{"text":"* You can use them not only for Image Classification but also for Object Detection, Instance & Semantic Segmentation and Video Classification.\n* You can use new functional transforms for transforming Videos, Bounding Boxes and Segmentation Masks.","__index_level_0__":5768}
+{"text":"Learn more about these new transforms [from our docs](https:\/\/pytorch.org\/vision\/stable\/auto_examples\/), and submit any feedback in our [dedicated issue](https:\/\/github.com\/pytorch\/vision\/issues\/6753).","__index_level_0__":5769}
+{"text":"\n## TorchText ","__index_level_0__":5770}
+{"text":"### [Beta] Adding scriptable T5 and Flan-T5 to the TorchText library with incremental decoding support!","__index_level_0__":5771}
+{"text":"TorchText has added the T5 model architecture with pre-trained weights for both the [original T5 paper](https:\/\/arxiv.org\/abs\/1910.10683) and [Flan-T5](https:\/\/arxiv.org\/abs\/2210.11416). The model is fully torchscriptable and features an optimized [multiheaded attention implementation](https:\/\/pytorch.org\/docs\/master\/generated\/torch.ao.nn.quantizable.MultiheadAttention.html?highlight=multihead#torch.ao.nn.quantizable.MultiheadAttention). We include several examples of how to utilize the model including summarization, classification, and translation.","__index_level_0__":5772}
+{"text":"For more details, please refer to [our docs](https:\/\/pytorch.org\/text\/stable\/models.html).","__index_level_0__":5773}
+{"text":"TorchX is moving to community supported mode. More details will be coming in at a later time. \n source: https:\/\/pytorch.org\/blog\/new-library-updates-in-pytorch-2.0\/ \n category: pytorch blogs","__index_level_0__":5775}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Deprecation of CUDA 11.6 and Python 3.7 Support\"\n---","__index_level_0__":5776}
+{"text":"For the upcoming PyTorch 2.0 feature release (target March 2023), we will target CUDA 11.7 as the stable version and CUDA 11.8 as the experimental version of CUDA and Python >=3.8, &lt;=3.11. ","__index_level_0__":5777}
+{"text":"If you are still using or depending on CUDA 11.6 or Python 3.7 builds, we strongly recommend moving to at least CUDA 11.7 and Python 3.8, as it would be the minimum versions required for PyTorch 2.0.","__index_level_0__":5778}
+{"text":"**Please note that as of Feb 1, CUDA 11.6 and Python 3.7  are no longer included in the nightlies**","__index_level_0__":5779}
+{"text":"Please refer to the Release Compatibility Matrix for PyTorch releases:","__index_level_0__":5780}
+{"text":"\n<table>\n  <tr>\n   <td><strong>PyTorch Version<\/strong>\n   <\/td>\n   <td><strong>Python<\/strong>\n   <\/td>\n   <td><strong>Stable CUDA<\/strong>\n   <\/td>\n   <td><strong>Experimental CUDA<\/strong>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>2.0\n   <\/td>\n   <td>>=3.8, &lt;=3.11\n   <\/td>\n   <td>CUDA 11.7, CUDNN 8.5.0.96\n   <\/td>\n   <td>CUDA 11.8, CUDNN 8.7.0.84\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>1.13\n   <\/td>\n   <td>>=3.7, &lt;=3.10\n   <\/td>\n   <td>CUDA 11.6, CUDNN 8.3.2.44\n   <\/td>\n   <td>CUDA 11.7, CUDNN 8.5.0.96\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>1.12\n   <\/td>\n   <td>>=3.7, &lt;=3.10\n   <\/td>\n   <td>CUDA 11.3, CUDNN 8.3.2.44\n   <\/td>\n   <td>CUDA 11.6, CUDNN 8.3.2.44\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":5781}
+{"text":"\nAs of 2\/1\/2023","__index_level_0__":5782}
+{"text":"For more information on PyTorch releases, updated compatibility matrix and release policies, please see (and bookmark) [Readme](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/RELEASE.md#release-compatibility-matrix).","__index_level_0__":5783}
+{"text":" \n source: https:\/\/pytorch.org\/blog\/deprecation-cuda-python-support\/ \n category: pytorch blogs","__index_level_0__":5784}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'torchvision 0.3: segmentation, detection models, new datasets and more..'\nauthor: Francisco Massa\nredirect_from: \/2019\/05\/23\/torchvision03.html\n---","__index_level_0__":5785}
+{"text":"PyTorch domain libraries like torchvision provide convenient access to common datasets and models that can be used to quickly create a state-of-the-art baseline. Moreover, they also provide common abstractions to reduce boilerplate code that users might have to otherwise repeatedly write. The torchvision 0.3 release brings several new features including models for semantic segmentation, object detection, instance segmentation, and person keypoint detection, as well as custom C++ \/ CUDA ops specific to computer vision.","__index_level_0__":5786}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/torchvision_0.3_headline.png\" width=\"100%\">\n<\/div>","__index_level_0__":5787}
+{"text":"\n### New features include:","__index_level_0__":5788}
+{"text":"**Reference training \/ evaluation scripts:** torchvision now provides, under the references\/ folder, scripts for training and evaluation of the following tasks: classification, semantic segmentation, object detection, instance segmentation and person keypoint detection. These serve as a log of how to train a specific model and provide baseline training and evaluation scripts to quickly bootstrap research.","__index_level_0__":5789}
+{"text":"**torchvision ops:** torchvision now contains custom C++ \/ CUDA operators. Those operators are specific to computer vision, and make it easier to build object detection models. These operators currently do not support PyTorch script mode, but support for it is planned for in the next release. Some of the ops supported include:","__index_level_0__":5790}
+{"text":"* roi_pool (and the module version RoIPool)\n* roi_align (and the module version RoIAlign)\n* nms, for non-maximum suppression of bounding boxes\n* box_iou, for computing the intersection over union metric between two sets of bounding boxes\n* box_area, for computing the area of a set of bounding boxes","__index_level_0__":5791}
+{"text":"Here are a few examples on using torchvision ops:","__index_level_0__":5792}
+{"text":"```python\nimport torch\nimport torchvision","__index_level_0__":5793}
+{"text":"# create 10 random boxes\nboxes = torch.rand(10, 4) * 100\n# they need to be in [x0, y0, x1, y1] format\nboxes[:, 2:] += boxes[:, :2]\n# create a random image\nimage = torch.rand(1, 3, 200, 200)\n# extract regions in `image` defined in `boxes`, rescaling\n# them to have a size of 3x3\npooled_regions = torchvision.ops.roi_align(image, [boxes], output_size=(3, 3))\n# check the size\nprint(pooled_regions.shape)\n# torch.Size([10, 3, 3, 3])","__index_level_0__":5794}
+{"text":"# or compute the intersection over union between\n# all pairs of boxes\nprint(torchvision.ops.box_iou(boxes, boxes).shape)\n# torch.Size([10, 10])\n```","__index_level_0__":5795}
+{"text":"\n**New models and datasets:** torchvision now adds support for object detection, instance segmentation and person keypoint detection models. In addition, several popular datasets have been added. Note: The API is currently experimental and might change in future versions of torchvision. New models include:","__index_level_0__":5796}
+{"text":"### Segmentation Models","__index_level_0__":5797}
+{"text":"The 0.3 release also contains models for dense pixelwise prediction on images.\nIt adds FCN and DeepLabV3 segmentation models, using a ResNet50 and ResNet101 backbones.\nPre-trained weights for ResNet101 backbone are available, and have been trained on a subset of COCO train2017, which contains the same 20 categories as those from Pascal VOC.","__index_level_0__":5798}
+{"text":"The pre-trained models give the following results on the subset of COCO val2017 which contain the same 20 categories as those present in Pascal VOC:","__index_level_0__":5799}
+{"text":"Network | mean IoU | global pixelwise acc\n-- | -- | --\nFCN ResNet101 | 63.7 | 91.9\nDeepLabV3 ResNet101 | 67.4 | 92.4","__index_level_0__":5800}
+{"text":"### Detection Models","__index_level_0__":5801}
+{"text":"Network | box AP | mask AP | keypoint AP\n-- | -- | -- | --\nFaster R-CNN ResNet-50 FPN trained on COCO | 37.0 | \u00a0 | \u00a0\nMask R-CNN ResNet-50 FPN trained on COCO | 37.9 | 34.6 | \u00a0\nKeypoint R-CNN ResNet-50 FPN trained on COCO | 54.6 | \u00a0 | 65.0","__index_level_0__":5802}
+{"text":"The implementations of the models for object detection, instance segmentation and keypoint detection are fast, specially during training.","__index_level_0__":5803}
+{"text":"In the following table, we use 8 V100 GPUs, with CUDA 10.0 and CUDNN 7.4 to report the results. During training, we use a batch size of 2 per GPU, and during testing a batch size of 1 is used.","__index_level_0__":5804}
+{"text":"For test time, we report the time for the model evaluation and post-processing (including mask pasting in image), but not the time for computing the precision-recall.","__index_level_0__":5805}
+{"text":"Network | train time (s \/ it) | test time (s \/ it) | memory (GB)\n-- | -- | -- | --\nFaster R-CNN ResNet-50 FPN | 0.2288 | 0.0590 | 5.2\nMask R-CNN ResNet-50 FPN | 0.2728 | 0.0903 | 5.4\nKeypoint R-CNN ResNet-50 FPN | 0.3789 | 0.1242 | 6.8","__index_level_0__":5806}
+{"text":"\nYou can load and use pre-trained detection and segmentation models with a few lines of code","__index_level_0__":5807}
+{"text":"```python\nimport torchvision","__index_level_0__":5808}
+{"text":"model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)\n# set it to evaluation mode, as the model behaves differently\n# during training and during evaluation\nmodel.eval()","__index_level_0__":5809}
+{"text":"image = PIL.Image.open('\/path\/to\/an\/image.jpg')\nimage_tensor = torchvision.transforms.functional.to_tensor(image)","__index_level_0__":5810}
+{"text":"# pass a list of (potentially different sized) tensors\n# to the model, in 0-1 range. The model will take care of\n# batching them together and normalizing\noutput = model([image_tensor])\n# output is a list of dict, containing the postprocessed predictions\n```","__index_level_0__":5811}
+{"text":"### Classification Models","__index_level_0__":5812}
+{"text":"The following classification models were added:","__index_level_0__":5813}
+{"text":"* GoogLeNet (Inception v1)\n* MobileNet V2\n* ShuffleNet v2\n* ResNeXt-50 32x4d and ResNeXt-101 32x8d","__index_level_0__":5814}
+{"text":"### Datasets","__index_level_0__":5815}
+{"text":"The following datasets were added:","__index_level_0__":5816}
+{"text":"* Caltech101, Caltech256, and CelebA\n* ImageNet dataset (improving on ImageFolder, provides class-strings)\n* Semantic Boundaries Dataset\n* VisionDataset as a base class for all datasets","__index_level_0__":5817}
+{"text":"\nIn addition, we've added more image transforms, general improvements and bug fixes, as well as improved documentation.","__index_level_0__":5818}
+{"text":"**See the full release notes [here](https:\/\/github.com\/pytorch\/vision\/releases) as well as this getting started tutorial [on Google Colab here](https:\/\/colab.research.google.com\/github\/pytorch\/vision\/blob\/temp-tutorial\/tutorials\/torchvision_finetuning_instance_segmentation.ipynb), which describes how to fine tune your own instance segmentation model on a custom dataset.**","__index_level_0__":5819}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/torchvision03\/ \n category: pytorch blogs","__index_level_0__":5821}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Prototype Features Now Available - APIs for Hardware Accelerated Mobile and ARM64 Builds'\nauthor: Team PyTorch\n---","__index_level_0__":5822}
+{"text":"Today, we are announcing four PyTorch prototype features. The first three of these will enable Mobile machine-learning developers to execute models on the full set of hardware (HW) engines making up a system-on-chip (SOC). This gives developers options to optimize their model execution for unique performance, power, and system-level concurrency.","__index_level_0__":5823}
+{"text":"These features include enabling execution on the following on-device HW engines:\n* DSP and NPUs using the Android Neural Networks API (NNAPI), developed in collaboration with Google\n* GPU execution on Android via Vulkan\n* GPU execution on iOS via Metal","__index_level_0__":5824}
+{"text":"This release also includes developer efficiency benefits with newly introduced support for ARM64 builds for Linux.","__index_level_0__":5825}
+{"text":"Below, you\u2019ll find brief descriptions of each feature with the links to get you started. These features are available through our [nightly builds](https:\/\/pytorch.org\/). Reach out to us on the [PyTorch Forums](https:\/\/discuss.pytorch.org\/) for any comment or feedback. We would love to get your feedback on those and hear how you are using them!","__index_level_0__":5826}
+{"text":"## NNAPI Support with Google Android","__index_level_0__":5827}
+{"text":"The Google Android and PyTorch teams collaborated to enable support for Android\u2019s Neural Networks API (NNAPI) via PyTorch Mobile. Developers can now unlock high-performance execution on Android phones as their machine-learning models will be able to access additional hardware blocks on the phone\u2019s system-on-chip. NNAPI allows Android apps to run computationally intensive neural networks on the most powerful and efficient parts of the chips that power mobile phones, including DSPs (Digital Signal Processors) and NPUs (specialized Neural Processing Units). The API was introduced in Android 8 (Oreo) and significantly expanded in Android 10 and 11 to support a richer set of AI models. With this integration, developers can now seamlessly access NNAPI directly from PyTorch Mobile. This initial release includes fully-functional support for a core set of features and operators, and Google and Facebook will be working to expand capabilities in the coming months.","__index_level_0__":5828}
+{"text":"**Links**\n* [Android Blog: Android Neural Networks API 1.3 and PyTorch Mobile support](https:\/\/android-developers.googleblog.com\/2020\/11\/android-neural-networks-api-13.html)\n* [PyTorch Medium Blog: Support for Android NNAPI with PyTorch Mobile](http:\/\/bit.ly\/android-nnapi-pytorch-mobile-announcement)","__index_level_0__":5829}
+{"text":"## PyTorch Mobile GPU support","__index_level_0__":5830}
+{"text":"Inferencing on GPU can provide great performance on many models types, especially those utilizing high-precision floating-point math. Leveraging the GPU for ML model execution as those found in SOCs from Qualcomm, Mediatek, and Apple allows for CPU-offload, freeing up the Mobile CPU for non-ML use cases. This initial prototype level support provided for on device GPUs is via the Metal API specification for iOS, and the Vulkan API specification for Android. As this feature is in an early stage: performance is not optimized and model coverage is limited. We expect this to improve significantly over the course of 2021 and would like to hear from you which models and devices you would like to see performance improvements on.","__index_level_0__":5831}
+{"text":"**Links**\n* [Prototype source workflows](https:\/\/github.com\/pytorch\/tutorials\/tree\/master\/prototype_source)","__index_level_0__":5832}
+{"text":"## ARM64 Builds for Linux","__index_level_0__":5833}
+{"text":"We will now provide prototype level PyTorch builds for ARM64 devices on Linux. As we see more ARM usage in our community with platforms such as Raspberry Pis and Graviton(2) instances spanning both at the edge and on servers respectively. This feature is available through our [nightly builds](https:\/\/pytorch.org\/).","__index_level_0__":5834}
+{"text":"We value your feedback on these features and look forward to collaborating with you to continuously improve them further!","__index_level_0__":5835}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/prototype-features-now-available-apis-for-hardware-accelerated-mobile-and-arm64-builds\/ \n category: pytorch blogs","__index_level_0__":5837}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch Enterprise Support Program Update\"\nauthor: Team PyTorch\nfeatured-img: \"\"\n---","__index_level_0__":5838}
+{"text":"On May 25, 2021, we announced the [PyTorch Enterprise Support Program](https:\/\/pytorch.org\/blog\/announcing-pytorch-enterprise\/) (ESP) that enabled providers to develop and offer tailored enterprise-grade support to their customers.","__index_level_0__":5839}
+{"text":"The program enabled Program certified service providers to develop and offer tailored enterprise-grade support to their customers through contribution of hotfixes and other improvements requested by PyTorch enterprise users who were developing models in production at scale for mission-critical applications. However, as we evaluate community feedback, we found ongoing ESP support was not necessary at this time and will immediately divert these resources to other areas to improve the user experience for the entire community.","__index_level_0__":5840}
+{"text":"Today, we are removing the PyTorch long-term support (LTS 1.8.2) download link from the \u201cGet Started\u201d page from the \u201c[Start Locally](https:\/\/pytorch.org\/get-started\/locally\/)\u201d download option in order to simplify the user experience. One can download PyTorch v1.8.2 in [previous versions](\/get-started\/previous-versions\/#v182-with-lts-support). Please note that it is only supported for Python while it is being deprecated. If there are any updates to ESP\/LTS, we will update future blogs.","__index_level_0__":5841}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/Pytorch-Enterprise-Support-Img1.png\" width=\"70%\">\n<\/p>","__index_level_0__":5842}
+{"text":"Please reach out to [marketing@pytorch.org](mailto:marketing@pytorch.org) with any questions.\n \n source: https:\/\/pytorch.org\/blog\/pytorch-enterprise-support-update\/ \n category: pytorch blogs","__index_level_0__":5843}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'New Releases: PyTorch 1.2, torchtext 0.4, torchaudio 0.3, and torchvision 0.4'\nauthor: Team PyTorch\nredirect_from: \/2019\/08\/06\/pytorch_aug2019_releases.html\n---","__index_level_0__":5844}
+{"text":"Since the release of PyTorch 1.0, we\u2019ve seen the community expand to add new tools, contribute to a growing set of models available in the PyTorch Hub, and continually increase usage in both research and production.","__index_level_0__":5845}
+{"text":"From a core perspective, PyTorch has continued to add features to support both research and production usage, including the ability to bridge these two worlds via [TorchScript](https:\/\/pytorch.org\/docs\/stable\/jit.html). Today, we are excited to announce that we have four new releases including PyTorch 1.2, torchvision 0.4, torchaudio 0.3, and torchtext 0.4. You can get started now with any of these releases at [pytorch.org](https:\/\/pytorch.org\/get-started\/locally\/).","__index_level_0__":5846}
+{"text":"# PyTorch 1.2","__index_level_0__":5847}
+{"text":"With PyTorch 1.2, the open source ML framework takes a major step forward for production usage with the addition of an improved and more polished TorchScript environment. These improvements make it even easier to ship production models, expand support for exporting ONNX formatted models, and enhance module level support for Transformers. In addition to these new features, [TensorBoard](https:\/\/pytorch.org\/docs\/stable\/tensorboard.html) is now no longer experimental - you can simply type `from torch.utils.tensorboard import SummaryWriter` to get started.","__index_level_0__":5848}
+{"text":"## TorchScript Improvements","__index_level_0__":5849}
+{"text":"Since its release in PyTorch 1.0, TorchScript has provided a path to production for eager PyTorch models. The TorchScript compiler converts PyTorch models to a statically typed graph representation, opening up opportunities for\noptimization and execution in constrained environments where Python is not available. You can incrementally convert your model to TorchScript, mixing compiled code seamlessly with Python.","__index_level_0__":5850}
+{"text":"PyTorch 1.2 significantly expands TorchScript's support for the subset of Python used in PyTorch models and delivers a new, easier-to-use API for compiling your models to TorchScript. See the [migration guide](https:\/\/pytorch.org\/docs\/master\/jit.html#migrating-to-pytorch-1-2-recursive-scripting-api) for details. Below is an example usage of the new API:","__index_level_0__":5851}
+{"text":"```python\nimport torch","__index_level_0__":5852}
+{"text":"class MyModule(torch.nn.Module):\n    def __init__(self, N, M):\n        super(MyModule, self).__init__()\n        self.weight = torch.nn.Parameter(torch.rand(N, M))","__index_level_0__":5853}
+{"text":"    def forward(self, input):\n        if input.sum() > 0:\n          output = self.weight.mv(input)\n        else:\n          output = self.weight + input\n        return output","__index_level_0__":5854}
+{"text":"# Compile the model code to a static representation\nmy_script_module = torch.jit.script(MyModule(3, 4))","__index_level_0__":5855}
+{"text":"# Save the compiled code and model data so it can be loaded elsewhere\nmy_script_module.save(\"my_script_module.pt\")\n```","__index_level_0__":5856}
+{"text":"To learn more, see our [Introduction to TorchScript](https:\/\/pytorch.org\/tutorials\/beginner\/Intro_to_TorchScript.html) and [Loading a\nPyTorch Model in C++](https:\/\/pytorch.org\/tutorials\/advanced\/cpp_export.html) tutorials.","__index_level_0__":5857}
+{"text":"## Expanded ONNX Export","__index_level_0__":5858}
+{"text":"The [ONNX](http:\/\/onnx.ai\/) community continues to grow with an open [governance structure](https:\/\/github.com\/onnx\/onnx\/wiki\/Expanded-ONNX-Steering-Committee-Announced!) and additional steering committee members, special interest groups (SIGs), and working groups (WGs). In collaboration with Microsoft, we\u2019ve added full support to export ONNX Opset versions 7(v1.2), 8(v1.3), 9(v1.4) and 10 (v1.5). We\u2019ve have also enhanced the constant folding pass to support Opset 10, the latest available version of ONNX. ScriptModule has also been improved including support for multiple outputs, tensor factories, and tuples as inputs and outputs. Additionally, users are now able to register their own symbolic to export custom ops, and specify the dynamic dimensions of inputs during export. Here is a summary of the all of the major improvements:","__index_level_0__":5859}
+{"text":"* Support for multiple Opsets including the ability to export dropout, slice, flip, and interpolate in Opset 10.\n* Improvements to ScriptModule including support for multiple outputs, tensor factories, and tuples as inputs and outputs.\n* More than a dozen additional PyTorch operators supported including the ability to export a custom operator.\n* Many big fixes and test infra improvements.","__index_level_0__":5860}
+{"text":"You can try out the latest tutorial [here](https:\/\/pytorch.org\/tutorials\/advanced\/super_resolution_with_onnxruntime.html), contributed by @lara-hdr at Microsoft. A big thank you to the entire Microsoft team for all of their hard work to make this release happen!","__index_level_0__":5861}
+{"text":"## nn.Transformer","__index_level_0__":5862}
+{"text":"In PyTorch 1.2, we now include a standard [nn.Transformer](https:\/\/pytorch.org\/docs\/stable\/nn.html?highlight=transformer#torch.nn.Transformer) module, based on the paper \u201c[Attention is All You Need](https:\/\/arxiv.org\/abs\/1706.03762)\u201d. The `nn.Transformer` module relies entirely on an [attention mechanism](https:\/\/pytorch.org\/docs\/stable\/nn.html?highlight=nn%20multiheadattention#torch.nn.MultiheadAttention) to draw global dependencies between input and output.  The individual components of the `nn.Transformer` module are designed so they can be adopted independently. For example, the [nn.TransformerEncoder](https:\/\/pytorch.org\/docs\/stable\/nn.html?highlight=nn%20transformerencoder#torch.nn.TransformerEncoder) can be used by itself, without the larger `nn.Transformer`. The new APIs include:","__index_level_0__":5863}
+{"text":"* `nn.Transformer`\n* `nn.TransformerEncoder` and `nn.TransformerEncoderLayer`\n* `nn.TransformerDecoder` and `nn.TransformerDecoderLayer`","__index_level_0__":5864}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/transformer.png\" width=\"70%\">\n<\/div>","__index_level_0__":5865}
+{"text":"See the [Transformer Layers](https:\/\/pytorch.org\/docs\/stable\/nn.html#transformer-layers) documentation for more information. See [here](https:\/\/github.com\/pytorch\/pytorch\/releases) for the full PyTorch 1.2 release notes.","__index_level_0__":5866}
+{"text":"# Domain API Library Updates","__index_level_0__":5867}
+{"text":"PyTorch domain libraries like torchvision, torchtext, and torchaudio provide convenient access to common datasets, models, and transforms that can be used to quickly create a state-of-the-art baseline. Moreover, they also provide common abstractions to reduce boilerplate code that users might have to otherwise repeatedly write. Since research domains have distinct requirements, an ecosystem of specialized libraries called domain APIs (DAPI) has emerged around PyTorch to simplify the development of new and existing algorithms in a number of fields. We\u2019re excited to release three updated DAPI libraries for text, audio, and vision that compliment the PyTorch 1.2 core release.","__index_level_0__":5868}
+{"text":"## Torchaudio 0.3 with Kaldi Compatibility, New Transforms","__index_level_0__":5869}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/spectrograms.png\" width=\"100%\">\n<\/div>","__index_level_0__":5870}
+{"text":"Torchaudio specializes in machine understanding of audio waveforms. It is an ML library that provides relevant signal processing functionality (but is not a general signal processing library). It leverages PyTorch\u2019s GPU support to provide many tools and transformations for waveforms to make data loading and standardization easier and more readable. For example, it offers data loaders for waveforms using sox, and transformations such as spectrograms, resampling, and mu-law encoding and decoding.","__index_level_0__":5871}
+{"text":"We are happy to announce the availability of torchaudio 0.3.0, with a focus on standardization and complex numbers, a transformation (resample) and two new functionals (phase_vocoder, ISTFT), Kaldi compatibility, and a new tutorial. Torchaudio was redesigned to be an extension of PyTorch and a part of the domain APIs (DAPI) ecosystem.","__index_level_0__":5872}
+{"text":"### Standardization","__index_level_0__":5873}
+{"text":"Significant effort in solving machine learning problems goes into data preparation. In this new release, we've updated torchaudio's interfaces for its transformations to standardize around the following vocabulary and conventions.","__index_level_0__":5874}
+{"text":"Tensors are assumed to have channel as the first dimension and time as the last dimension (when applicable). This makes it consistent with PyTorch's dimensions. For size names, the prefix `n_` is used (e.g. \"a tensor of size (`n_freq`, `n_mel`)\") whereas dimension names do not have this prefix (e.g. \"a tensor of dimension (channel, time)\"). The input of all transforms and functions now assumes channel first. This is done to be consistent with PyTorch, which has channel followed by the number of samples. The channel parameter of all transforms and functions is now deprecated.","__index_level_0__":5875}
+{"text":"The output of `STFT` is (channel, frequency, time, 2), meaning for each channel, the columns are the Fourier transform of a certain window, so as we travel horizontally we can see each column (the Fourier transformed waveform) change over time. This matches the output of librosa so we no longer need to transpose in our test comparisons with `Spectrogram`, `MelScale`, `MelSpectrogram`, and `MFCC`. Moreover, because of these new conventions, we deprecated `LC2CL` and `BLC2CBL` which were used to transfer from one shape of signal to another.","__index_level_0__":5876}
+{"text":"As part of this release, we're also introducing support for complex numbers via tensors of dimension (..., 2), and providing `magphase` to convert such a tensor into its magnitude and phase, and similarly `complex_norm` and `angle`.","__index_level_0__":5877}
+{"text":"The details of the standardization are provided in the [README](https:\/\/github.com\/pytorch\/audio\/blob\/v0.3.0\/README.md#Conventions).","__index_level_0__":5878}
+{"text":"### Functionals, Transformations, and Kaldi Compatibility","__index_level_0__":5879}
+{"text":"Prior to the standardization, we separated state and computation into `torchaudio.transforms` and `torchaudio.functional`.","__index_level_0__":5880}
+{"text":"As part of the transforms, we're adding a new transformation in 0.3.0: `Resample`. `Resample` can upsample or downsample a waveform to a different frequency.","__index_level_0__":5881}
+{"text":"As part of the functionals, we're introducing: `phase_vocoder`, a phase vocoder to change the speed of a waveform without changing its pitch, and `ISTFT`, the inverse `STFT` implemented to be compatible with STFT provided by PyTorch. This separation allows us to make functionals weak scriptable and to utilize JIT in 0.3.0. We thus have JIT and CUDA support for the following transformations: `Spectrogram`, `AmplitudeToDB` (previously named `SpectrogramToDB`), `MelScale`,\n`MelSpectrogram`, `MFCC`, `MuLawEncoding`, `MuLawDecoding` (previously named `MuLawExpanding`).","__index_level_0__":5882}
+{"text":"We now also provide a compatibility interface with Kaldi to ease onboarding and reduce a user's code dependency on Kaldi. We now have an interface for `spectrogram`, `fbank`, and `resample_waveform`.","__index_level_0__":5883}
+{"text":"### New Tutorial","__index_level_0__":5884}
+{"text":"To showcase the new conventions and transformations, we have a [new tutorial](https:\/\/pytorch.org\/tutorials\/beginner\/audio_preprocessing_tutorial.html) demonstrating how to preprocess waveforms using torchaudio. This tutorial walks through an example of loading a waveform and applying some of the available transformations to it.","__index_level_0__":5885}
+{"text":"We are excited to see an active community around torchaudio and eager to further grow and support it. We encourage you to go ahead and experiment for yourself with this tutorial and the two datasets that are available: VCTK and YESNO! They have an interface to download the datasets and preprocess them in a convenient format. You can find the details in the release notes [here](https:\/\/github.com\/pytorch\/audio\/releases).","__index_level_0__":5886}
+{"text":"## Torchtext 0.4 with supervised learning datasets","__index_level_0__":5887}
+{"text":"A key focus area of torchtext is to provide the fundamental elements to help accelerate NLP research. This includes easy access to commonly used datasets and basic preprocessing pipelines for working on raw text based data. The torchtext 0.4.0 release includes several popular supervised learning baselines with \"one-command\" data loading. A [tutorial](https:\/\/pytorch.org\/tutorials\/beginner\/text_sentiment_ngrams_tutorial.html) is included to show how to use the new datasets for text classification analysis. We also added and improved on a few functions such as [get_tokenizer](https:\/\/pytorch.org\/text\/data.html?highlight=get_tokenizer#torchtext.data.get_tokenizer) and [build_vocab_from_iterator](https:\/\/pytorch.org\/text\/vocab.html#build-vocab-from-iterator) to make it easier to implement future datasets. Additional examples can be found [here](https:\/\/github.com\/pytorch\/text\/tree\/master\/examples\/text_classification).","__index_level_0__":5888}
+{"text":"Text classification is an important task in Natural Language Processing with many applications, such as sentiment analysis. The new release includes several popular [text classification datasets](https:\/\/pytorch.org\/text\/datasets.html?highlight=textclassification#torchtext.datasets.TextClassificationDataset) for supervised learning including:","__index_level_0__":5889}
+{"text":"* AG_NEWS\n* SogouNews\n* DBpedia\n* YelpReviewPolarity\n* YelpReviewFull\n* YahooAnswers\n* AmazonReviewPolarity\n* AmazonReviewFull","__index_level_0__":5890}
+{"text":"Each dataset comes with two parts (train vs. test), and can be easily loaded with a single command. The datasets also support an ngrams feature to capture the partial information about the local word order. Take a look at the tutorial [here](https:\/\/pytorch.org\/tutorials\/beginner\/text_sentiment_ngrams_tutorial.html) to learn more about how to use the new datasets for supervised problems such as text classification analysis.","__index_level_0__":5891}
+{"text":"```python\nfrom torchtext.datasets.text_classification import DATASETS\ntrain_dataset, test_dataset = DATASETS['AG_NEWS'](ngrams=2)\n```","__index_level_0__":5892}
+{"text":"In addition to the domain library, PyTorch provides many tools to make data loading easy. Users now can load and preprocess the text classification datasets with some well supported tools, like [torch.utils.data.DataLoader](https:\/\/pytorch.org\/docs\/stable\/_modules\/torch\/utils\/data\/dataloader.html) and [torch.utils.data.IterableDataset](https:\/\/pytorch.org\/docs\/master\/data.html#torch.utils.data.IterableDataset). Here are a few lines to wrap the data with DataLoader. More examples can be found [here](https:\/\/github.com\/pytorch\/text\/tree\/master\/examples\/text_classification).","__index_level_0__":5893}
+{"text":"```python\nfrom torch.utils.data import DataLoader\ndata = DataLoader(train_dataset, collate_fn=generate_batch)\n```","__index_level_0__":5894}
+{"text":"Check out the release notes [here](https:\/\/github.com\/pytorch\/text\/releases) to learn more and try out the [tutorial here](http:\/\/pytorch.org\/tutorials\/beginner\/text_sentiment_ngrams_tutorial.html).","__index_level_0__":5895}
+{"text":"## Torchvision 0.4 with Support for Video","__index_level_0__":5896}
+{"text":"Video is now a first-class citizen in torchvision, with support for data loading, datasets, pre-trained models, and transforms. The 0.4 release of torchvision includes:","__index_level_0__":5897}
+{"text":"* Efficient IO primitives for reading\/writing video files (including audio), with support for arbitrary encodings and formats.\n* Standard video datasets, compatible with `torch.utils.data.Dataset` and `torch.utils.data.DataLoader`.\n* Pre-trained models built on the Kinetics-400 dataset for action classification on videos (including the training scripts).\n* Reference training scripts for training your own video models.","__index_level_0__":5898}
+{"text":"We wanted working with video data in PyTorch to be as straightforward as possible, without compromising too much on performance.\nAs such, we avoid the steps that would require re-encoding the videos beforehand, as it would involve:","__index_level_0__":5899}
+{"text":"* A preprocessing step which duplicates the dataset in order to re-encode it.\n* An overhead in time and space because this re-encoding is time-consuming.\n* Generally, an external script should be used to perform the re-encoding.","__index_level_0__":5900}
+{"text":"Additionally, we provide APIs such as the utility class, `VideoClips`, that simplifies the task of enumerating all possible clips of fixed size in a list of video files by creating an index of all clips in a set of videos. It also allows you to specify a fixed frame-rate for the videos. An example of the API is provided below:","__index_level_0__":5901}
+{"text":"```python\nfrom torchvision.datasets.video_utils import VideoClips","__index_level_0__":5902}
+{"text":"class MyVideoDataset(object):\n    def __init__(self, video_paths):\n        self.video_clips = VideoClips(video_paths,\n                                      clip_length_in_frames=16,\n                                      frames_between_clips=1,\n                                      frame_rate=15)","__index_level_0__":5903}
+{"text":"    def __getitem__(self, idx):\n        video, audio, info, video_idx = self.video_clips.get_clip(idx)\n        return video, audio","__index_level_0__":5904}
+{"text":"    def __len__(self):\n        return self.video_clips.num_clips()\n```","__index_level_0__":5905}
+{"text":"Most of the user-facing API is in Python, similar to PyTorch, which makes it easily extensible. Plus, the underlying implementation is fast \u2014 torchvision decodes as little as possible from the video on-the-fly in order to return a clip from the video.","__index_level_0__":5906}
+{"text":"Check out the torchvision 0.4 [release notes here](https:\/\/github.com\/pytorch\/vision\/releases) for more details.","__index_level_0__":5907}
+{"text":"We look forward to continuing our collaboration with the community and hearing your feedback as we further improve and expand the PyTorch deep learning platform.","__index_level_0__":5908}
+{"text":"*We\u2019d like to thank the entire PyTorch team and the community for all of the contributions to this work!*\n \n source: https:\/\/pytorch.org\/blog\/pytorch-1.2-and-domain-api-release\/ \n category: pytorch blogs","__index_level_0__":5909}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'How to Train State-Of-The-Art Models Using TorchVision\u2019s Latest Primitives'\nauthor: Vasilis Vryniotis\nfeatured-img: 'assets\/images\/fx-image2.png'\n---","__index_level_0__":5910}
+{"text":"<style type=\"text\/css\">\narticle.pytorch-article table tr th, article.pytorch-article table td {line-height: 1.5rem}\n<\/style>","__index_level_0__":5911}
+{"text":"A few weeks ago, TorchVision v0.11 was released packed with numerous new primitives, models and training recipe improvements which allowed achieving state-of-the-art (SOTA) results. The project was dubbed \u201c[TorchVision with Batteries Included](https:\/\/github.com\/pytorch\/vision\/issues\/3911)\u201d and aimed to modernize our library. We wanted to enable researchers to reproduce papers and conduct research more easily by using common building blocks. Moreover, we aspired to provide the necessary tools to Applied ML practitioners to train their models on their own data using the same SOTA techniques as in research. Finally, we wanted to refresh our pre-trained weights and offer\u00a0better off-the-shelf models to our users, hoping that they would build better applications.","__index_level_0__":5912}
+{"text":"Though there is still much work to be done, we wanted to share with you some exciting results from the above work. We will showcase how one can use the new tools included in TorchVision to achieve state-of-the-art results on a highly competitive and well-studied architecture such as ResNet50 [[1]](https:\/\/arxiv.org\/abs\/1512.03385). We will share the exact recipe used to improve our baseline by over 4.7 accuracy points to reach a final top-1 accuracy of 80.9% and share the journey for deriving the new training process. Moreover, we will show that this recipe generalizes well to other model variants and families. We hope that the above will influence future research for developing stronger generalizable training methodologies and will inspire the community to adopt and contribute to our efforts.","__index_level_0__":5913}
+{"text":"## The Results","__index_level_0__":5914}
+{"text":"Using our new training recipe found on ResNet50, we\u2019ve refreshed the pre-trained weights of the following models:","__index_level_0__":5915}
+{"text":"\n| Model    | Accuracy@1 | Accuracy@5| \n|----------|:--------:|:----------:|\n| ResNet50    | 80.858 | 95.434| \n|----------|:--------:|:----------:|\n| ResNet101    | 81.886 | 95.780| \n|----------|:--------:|:----------:|\n| ResNet152    | 82.284 | 96.002| \n|----------|:--------:|:----------:|\n| ResNeXt50-32x4d    | 81.198 | 95.340| ","__index_level_0__":5916}
+{"text":"Note that the accuracy of all models except RetNet50 can be further improved by adjusting their training parameters slightly, but our focus was to have a single robust recipe which performs well for all. ","__index_level_0__":5917}
+{"text":"**UPDATE:** We have refreshed the majority of popular classification models of TorchVision, you can find the details on this [blog post](https:\/\/pytorch.org\/blog\/introducing-torchvision-new-multi-weight-support-api\/).","__index_level_0__":5918}
+{"text":"There are currently two ways to use the latest weights of the model.","__index_level_0__":5919}
+{"text":"## Using the Multi-pretrained weight API","__index_level_0__":5920}
+{"text":"We are currently working on a new prototype mechanism which will extend the model builder methods of TorchVision to [support multiple weights](https:\/\/github.com\/pytorch\/vision\/issues\/4611). Along with the weights, we store useful [meta-data](https:\/\/github.com\/pytorch\/vision\/blob\/c5fb79f8fad60511c89957c4970cc2a5cfc8432e\/torchvision\/prototype\/models\/resnet.py#L94-L103) (such as the labels, the accuracy, links to recipe etc) and the preprocessing transforms necessary for using the models. Example:","__index_level_0__":5921}
+{"text":"```python\n  from PIL import Image\n  from torchvision import prototype as P\n  img = Image.open(\"test\/assets\/encode_jpeg\/grace_hopper_517x606.jpg\")\n  \u00a0\n  # Initialize model\n  weights = P.models.ResNet50_Weights.IMAGENET1K_V2\n  model = P.models.resnet50(weights=weights)\n  model.eval()","__index_level_0__":5922}
+{"text":"  # Initialize inference transforms\n  preprocess = weights.transforms()\n  \u00a0\n  # Apply inference preprocessing transforms\n  batch = preprocess(img).unsqueeze(0)\n  prediction = model(batch).squeeze(0).softmax(0)\n  \u00a0\n  # Make predictions\n  label = prediction.argmax().item()\n  score = prediction[label].item()\n  \u00a0\n  # Use meta to get the labels\n  category_name = weights.meta['categories'][label]\n  print(f\"{category_name}: {100 * score}%\")\n```","__index_level_0__":5923}
+{"text":"## Using the legacy API","__index_level_0__":5924}
+{"text":"Those who don\u2019t want to use a prototype API have the option of accessing the new weights via the legacy API using the following approach:","__index_level_0__":5925}
+{"text":"```python\n  from torchvision.models import resnet\n  \u00a0\n  # Overwrite the URL of the previous weights\n  resnet.model_urls[\"resnet50\"] = \"https:\/\/download.pytorch.org\/models\/resnet50-11ad3fa6.pth\"\n  \u00a0\n  # Initialize the model using the legacy API\n  model = resnet.resnet50(pretrained=True)\n  \u00a0\n  # TODO: Apply preprocessing + call the model\n  # ...\n```","__index_level_0__":5926}
+{"text":"## The Training Recipe","__index_level_0__":5927}
+{"text":"Our goal was to use the newly introduced primitives of TorchVision to derive a new strong training recipe which achieves state-of-the-art results for the vanilla ResNet50 architecture when trained from scratch on ImageNet with no additional external data. Though by using architecture specific tricks\u00a0[[2]](https:\/\/arxiv.org\/abs\/1812.01187) one could further improve the accuracy, we\u2019ve decided not to include them so that the recipe can be used in other architectures. Our recipe\u00a0heavily focuses on simplicity and builds upon work by FAIR [[3]](https:\/\/arxiv.org\/abs\/2103.06877), [[4]](https:\/\/arxiv.org\/abs\/2106.14881), [[5]](https:\/\/arxiv.org\/abs\/1906.06423), [[6]](https:\/\/arxiv.org\/abs\/2012.12877), [[7]](https:\/\/arxiv.org\/abs\/2110.00476).\u00a0Our findings align with the\u00a0parallel study of Wightman et al. [[7]](https:\/\/arxiv.org\/abs\/2110.00476), who also report major accuracy improvements by focusing on the training recipes.","__index_level_0__":5928}
+{"text":"Without further ado, here are the main parameters of our recipe:","__index_level_0__":5929}
+{"text":"```python\n  # Optimizer & LR scheme\n  ngpus=8,\n  batch_size=128,\u00a0 # per GPU","__index_level_0__":5930}
+{"text":"  epochs=600, \n  opt='sgd', \u00a0\n  momentum=0.9,","__index_level_0__":5931}
+{"text":"  lr=0.5, \n  lr_scheduler='cosineannealinglr', \n  lr_warmup_epochs=5, \n  lr_warmup_method='linear', \n  lr_warmup_decay=0.01, ","__index_level_0__":5932}
+{"text":"\n  # Regularization and Augmentation\n  weight_decay=2e-05, \n  norm_weight_decay=0.0,","__index_level_0__":5933}
+{"text":"  label_smoothing=0.1, \n  mixup_alpha=0.2, \n  cutmix_alpha=1.0, \n  auto_augment='ta_wide', \n  random_erase=0.1, \n  \n  ra_sampler=True,\n  ra_reps=4,","__index_level_0__":5934}
+{"text":"\n  # EMA configuration\n  model_ema=True, \n  model_ema_steps=32, \n  model_ema_decay=0.99998, ","__index_level_0__":5935}
+{"text":"\n  # Resizing\n  interpolation='bilinear', \n  val_resize_size=232, \n  val_crop_size=224, \n  train_crop_size=176,\n```","__index_level_0__":5936}
+{"text":"Using our standard [training reference script](https:\/\/github.com\/pytorch\/vision\/tree\/main\/references\/classification), we can train a ResNet50 using the following command:","__index_level_0__":5937}
+{"text":"```\ntorchrun --nproc_per_node=8 train.py --model resnet50 --batch-size 128 --lr 0.5 \\\n--lr-scheduler cosineannealinglr --lr-warmup-epochs 5 --lr-warmup-method linear \\\n--auto-augment ta_wide --epochs 600 --random-erase 0.1 --weight-decay 0.00002\u00a0\\\n--norm-weight-decay 0.0 --label-smoothing 0.1 --mixup-alpha 0.2 --cutmix-alpha 1.0\u00a0\\\n--train-crop-size 176 --model-ema --val-resize-size 232 --ra-sampler --ra-reps 4\n```","__index_level_0__":5938}
+{"text":"## Methodology","__index_level_0__":5939}
+{"text":"There are a few principles we kept in mind during our explorations:","__index_level_0__":5940}
+{"text":"1. Training is a stochastic process and the validation metric we try to optimize is a random variable. This is due to the random weight initialization scheme employed and the existence of random effects during the training process. This means that we can\u2019t do a single run to assess the effect of a recipe change. The standard practice is doing multiple runs (usually 3 to 5) and studying the summarization stats (such as mean, std, median, max, etc).\n2. There is usually a significant interaction between different parameters, especially for techniques that focus on Regularization and reducing overfitting. Thus changing the value of one can have effects on the optimal configurations of others. To account for that one can either adopt a greedy search approach (which often leads to suboptimal results but tractable experiments) or apply grid search (which leads to better results but is computationally expensive). In this work, we used a mixture of both.\n3. Techniques that are non-deterministic or introduce noise usually require longer training cycles to improve model performance. To keep things tractable, we initially used short training cycles (small number of epochs) to decide which paths can be eliminated early and which should be explored using longer training.\n4. There is a risk of overfitting the validation dataset [[8]](https:\/\/arxiv.org\/abs\/1902.10811) because of the repeated experiments. To mitigate some of the risk, we apply only training optimizations that provide a significant accuracy improvements and use K-fold cross validation to verify optimizations done on the validation set. Moreover we confirm that our recipe ingredients generalize well on other models for which we didn\u2019t optimize the hyper-parameters.","__index_level_0__":5941}
+{"text":"## Break down of key accuracy improvements","__index_level_0__":5942}
+{"text":"As discussed in\u00a0[earlier blogposts](https:\/\/pytorch.org\/blog\/torchvision-ssdlite-implementation\/#break-down-of-key-accuracy-improvements), training models is not a journey of monotonically increasing accuracies and the process involves a lot of backtracking. To quantify the effect of each optimization, below we attempt to show-case an idealized linear journey of deriving the final recipe starting from the original recipe of TorchVision. We would like to clarify that this is an oversimplification of the actual path we followed and thus it should be taken with a grain of salt.\u00a0","__index_level_0__":5943}
+{"text":"<p align=\"center\">\n<img src=\"\/assets\/images\/sota\/Cumulative Accuracy Improvements for ResNet50.png\" alt=\"Cumulative Accuracy Improvements for ResNet50\" width=\"100%\">\n<\/p>","__index_level_0__":5944}
+{"text":"In the table below, we provide a summary of the performance of stacked incremental improvements on top of Baseline. Unless denoted otherwise, we report the model with best Acc@1 out of 3 runs:","__index_level_0__":5945}
+{"text":"\n|          | Accuracy@1 | Accuracy@5| Incremental Diff|Absolute Diff|\n|----------|:--------:|:----------:|:---------|:--------:|\n| ResNet50 Baseline    |76.130 | 92.862| 0.000|0.000|\n|----------|:--------:|:----------:|:---------|:--------:|\n| + LR optimizations    | 76.494 |93.198| 0.364|0.364\n|----------|:--------:|:----------:|:---------|:--------:|\n| + TrivialAugment    | 76.806| 93.272|0.312| 0.676|\n|----------|:--------:|:----------:|:---------|:--------:|\n| + Long Training    | 78.606| 94.052| 1.800|2.476|\n|----------|:--------:|:----------:|:---------|:--------:|\n| + Random Erasing    | 78.796 | 94.094|0.190|2.666\n|----------|:--------:|:----------:|:---------|:--------:|\n| + Label Smoothing    |79.114| 94.374| 0.318|2.984|\n|----------|:--------:|:----------:|:---------|:--------:|\n| + Mixup    | 79.232| 94.536| 0.118|3.102|\n|----------|:--------:|:----------:|:---------|:--------:|\n| + Cutmix    |79.510| 94.642| 0.278|3.380|\n|----------|:--------:|:----------:|:---------|:--------:|\n| + Weight Decay tuning    |80.036|94.746| 0.526|3.906|\n|----------|:--------:|:----------:|:---------|:--------:|\n| + FixRes mitigations   |80.196|94.672| 0.160|4.066|\n|----------|:--------:|:----------:|:---------|:--------:|\n|+ EMA   |80.450|94.908| 0.254|4.320|\n|----------|:--------:|:----------:|:---------|:--------:|\n| + Inference Resize tuning *   |80.674|95.166| 0.224|4.544|\n|----------|:--------:|:----------:|:---------|:--------:|\n| + Repeated Augmentation **  |80.858|95.434| 0.184|4.728|","__index_level_0__":5946}
+{"text":"*The tuning of the inference size was done on top of the last model. See below for details.","__index_level_0__":5947}
+{"text":"** Community contribution done after the release of the article. See below for details.","__index_level_0__":5948}
+{"text":"## Baseline","__index_level_0__":5949}
+{"text":"Our baseline is the previously released ResNet50 model of TorchVision. It was trained with the following recipe:","__index_level_0__":5950}
+{"text":"```python \n  # Optimizer & LR scheme\n  ngpus=8,\n  batch_size=32,\u00a0 # per GPU","__index_level_0__":5951}
+{"text":"  epochs=90, \n  opt='sgd', \u00a0\n  momentum=0.9,","__index_level_0__":5952}
+{"text":"  lr=0.1, \n  lr_scheduler='steplr', \n  lr_step_size=30, \n  lr_gamma=0.1, ","__index_level_0__":5953}
+{"text":"\n  # Regularization\n  weight_decay=1e-4,","__index_level_0__":5954}
+{"text":"\n  # Resizing\n  interpolation='bilinear', \n  val_resize_size=256, \n  val_crop_size=224, \n  train_crop_size=224,\n```","__index_level_0__":5955}
+{"text":"Most of the above parameters are the defaults on our [training scripts](https:\/\/github.com\/pytorch\/vision\/tree\/main\/references\/classification). We will start building on top of this baseline by introducing optimizations until we gradually arrive at the final recipe.","__index_level_0__":5956}
+{"text":"## LR optimizations","__index_level_0__":5957}
+{"text":"There are a few parameter updates we can apply to improve both the accuracy and the speed of our training. This can be achieved by increasing the batch size and tuning the LR. Another common method is to apply warmup and gradually increase our learning rate. This is beneficial especially when we use very high learning rates and helps with the stability of the training in the early epochs. Finally, another optimization is to apply Cosine Schedule to adjust our LR during the epochs. A big advantage of cosine is that there are no hyper-parameters to optimize, which cuts down our search space.","__index_level_0__":5958}
+{"text":"Here are the additional optimizations applied on top of the baseline recipe. Note that we\u2019ve run multiple experiments to determine the optimal configuration of the parameters:","__index_level_0__":5959}
+{"text":"```python\n  batch_size=128,\u00a0 # per GPU","__index_level_0__":5960}
+{"text":"  lr=0.5, \n  lr_scheduler='cosineannealinglr', \n  lr_warmup_epochs=5, \n  lr_warmup_method='linear', \n  lr_warmup_decay=0.01,\n```","__index_level_0__":5961}
+{"text":"The above optimizations increase our top-1 Accuracy by 0.364 points comparing to the baseline. Note that in order to combine the different LR strategies we use the newly introduced [SequentialLR](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.optim.lr_scheduler.SequentialLR.html#torch.optim.lr_scheduler.SequentialLR) scheduler.","__index_level_0__":5962}
+{"text":"## TrivialAugment","__index_level_0__":5963}
+{"text":"The original model was trained using basic augmentation transforms such as Random resized crops and horizontal flips. An easy way to improve our accuracy is to apply more complex \u201cAutomatic-Augmentation\u201d techniques. The one that performed best for us is TrivialAugment\u00a0[[9]](https:\/\/arxiv.org\/abs\/2103.10158), which\u00a0is extremely simple and can be considered \u201cparameter free\u201d, which means it can help us cut down our search space further.","__index_level_0__":5964}
+{"text":"Here is the update applied on top of the previous step:","__index_level_0__":5965}
+{"text":"```\nauto_augment='ta_wide',\n```","__index_level_0__":5966}
+{"text":"The use of TrivialAugment increased our top-1 Accuracy by\u00a00.312 points\u00a0compared to the previous step.","__index_level_0__":5967}
+{"text":"## Long Training","__index_level_0__":5968}
+{"text":"Longer training cycles are beneficial when our recipe contains ingredients that behave randomly. More specifically as we start adding more and more techniques that introduce noise, increasing the number of epochs becomes crucial. Note that at early stages of our exploration, we used relatively short cycles of roughly 200 epochs which was later increased to 400 as we started narrowing down most of the parameters and finally increased to 600 epochs at the final versions of the recipe.","__index_level_0__":5969}
+{"text":"Below we see the update applied on top of the earlier steps:","__index_level_0__":5970}
+{"text":"```\nepochs=600,\n```","__index_level_0__":5971}
+{"text":"This further increases our top-1 Accuracy by 1.8 points on top of the previous step. This is the biggest increase we will observe in this iterative process. It\u2019s worth noting that the effect of this single optimization is overstated and somehow misleading. Just increasing the number of epochs on top of the old baseline won\u2019t yield such significant improvements. Nevertheless the combination of the LR optimizations with strong Augmentation strategies helps the model benefit from longer cycles. It\u2019s also worth mentioning that the reason we introduce the lengthy training cycles so early in the process is because in the next steps we will introduce techniques that\u00a0require significantly more epochs to provide good results.","__index_level_0__":5972}
+{"text":"## Random Erasing","__index_level_0__":5973}
+{"text":"Another data augmentation technique known to help the classification accuracy is Random Erasing [[10]](https:\/\/arxiv.org\/abs\/1708.04896), [[11]](https:\/\/arxiv.org\/abs\/1708.04552). Often paired with Automatic Augmentation methods, it usually yields additional improvements in accuracy due to its regularization effect. In our experiments we tuned only the probability of applying the method via a grid search and found that it\u2019s beneficial to keep its probability at low levels, typically around 10%.\u00a0","__index_level_0__":5974}
+{"text":"Here is the extra parameter introduced on top of the previous:","__index_level_0__":5975}
+{"text":"```\nrandom_erase=0.1,\n```","__index_level_0__":5976}
+{"text":"Applying Random Erasing increases our Acc@1 by further\u00a00.190 points.","__index_level_0__":5977}
+{"text":"## Label Smoothing","__index_level_0__":5978}
+{"text":"A good technique to reduce overfitting is to stop the model from becoming overconfident. This can be achieved by softening the ground truth using Label Smoothing\u00a0[[12]](https:\/\/www.cv-foundation.org\/openaccess\/content_cvpr_2016\/papers\/Szegedy_Rethinking_the_Inception_CVPR_2016_paper.pdf). There is a single parameter which controls the degree of smoothing (the higher the stronger) that we need to specify. Though optimizing it via grid search is possible, we found that values around 0.05-0.15 yield similar results, so to avoid overfitting it we used the same value as on the\u00a0paper that introduced it.","__index_level_0__":5979}
+{"text":"Below we can find the extra config added on this step:","__index_level_0__":5980}
+{"text":"```\nlabel_smoothing=0.1,\n```","__index_level_0__":5981}
+{"text":"We use PyTorch\u2019s newly introduced\u00a0[CrossEntropyLoss](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.CrossEntropyLoss.html?highlight=label_smoothing) label_smoothing parameter and that increases our accuracy by an additional\u00a00.318 points.","__index_level_0__":5982}
+{"text":"## Mixup and Cutmix","__index_level_0__":5983}
+{"text":"Two data augmentation techniques often used to produce SOTA results are Mixup and Cutmix\u00a0[[13]](https:\/\/arxiv.org\/abs\/1710.09412), [[14]](https:\/\/arxiv.org\/abs\/1905.04899). They both provide strong regularization effects by softening not only the labels but also the images. In our setup we found it beneficial to apply one of them randomly with equal probability. Each is parameterized with a\u00a0hyperparameter alpha, which controls the shape of the Beta distribution from which the smoothing probability is sampled. We did a very limited grid search, focusing primarily on common values proposed on the papers.\u00a0","__index_level_0__":5984}
+{"text":"Below you will find the optimal values for the alpha parameters of the two techniques:","__index_level_0__":5985}
+{"text":"```\nmixup_alpha=0.2, \ncutmix_alpha=1.0,\n```","__index_level_0__":5986}
+{"text":"Applying mixup increases our accuracy by\u00a00.118 points and combining it with cutmix improves it by additional 0.278 points.","__index_level_0__":5987}
+{"text":"## Weight Decay tuning","__index_level_0__":5988}
+{"text":"Our standard recipe uses L2 regularization to reduce overfitting. The Weight Decay parameter controls the degree of the regularization (the larger the stronger) and is applied universally to all learned parameters of the model by default. In this recipe, we apply two optimizations to the standard approach. First we perform grid search to tune the parameter of weight decay and second we disable weight decay for the parameters of the normalization layers.\u00a0","__index_level_0__":5989}
+{"text":"Below you can find the optimal configuration of weight decay for our recipe:","__index_level_0__":5990}
+{"text":"```\nweight_decay=2e-05, \nnorm_weight_decay=0.0,\n```","__index_level_0__":5991}
+{"text":"The above update improves our accuracy by a further\u00a00.526 points, providing additional experimental evidence for a known fact that tuning weight decay has significant effects on the performance of the model. Our approach for separating the Normalization parameters from the rest was inspired by\u00a0[ClassyVision\u2019s](https:\/\/github.com\/facebookresearch\/ClassyVision) approach.","__index_level_0__":5992}
+{"text":"## FixRes mitigations","__index_level_0__":5993}
+{"text":"An important property identified early in our experiments is the fact that the models performed significantly better if the resolution used during validation was increased from the 224x224 of training. This effect is studied in detail on the FixRes paper [[5]](https:\/\/arxiv.org\/abs\/1906.06423)\u00a0and two mitigations are proposed: a) one could try to reduce the training resolution so that the accuracy on the validation resolution is maximized or b) one could fine-tune the model on a two-phase training so that it adjusts on the target resolution. Since we didn\u2019t want to introduce a 2-phase training, we went for option a). This means that we reduced the train crop size from 224 and used grid search to find the one that maximizes the validation on resolution of 224x224.","__index_level_0__":5994}
+{"text":"Below you can see the optimal value used on our recipe:","__index_level_0__":5995}
+{"text":"```\nval_crop_size=224, \ntrain_crop_size=176,\n```","__index_level_0__":5996}
+{"text":"The above optimization improved our accuracy by an additional 0.160 points and sped up our training by 10%.\u00a0","__index_level_0__":5997}
+{"text":"It\u2019s worth noting that the FixRes effect still persists, meaning that the model continues to perform better on validation when we increase the resolution. Moreover, further reducing the training crop-size actually hurts the accuracy. This intuitively makes sense because one can only reduce the resolution so much before critical details start disappearing from the picture. Finally, we should note that the above FixRes mitigation seems to benefit models with similar depth to ResNet50. Deeper variants with larger receptive fields seem to be slightly negatively affected (typically by 0.1-0.2 points). Hence we consider this part of the recipe optional. Below we visualize the performance of the best available checkpoints (with the full recipe) for models trained with 176 and 224 resolution:","__index_level_0__":5998}
+{"text":"<div style=\"display: flex\">\n<img src=\"\/assets\/images\/sota\/Best ResNet50 trained with 176 Resolution.png\" alt=\"Best ResNet50 trained with 176 Resolution\" width=\"50%\">\n<img src=\"\/assets\/images\/sota\/Best ResNet50 trained with 224 Resolution.png\" alt=\"Best ResNet50 trained with 224 Resolution\" width=\"50%\">\n<\/div>","__index_level_0__":5999}
+{"text":"## Exponential Moving Average (EMA)","__index_level_0__":6000}
+{"text":"EMA is a technique that allows one to push the accuracy of a model without increasing its complexity or inference time. It performs an exponential moving average on the model weights and this leads to increased accuracy and more stable models. The averaging happens every few iterations and its decay parameter was tuned via grid search.\u00a0","__index_level_0__":6001}
+{"text":"Below you can see the optimal values for our recipe:","__index_level_0__":6002}
+{"text":"```\nmodel_ema=True, \nmodel_ema_steps=32, \nmodel_ema_decay=0.99998,\n```","__index_level_0__":6003}
+{"text":"The use of EMA increases our accuracy by\u00a00.254 points comparing to the previous step. Note that TorchVision\u2019s\u00a0[EMA implementation](https:\/\/github.com\/pytorch\/vision\/pull\/4406) is build on top of PyTorch\u2019s [AveragedModel](https:\/\/pytorch.org\/docs\/stable\/optim.html#stochastic-weight-averaging) class with the key difference being that it averages not only the model parameters but also its buffers. Moreover, we have adopted tricks from\u00a0[Pycls](https:\/\/github.com\/facebookresearch\/pycls\/tree\/main\/pycls)\u00a0which allow us to parameterize the decay in a way that doesn\u2019t depend on the number of epochs.","__index_level_0__":6004}
+{"text":"## Inference Resize tuning","__index_level_0__":6005}
+{"text":"Unlike all other steps of the process which involved training models with different parameters, this optimization was done on top of the final model. During inference, the image is resized to a specific resolution and then a central 224x224 crop is taken from it. The original recipe used a resize size of 256, which caused a similar discrepancy as the one described on the FixRes paper [[5]](https:\/\/arxiv.org\/abs\/1906.06423). By bringing this resize value closer to the target inference resolution, one can improve the accuracy. To select the value we run a short grid search between interval [224, 256] with step of 8. To avoid overfitting, the value was selected using half of the validation set and confirmed using the other half.","__index_level_0__":6006}
+{"text":"Below you can see the optimal value used on our recipe:","__index_level_0__":6007}
+{"text":"```\nval_resize_size=232,\n```","__index_level_0__":6008}
+{"text":"The above is an optimization which improved our accuracy by\u00a00.224 points.\u00a0It\u2019s worth noting that the optimal value for ResNet50 works also best for ResNet101, ResNet152 and ResNeXt50, which hints that it generalizes across models:","__index_level_0__":6009}
+{"text":"\n<div style=\"display: flex\">\n<img src=\"\/assets\/images\/sota\/ResNet50 Inference Resize.png\" alt=\"ResNet50 Inference Resize\" width=\"30%\">\n<img src=\"\/assets\/images\/sota\/ResNet101 Inference Resize.png\" alt=\"ResNet101 Inference Resize\" width=\"30%\">\n<img src=\"\/assets\/images\/sota\/ResNet152 Inference Resize.png\" alt=\"Best ResNet50 trained with 224 Resolution\" width=\"30%\">\n<\/div>","__index_level_0__":6010}
+{"text":"## [UPDATE] Repeated Augmentation","__index_level_0__":6011}
+{"text":"Repeated Augmentation [[15]](https:\/\/arxiv.org\/abs\/1901.09335), [[16]](https:\/\/arxiv.org\/abs\/1902.05509) is another technique which can improve the overall accuracy and has been used by other strong recipes such as those at [[6]](https:\/\/arxiv.org\/abs\/2012.12877), [[7]](https:\/\/arxiv.org\/abs\/2110.00476). Tal Ben-Nun, a community contributor, has [further improved](https:\/\/github.com\/pytorch\/vision\/pull\/5201) upon our original recipe by proposing training the model with 4 repetitions. His contribution came after the release of this article.","__index_level_0__":6012}
+{"text":"Below you can see the optimal value used on our recipe:","__index_level_0__":6013}
+{"text":"```\nra_sampler=True,\nra_reps=4,\n```","__index_level_0__":6014}
+{"text":"The above is the final optimization which improved our accuracy by\u00a00.184 points.\u00a0","__index_level_0__":6015}
+{"text":"## Optimizations that were tested but not adopted","__index_level_0__":6016}
+{"text":"During the early stages of our research, we experimented with additional techniques, configurations and optimizations. Since our target was to keep our recipe as simple as possible, we decided not to include anything that didn\u2019t provide a significant improvement. Here are a few approaches that we took but didn\u2019t make it to our final recipe:","__index_level_0__":6017}
+{"text":"- **Optimizers:** Using more complex optimizers such as Adam, RMSProp or SGD with Nesterov momentum didn\u2019t\u00a0provide significantly better results than vanilla SGD with momentum.\n- **LR Schedulers:**\u00a0We tried different LR Scheduler schemes such as StepLR and Exponential. Though the latter tends to work better with EMA, it often requires additional hyper-parameters such as defining the minimum LR to work well. Instead, we just use cosine annealing decaying the LR up to zero and choose the checkpoint with the highest accuracy.\n- **Automatic Augmentations:**\u00a0We\u2019ve tried different augmentation strategies such as AutoAugment and RandAugment. None of these outperformed the simpler parameter-free TrivialAugment.\n- **Interpolation:** Using bicubic or nearest interpolation didn\u2019t\u00a0provide significantly better results than bilinear.\n- **Normalization layers:** Using Sync Batch Norm didn\u2019t yield\u00a0significantly better results than using the regular Batch Norm.","__index_level_0__":6018}
+{"text":"## Acknowledgements","__index_level_0__":6019}
+{"text":"We would like to thank\u00a0Piotr Dollar, Mannat Singh and Hugo Touvron for providing their insights and feedback during the development of the recipe and for their previous research work on which our recipe is based on. Their support was invaluable for achieving the above result. Moreover, we would like to thank\u00a0Prabhat Roy, Kai Zhang, Yiwen Song, Joel Schlosser, Ilqar Ramazanli, Francisco Massa, Mannat Singh, Xiaoliang Dai, Samuel Gabriel, Allen Goodman and Tal Ben-Nun for their contributions to the Batteries Included project.","__index_level_0__":6020}
+{"text":"## References","__index_level_0__":6021}
+{"text":"1. Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun. \u201cDeep Residual Learning for Image Recognition\u201d.\n2. Tong He, Zhi Zhang, Hang Zhang, Zhongyue Zhang, Junyuan Xie, Mu Li. \u201cBag of Tricks for Image Classification with Convolutional Neural Networks\u201d\n3. Piotr Doll\u00e1r, Mannat Singh, Ross Girshick. \u201cFast and Accurate Model Scaling\u201d\n4. Tete Xiao, Mannat Singh, Eric Mintun, Trevor Darrell, Piotr Doll\u00e1r, Ross Girshick. \u201cEarly Convolutions Help Transformers See Better\u201d\n5. Hugo Touvron, Andrea Vedaldi, Matthijs Douze, Herv\u00e9 J\u00e9gou. \u201cFixing the train-test resolution discrepancy\n6. Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, Herv\u00e9 J\u00e9gou. \u201cTraining data-efficient image transformers & distillation through attention\u201d\n7. Ross Wightman, Hugo Touvron, Herv\u00e9 J\u00e9gou. \u201cResNet strikes back: An improved training procedure in timm\u201d\n8. Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, Vaishaal Shankar. \u201cDo ImageNet Classifiers Generalize to ImageNet?\u201d\n9. Samuel G. M\u00fcller, Frank Hutter. \u201cTrivialAugment: Tuning-free Yet State-of-the-Art Data Augmentation\u201d\n10. Zhun Zhong, Liang Zheng, Guoliang Kang, Shaozi Li, Yi Yang. \u201cRandom Erasing Data Augmentation\u201d\n11. Terrance DeVries, Graham W. Taylor. \u201cImproved Regularization of Convolutional Neural Networks with Cutout\u201d\n12. Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, Zbigniew Wojna. \u201cRethinking the Inception Architecture for Computer Vision\u201d\n13. Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, David Lopez-Paz. \u201cmixup: Beyond Empirical Risk Minimization\u201d\n14. Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, Youngjoon Yoo. \u201cCutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features\u201d\n15. Elad Hoffer, Tal Ben-Nun, Itay Hubara, Niv Giladi, Torsten Hoefler, Daniel Soudry. \u201cAugment your batch: better training with larger batches\u201d\n16. Maxim Berman, Herv\u00e9 J\u00e9gou, Andrea Vedaldi, Iasonas Kokkinos, Matthijs Douze. \u201cMultigrain: a unified image embedding for classes and instances\u201d\n \n source: https:\/\/pytorch.org\/blog\/how-to-train-state-of-the-art-models-using-torchvision-latest-primitives\/ \n category: pytorch blogs","__index_level_0__":6022}
+{"text":"text: ---\nlayout: blog_detail\ntitle: 'Updates & Improvements to PyTorch Tutorials'\nauthor: Team PyTorch\n---","__index_level_0__":6023}
+{"text":"PyTorch.org provides researchers and developers with documentation, installation instructions, latest news, community projects, tutorials, and more. Today, we are introducing usability and content improvements including tutorials in additional categories, a new recipe format for quickly referencing common topics, sorting using tags, and an updated homepage. ","__index_level_0__":6024}
+{"text":"Let\u2019s take a look at them in detail. ","__index_level_0__":6025}
+{"text":"## TUTORIALS HOME PAGE UPDATE\nThe tutorials home page now provides clear actions that developers can take. For new PyTorch users, there is an easy-to-discover button to take them directly to \u201cA 60 Minute Blitz\u201d. Right next to it, there is a button to view all recipes which are designed to teach specific features quickly with examples. ","__index_level_0__":6026}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/tutorialhomepage.png\" width=\"100%\">\n<\/div>","__index_level_0__":6027}
+{"text":"In addition to the existing left navigation bar, tutorials can now be quickly filtered by multi-select tags. Let\u2019s say you want to view all tutorials related to \u201cProduction\u201d and \u201cQuantization\u201d. You can select the \u201cProduction\u201d and \u201cQuantization\u201d filters as shown in the image shown below:","__index_level_0__":6028}
+{"text":"<div class=\"text-center\">\n  <img src=\"{{ site.url }}\/assets\/images\/blockfiltering.png\" width=\"100%\">\n<\/div>","__index_level_0__":6029}
+{"text":"The following additional resources can also be found at the bottom of the Tutorials homepage:\n* [PyTorch Cheat Sheet](https:\/\/pytorch.org\/tutorials\/beginner\/ptcheat.html)\n* [PyTorch Examples](https:\/\/github.com\/pytorch\/examples)\n* [Tutorial on GitHub](https:\/\/github.com\/pytorch\/tutorials)","__index_level_0__":6030}
+{"text":"## PYTORCH RECIPES  \nRecipes are new bite-sized, actionable examples designed to teach researchers and developers how to use specific PyTorch features. Some notable new recipes include:\n* [Loading Data in PyTorch](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/loading_data_recipe.html)\n* [Model Interpretability Using Captum](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/Captum_Recipe.html)\n* [How to Use TensorBoard](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/tensorboard_with_pytorch.html)","__index_level_0__":6031}
+{"text":"View the full recipes [here](http:\/\/pytorch.org\/tutorials\/recipes\/recipes_index.html).","__index_level_0__":6032}
+{"text":"## LEARNING PYTORCH\nThis section includes tutorials designed for users new to PyTorch. Based on community feedback, we have made updates to the current [Deep Learning with PyTorch: A 60 Minute Blitz](https:\/\/pytorch.org\/tutorials\/beginner\/deep_learning_60min_blitz.html) tutorial, one of our most popular tutorials for beginners. Upon completion, one can understand what PyTorch and neural networks are, and be able to build and train a simple image classification network. Updates include adding explanations to clarify output meanings and linking back to where users can read more in the docs, cleaning up confusing syntax errors, and reconstructing and explaining new concepts for easier readability.  ","__index_level_0__":6033}
+{"text":"## DEPLOYING MODELS IN PRODUCTION\nThis section includes tutorials for developers looking to take their PyTorch models to production. The tutorials include:\n* [Deploying PyTorch in Python via a REST API with Flask](https:\/\/pytorch.org\/tutorials\/intermediate\/flask_rest_api_tutorial.html)\n* [Introduction to TorchScript](https:\/\/pytorch.org\/tutorials\/beginner\/Intro_to_TorchScript_tutorial.html)\n* [Loading a TorchScript Model in C++](https:\/\/pytorch.org\/tutorials\/advanced\/cpp_export.html)\n* [Exporting a Model from PyTorch to ONNX and Running it using ONNX Runtime](https:\/\/pytorch.org\/tutorials\/advanced\/super_resolution_with_onnxruntime.html)","__index_level_0__":6034}
+{"text":"## FRONTEND APIS\nPyTorch provides a number of frontend API features that can help developers to code, debug, and validate their models more efficiently. This section includes tutorials that teach what these features are and how to use them. Some tutorials to highlight: \n* [Introduction to Named Tensors in PyTorch](https:\/\/pytorch.org\/tutorials\/intermediate\/named_tensor_tutorial.html)\n* [Using the PyTorch C++ Frontend](https:\/\/pytorch.org\/tutorials\/advanced\/cpp_frontend.html)\n* [Extending TorchScript with Custom C++ Operators](https:\/\/pytorch.org\/tutorials\/advanced\/torch_script_custom_ops.html)\n* [Extending TorchScript with Custom C++ Classes](https:\/\/pytorch.org\/tutorials\/advanced\/torch_script_custom_classes.html)\n* [Autograd in C++ Frontend](https:\/\/pytorch.org\/tutorials\/advanced\/cpp_autograd.html)","__index_level_0__":6035}
+{"text":"## MODEL OPTIMIZATION\nDeep learning models often consume large amounts of memory, power, and compute due to their complexity. This section provides tutorials for model optimization:\n* [Pruning](https:\/\/pytorch.org\/tutorials\/intermediate\/pruning_tutorial.html)\n* [Dynamic Quantization on BERT](https:\/\/pytorch.org\/tutorials\/intermediate\/dynamic_quantization_bert_tutorial.html)\n* [Static Quantization with Eager Mode in PyTorch](https:\/\/pytorch.org\/tutorials\/advanced\/static_quantization_tutorial.html)","__index_level_0__":6036}
+{"text":"## PARALLEL AND DISTRIBUTED TRAINING\nPyTorch provides features that can accelerate performance in research and production such as native support for asynchronous execution of collective operations and peer-to-peer communication that is accessible from Python and C++. This section includes tutorials on parallel and distributed training: \n* [Single-Machine Model Parallel Best Practices](https:\/\/pytorch.org\/tutorials\/intermediate\/model_parallel_tutorial.html)\n* [Getting started with Distributed Data Parallel](https:\/\/pytorch.org\/tutorials\/intermediate\/ddp_tutorial.html)\n* [Getting started with Distributed RPC Framework](https:\/\/pytorch.org\/tutorials\/intermediate\/rpc_tutorial.html)\n* [Implementing a Parameter Server Using Distributed RPC Framework](https:\/\/pytorch.org\/tutorials\/intermediate\/rpc_param_server_tutorial.html)","__index_level_0__":6037}
+{"text":"Making these improvements are just the first step of improving PyTorch.org for the community. Please submit your suggestions [here](https:\/\/github.com\/pytorch\/tutorials\/pulls).","__index_level_0__":6038}
+{"text":"Team PyTorch\n \n source: https:\/\/pytorch.org\/blog\/updates-improvements-to-pytorch-tutorials\/ \n category: pytorch blogs","__index_level_0__":6040}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"PyTorch 2.0: Our next generation release that is faster, more Pythonic and Dynamic as ever\"\n---","__index_level_0__":6041}
+{"text":"We are excited to announce the release of [PyTorch\u00ae 2.0](https:\/\/github.com\/pytorch\/pytorch\/releases\/tag\/v2.0.0) which we highlighted during the [PyTorch Conference](https:\/\/www.youtube.com\/@PyTorch\/playlists?view=50&sort=dd&shelf_id=2) on 12\/2\/22! PyTorch 2.0 offers the same eager-mode development and user experience, while fundamentally changing and supercharging how PyTorch operates at compiler level under the hood with faster performance and support for Dynamic Shapes and Distributed.","__index_level_0__":6042}
+{"text":"This next-generation release includes a Stable version of Accelerated Transformers (formerly called Better Transformers); Beta includes torch.compile as the main API for PyTorch 2.0,  the scaled_dot_product_attention function as part of torch.nn.functional, the MPS backend, functorch APIs in the torch.func module; and other Beta\/Prototype improvements across various inferences, performance and training optimization features on GPUs and CPUs. For a comprehensive introduction and technical overview of torch.compile, please visit the 2.0 [Get Started page](\/get-started\/pytorch-2.0).","__index_level_0__":6043}
+{"text":"Along with 2.0, we are also releasing a series of beta updates to the PyTorch domain libraries, including those that are in-tree, and separate libraries including TorchAudio, TorchVision, and TorchText. An update for TorchX is also being released as it moves to community supported mode. More details can be found in this [library blog](\/blog\/new-library-updates-in-pytorch-2.0\/). ","__index_level_0__":6044}
+{"text":"This release is composed of over 4,541 commits and 428 contributors since 1.13.1. We want to sincerely thank our dedicated community for your contributions. As always, we encourage you to try these out and report any issues as we improve 2.0 and the overall 2-series this year.","__index_level_0__":6045}
+{"text":"Summary: \n* torch.compile is the main API for PyTorch 2.0, which wraps your model and returns a compiled model. It is a fully additive (and optional) feature and hence 2.0 is 100% backward compatible by definition.\n* As an underpinning technology of torch.compile, TorchInductor with Nvidia and AMD GPUs will rely on OpenAI Triton deep learning compiler to generate performant code and hide low level hardware details. OpenAI Triton-generated kernels achieve performance that's on par with hand-written kernels and specialized cuda libraries such as cublas.\n* Accelerated Transformers introduce high-performance support for training and inference using a custom kernel architecture for scaled dot product attention (SPDA). The API is integrated with torch.compile() and model developers may also use the [scaled dot product attention](#beta-scaled-dot-product-attention-20) kernels directly by calling the new scaled_dot_product_attention() operator. \n* Metal Performance Shaders (MPS) backend provides GPU accelerated PyTorch training on Mac platforms with added support for Top 60 most used ops, bringing coverage to over 300 operators. \n* Amazon AWS optimizes the PyTorch CPU inference on AWS Graviton3 based [C7g instances](https:\/\/aws.amazon.com\/blogs\/aws\/new-amazon-ec2-c7g-instances-powered-by-aws-graviton3-processors\/). PyTorch 2.0 improves inference performance on Graviton compared to the previous releases, including improvements for Resnet50 and Bert. \n* New prototype features and technologies across TensorParallel, DTensor, 2D parallel, TorchDynamo, AOTAutograd, PrimTorch and TorchInductor.","__index_level_0__":6046}
+{"text":"<table class=\"table table-bordered\">\n<thead>\n  <tr>\n   <td scope=\"col\">\n<strong>Stable<\/strong>\n   <\/td>\n   <td scope=\"col\"><strong>Beta<\/strong>\n   <\/td>\n   <td scope=\"col\"><strong>Prototype<\/strong>\n   <\/td>\n   <td scope=\"col\"><strong>Performance Improvements<\/strong>\n   <\/td>\n  <\/tr>\n  <\/thead>\n  <tr>\n   <td>","__index_level_0__":6047}
+{"text":"<a href=\"#stable-features\">Accelerated PT 2 Transformers<\/a>\n   <\/td>\n   <td>","__index_level_0__":6048}
+{"text":"<a href=\"#beta-features\">torch.compile<\/a>\n   <\/td>\n   <td>","__index_level_0__":6049}
+{"text":"<a href=\"#prototype-features\">DTensor<\/a>\n   <\/td>\n   <td>","__index_level_0__":6050}
+{"text":"<a href=\"#deprecation-of-cuda-116-and-python-37-support-for-pytorch-20\">CUDA support for 11.7 & 11.8 (deprecating CUDA 11.6) <\/a>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>\n   <\/td>\n   <td>","__index_level_0__":6051}
+{"text":"<a href=\"#beta-pytorch-mps-backend\">PyTorch MPS Backend<\/a>\n   <\/td>\n   <td>","__index_level_0__":6052}
+{"text":"<a href=\"#prototype-tensorparallel\">TensorParallel<\/a>\n   <\/td>\n   <td> ","__index_level_0__":6053}
+{"text":"<a href=\"#deprecation-of-cuda-116-and-python-37-support-for-pytorch-20\">Python 3.8 (deprecating Python 3.7)<\/a>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>\n   <\/td>\n   <td>","__index_level_0__":6054}
+{"text":"<a href=\"#beta-scaled-dot-product-attention-20\">Scaled dot product attention<\/a>\n   <\/td>\n   <td>","__index_level_0__":6055}
+{"text":"<a href=\"#prototype-2d-parallel\">2D Parallel<\/a>\n   <\/td>\n   <td>","__index_level_0__":6056}
+{"text":"<a href=\"#optimized-pytorch-inference-with-aws-graviton-processors\">AWS Graviton3<\/a>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>\n   <\/td>\n   <td>","__index_level_0__":6057}
+{"text":"<a href=\"#beta-functorch---torchfunc\">functorch<\/a>\n   <\/td>\n   <td rowspan=\"2\" >","__index_level_0__":6058}
+{"text":"<a href=\"#beta-torchcompile\">Torch.compile (dynamic=True)<\/a>\n   <\/td>\n   <td>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>\n   <\/td>\n   <td><a href=\"#beta-dispatchable-collectives\">Dispatchable Collectives<\/a>\n   <\/td>\n   <td>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>\n   <\/td>\n   <td><a href=\"#beta-torchset_default_device-and-torchdevice-as-context-manager\">Torch.set_default & torch.device<\/a>\n   <\/td>\n   <td>\n   <\/td>\n   <td>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>\n   <\/td>\n   <td>","__index_level_0__":6059}
+{"text":"<a href=\"#beta-x86-as-the-new-default-quantization-backend-for-x86-cpu\">X86 quantization backend<\/a>\n   <\/td>\n   <td>\n   <\/td>\n   <td>\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>\n   <\/td>\n   <td>","__index_level_0__":6060}
+{"text":"<a href=\"#beta-gnn-inference-and-training-optimization-on-cpu\">GNN inference and training performance<\/a>\n   <\/td>\n   <td>\n   <\/td>\n   <td>\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":6061}
+{"text":"\n*To see a full list of public 2.0, 1.13 and 1.12 feature submissions click [here](https:\/\/docs.google.com\/spreadsheets\/d\/1H3jazwO8BBCwK8JwLNYspLiHfUrzshEtyqjL-X93I9g\/edit#gid=790902532).","__index_level_0__":6062}
+{"text":"\n## Stable Features","__index_level_0__":6063}
+{"text":"\n### [Stable] Accelerated PyTorch 2 Transformers","__index_level_0__":6064}
+{"text":"The PyTorch 2.0 release includes a new high-performance implementation of the PyTorch Transformer API. In releasing Accelerated PT2 Transformers, our goal is to make training and deployment of state-of-the-art Transformer models affordable across the industry. This release introduces high-performance support for training and inference using a custom kernel architecture for scaled dot product attention (SPDA), extending the inference \u201cfastpath\u201d architecture, previously known as \"Better Transformer.\"","__index_level_0__":6065}
+{"text":"Similar to the \u201cfastpath\u201d architecture, custom kernels are fully integrated into the PyTorch Transformer API \u2013 thus, using the native Transformer and MultiHeadAttention API will enable users to:","__index_level_0__":6066}
+{"text":"* transparently see significant speed improvements;  \n* support many more use cases including models using Cross-Attention, Transformer Decoders, and for training models; and\n* continue to use fastpath inference for fixed and variable sequence length Transformer Encoder and Self Attention use cases.","__index_level_0__":6067}
+{"text":"To take full advantage of different hardware models and Transformer use cases, multiple SDPA custom kernels are supported (see below), with custom kernel selection logic that will pick the highest-performance kernel for a given model and hardware type. In addition to the existing Transformer API, model developers may also use the [scaled dot product attention](#beta-scaled-dot-product-attention-20) kernels directly by calling the new scaled_dot_product_attention() operator. Accelerated PyTorch 2 Transformers are integrated with torch.compile() .  To use your model while benefiting from the additional acceleration of PT2-compilation (for inference or training), pre-process the model with `model = torch.compile(model)`.","__index_level_0__":6068}
+{"text":"We have achieved major speedups for training transformer models and in particular large language models with Accelerated PyTorch 2 Transformers using a combination of custom kernels and torch.compile(). ","__index_level_0__":6069}
+{"text":"![alt_text](\/assets\/images\/pytorch20post.png \"Accelerated PyTorch 2 speed\"){:width=\"100%\"}\n<small style=\"line-height: 1.1\"><em>Figure: Using scaled dot product attention with custom kernels and torch.compile delivers significant speedups for training large language models, such as for [nanoGPT](https:\/\/github.com\/karpathy\/nanoGPT) shown here.<\/em><\/small>","__index_level_0__":6070}
+{"text":"## Beta Features","__index_level_0__":6072}
+{"text":"\n### [Beta] torch.compile","__index_level_0__":6073}
+{"text":"torch.compile is the main API for PyTorch 2.0, which wraps your model and returns a compiled model. It is a fully additive (and optional) feature and hence 2.0 is 100% backward compatible by definition.","__index_level_0__":6074}
+{"text":"Underpinning torch.compile are new technologies \u2013 TorchDynamo, AOTAutograd, PrimTorch and TorchInductor:\n* TorchDynamo captures PyTorch programs safely using Python Frame Evaluation Hooks and is a significant innovation that was a result of 5 years of our R&D into safe graph capture. \n* AOTAutograd overloads PyTorch\u2019s autograd engine as a tracing autodiff for generating ahead-of-time backward traces. \n* PrimTorch canonicalizes ~2000+ PyTorch operators down to a closed set of ~250 primitive operators that developers can target to build a complete PyTorch backend. This substantially lowers the barrier of writing a PyTorch feature or backend. \n* TorchInductor is a deep learning compiler that generates fast code for multiple accelerators and backends. For NVIDIA and AMD GPUs, it uses OpenAI Triton as a key building block. For intel CPUs, we generate C++ code using multithreading, vectorized instructions and offloading appropriate operations to mkldnn when possible.","__index_level_0__":6075}
+{"text":"With all the new technologies, torch.compile is able to work 93% of time across 165 open-source models and runs 20% faster on average at float32 precision and 36% faster on average at AMP precision. ","__index_level_0__":6076}
+{"text":"For more information, please refer to [https:\/\/pytorch.org\/get-started\/pytorch-2.0\/](https:\/\/pytorch.org\/get-started\/pytorch-2.0\/) and for TorchInductor CPU with Intel [here](https:\/\/dev-discuss.pytorch.org\/t\/torchinductor-update-5-cpu-backend-backend-performance-update-and-deep-dive-on-key-optimizations\/1117).","__index_level_0__":6077}
+{"text":"\n### [Beta] PyTorch MPS Backend","__index_level_0__":6078}
+{"text":"MPS backend provides GPU-accelerated PyTorch training on Mac platforms. This release brings improved correctness, stability, and operator coverage. ","__index_level_0__":6079}
+{"text":"MPS backend now includes support for the Top 60 most used ops, along with the most frequently requested operations by the community, bringing coverage to over 300 operators. The major focus of the release was to enable full OpInfo-based forward and gradient mode testing to address silent correctness issues. These changes have resulted in wider adoption of MPS backend by 3rd party networks such as Stable Diffusion, YoloV5, WhisperAI, along with increased coverage for Torchbench networks and Basic tutorials. We encourage developers to update to the latest macOS release to see the best performance and stability on the MPS backend. ","__index_level_0__":6080}
+{"text":"1. [MPS Backend](https:\/\/pytorch.org\/docs\/stable\/notes\/mps.html)\n2. [Developer information](https:\/\/github.com\/pytorch\/pytorch\/wiki\/MPS-Backend)\n3. [Accelerated PyTorch training on Mac](https:\/\/developer.apple.com\/metal\/pytorch\/) \n4. [Metal](https:\/\/developer.apple.com\/documentation\/metal?language=objc), [Metal Performance Shaders](https:\/\/developer.apple.com\/documentation\/metalperformanceshaders?language=objc) & [Metal Performance Shaders Graph](https:\/\/developer.apple.com\/documentation\/metalperformanceshadersgraph?language=objc)","__index_level_0__":6084}
+{"text":"\n### [Beta] Scaled dot product attention 2.0 ","__index_level_0__":6085}
+{"text":"We are thrilled to announce the release of PyTorch 2.0, which introduces a powerful scaled dot product attention function as part of torch.nn.functional. This function includes multiple implementations that can be seamlessly applied depending on the input and hardware in use.","__index_level_0__":6086}
+{"text":"In previous versions of PyTorch, you had to rely on third-party implementations and install separate packages to take advantage of memory-optimized algorithms like [FlashAttention](https:\/\/github.com\/HazyResearch\/flash-attention). With PyTorch 2.0, all these implementations are readily available by default.","__index_level_0__":6087}
+{"text":"These implementations include [FlashAttention](https:\/\/arxiv.org\/abs\/2205.14135) from HazyResearch, Memory-Efficient Attention from the [xFormers](https:\/\/github.com\/facebookresearch\/xformers) project, and a native C++ implementation that is ideal for non-CUDA devices or when high-precision is required.","__index_level_0__":6088}
+{"text":"PyTorch 2.0 will automatically select the optimal implementation for your use case, but you can also toggle them individually for finer-grained control. Additionally, the scaled dot product attention function can be used to build common transformer architecture components.","__index_level_0__":6089}
+{"text":"Learn more with the [documentation](https:\/\/pytorch.org\/docs\/master\/generated\/torch.nn.functional.scaled_dot_product_attention.html?highlight=scaled_dot_product#torch.nn.functional.scaled_dot_product_attention) and this [tutorial](https:\/\/pytorch.org\/tutorials\/intermediate\/scaled_dot_product_attention_tutorial.html).","__index_level_0__":6090}
+{"text":"\n### [Beta] functorch -> torch.func ","__index_level_0__":6091}
+{"text":"Inspired by [Google JAX](https:\/\/github.com\/google\/jax), functorch is a library that offers composable vmap (vectorization) and autodiff transforms. It enables advanced autodiff use cases that would otherwise be tricky to express in PyTorch. Examples include:\n* [model ensembling](https:\/\/pytorch.org\/tutorials\/intermediate\/ensembling.html)\n* [efficiently computing jacobians and hessians](https:\/\/pytorch.org\/tutorials\/intermediate\/jacobians_hessians.html)\n* [computing per-sample-gradients (or other per-sample quantities)](https:\/\/pytorch.org\/tutorials\/intermediate\/per_sample_grads.html)","__index_level_0__":6092}
+{"text":"We\u2019re excited to announce that, as the final step of upstreaming and integrating functorch into PyTorch, the functorch APIs are now available in the torch.func module. Our function transform APIs are identical to before, but we have changed how the interaction with NN modules work. Please see the [docs](https:\/\/pytorch.org\/docs\/master\/func.html) and the [migration guide](https:\/\/pytorch.org\/docs\/master\/func.migrating.html) for more details.","__index_level_0__":6093}
+{"text":"Furthermore, we have [added support for torch.autograd.Function](https:\/\/pytorch.org\/docs\/master\/notes\/extending.func.html): one is now able to apply function transformations (e.g. vmap, grad, jvp) over torch.autograd.Function.","__index_level_0__":6094}
+{"text":"\n### [Beta] Dispatchable Collectives","__index_level_0__":6095}
+{"text":"Dispatchable collectives is an improvement to the existing init_process_group() API which changes backend to an optional argument. For users, the main advantage of this feature is that it will allow them to write code that can run on both GPU and CPU machines without having to change the backend specification. The dispatchability feature will also make it easier for users to support both GPU and CPU collectives, as they will no longer need to specify the backend manually (e.g. \u201cNCCL\u201d or \u201cGLOO\u201d). Existing backend specifications by users will be honored and will not require change.","__index_level_0__":6096}
+{"text":"Usage example:\n```\nimport torch.distributed.dist\n\u2026\n# old\ndist.init_process_group(backend=\u201dnccl\u201d, ...)\ndist.all_reduce(...) # with CUDA tensors works\ndist.all_reduce(...) # with CPU tensors does not work","__index_level_0__":6097}
+{"text":"# new\ndist.init_process_group(...) # backend is optional\ndist.all_reduce(...) # with CUDA tensors works\ndist.all_reduce(...) # with CPU tensors works\n```","__index_level_0__":6098}
+{"text":"Learn more [here](https:\/\/pytorch.org\/docs\/master\/distributed.html#torch.distributed.init_process_group).","__index_level_0__":6099}
+{"text":"\n### [Beta] torch.set_default_device and torch.device as context manager","__index_level_0__":6100}
+{"text":"torch.set_default_device allows users to change the default device that factory functions in PyTorch allocate on. For example, if you torch.set_default_device(\u2018cuda\u2019), a call to torch.empty(2) will allocate on CUDA (rather than on CPU). You can also use torch.device as a context manager to change the default device on a local basis. This resolves a long standing feature request from PyTorch\u2019s initial release for a way to do this.","__index_level_0__":6101}
+{"text":"Learn more [here](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/changing_default_device.html). ","__index_level_0__":6102}
+{"text":"\n### [Beta] \"X86\" as the new default quantization backend for x86 CPU","__index_level_0__":6103}
+{"text":"The new X86 quantization backend, which utilizes FBGEMM and oneDNN kernel libraries, replaces FBGEMM as the default quantization backend for x86 CPU platforms and offers improved int8 inference performance compared to the original FBGEMM backend, leveraging the strengths of both libraries, with 1.3X \u2013 2X inference performance speedup measured on 40+ deep learning models. The new backend is functionally compatible with the original FBGEMM backend.","__index_level_0__":6104}
+{"text":"\n**Table: Geomean Speedup of X86 Quantization Backend vs. FBGEMM Backend**","__index_level_0__":6105}
+{"text":"\n<table>\n  <tr>\n   <td> \n   <\/td>\n   <td>1 core\/instance\n   <\/td>\n   <td>2 cores\/instance\n   <\/td>\n   <td>4 cores\/instance\n   <\/td>\n   <td>1 socket (32 cores)\/instance\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>Intel(R) Xeon(R) Platinum 8358 CPU @ 2.60GHz\n   <\/td>\n   <td>1.76X\n   <\/td>\n   <td>1.80X\n   <\/td>\n   <td>2.04X\n   <\/td>\n   <td>1.34X\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":6106}
+{"text":"\nBy default, users on x86 platforms will utilize the x86 quantization backend and their PyTorch programs will remain unchanged when using the default backend. Alternatively, users have the option to specify \"X86\" as the quantization backend explicitly. Example code is shown below:","__index_level_0__":6107}
+{"text":"```\nimport torch\nfrom torch.ao.quantization import get_default_qconfig_mappingfrom torch.quantization.quantize_fx\nimport prepare_fx, convert_fx\n \n# get default configuration\nqconfig_mapping = get_default_qconfig_mapping()\n \n# or explicitly specify the backend\n# qengine = 'x86'\n# torch.backends.quantized.engine = qengine\n# qconfig_mapping = get_default_qconfig_mapping(qengine)\n \n# construct fp32 model\nmodel_fp32 = ...\n \n# prepare\nprepared_model = prepare_fx(model_fp32, qconfig_mapping, example_inputs=x)\n \n# calibrate\n...\n \n# convert\nquantized_model = convert_fx(prepared_model)\n```","__index_level_0__":6108}
+{"text":"Find more information: [https:\/\/github.com\/pytorch\/pytorch\/issues\/83888](https:\/\/github.com\/pytorch\/pytorch\/issues\/83888) and [https:\/\/www.intel.com\/content\/www\/us\/en\/developer\/articles\/technical\/accelerate-pytorch-int8-inf-with-new-x86-backend.html](https:\/\/www.intel.com\/content\/www\/us\/en\/developer\/articles\/technical\/accelerate-pytorch-int8-inf-with-new-x86-backend.html).","__index_level_0__":6109}
+{"text":"\n### [Beta] GNN inference and training optimization on CPU ","__index_level_0__":6110}
+{"text":"PyTorch 2.0 includes several critical optimizations to improve GNN inference and training performance on CPU. Before 2.0, GNN models of PyG suffers from low efficiency on CPU due to lack of performance tuning for several critical kernels (scatter\/gather, etc) and the lack of GNN-related sparse matrix multiplication ops. To be specific, optimizations include:\n* scatter_reduce: performance hotspot in Message Passing when the edge index is stored in Coordinate format (COO).\n* gather: backward of scatter_reduce, specially tuned for the GNN compute when the index is an expanded tensor.\n* torch.sparse.mm with reduce flag: performance hotspot in Message Passing when the edge index is stored in Compressed Sparse Row (CSR). Supported reduce flag of: sum, mean, amax, amin.","__index_level_0__":6111}
+{"text":"On PyG benchmarks\/examples, OGB benchmarks, a 1.12x - 4.07x performance speedup is measured (1.13.1 compared with 2.0) for single node inference and training.","__index_level_0__":6112}
+{"text":"<table class=\"table table-bordered\">\n  <thead>\n  <tr>\n   <td scope=\"col\"><strong>Model-Dataset<\/strong>\n   <\/td>\n   <td scope=\"col\"><strong>Option<\/strong>\n   <\/td>\n   <td scope=\"col\"><strong>Speedup Ratio<\/strong>\n   <\/td>\n  <\/tr>\n  <\/thead>\n  <tr>\n   <td rowspan=\"5\" >GCN-Reddit (inference)\n   <\/td>\n   <td>512-2-64-dense\n   <\/td>\n   <td>1.22x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>1024-3-128-dense\n   <\/td>\n   <td>1.25x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>512-2-64-sparse\n   <\/td>\n   <td>1.31x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>1024-3-128-sparse\n   <\/td>\n   <td>1.68x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>512-2-64-dense\n   <\/td>\n   <td>1.22x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td rowspan=\"4\" > \nGraphSage-ogbn-products (inference)\n   <\/td>\n   <td>1024-3-128-dense\n   <\/td>\n   <td>1.15x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>512-2-64-sparse\n   <\/td>\n   <td>1.20x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>1024-3-128-sparse\n   <\/td>\n   <td>1.33x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>full-batch-sparse\n   <\/td>\n   <td>4.07x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>GCN-PROTEINS (training)\n   <\/td>\n   <td>3-32\n   <\/td>\n   <td>1.67x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>GCN-REDDIT-BINARY (training)\n   <\/td>\n   <td>3-32\n   <\/td>\n   <td>1.67x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td rowspan=\"2\" >GCN-Reddit (training)\n   <\/td>\n   <td>512-2-64-dense\n   <\/td>\n   <td>1.20x\n   <\/td>\n  <\/tr>\n  <tr>\n   <td>1024-3-128-dense\n   <\/td>\n   <td>1.12x\n   <\/td>\n  <\/tr>\n<\/table>","__index_level_0__":6113}
+{"text":"\nLearn more: [PyG CPU Performance Optimization](https:\/\/www.pyg.org\/ns-newsarticle-accelerating-pyg-on-intel-cpus).","__index_level_0__":6114}
+{"text":"\n### [Beta] Accelerating inference on CPU with PyTorch by leveraging oneDNN Graph ","__index_level_0__":6115}
+{"text":"[oneDNN Graph API](https:\/\/spec.oneapi.io\/onednn-graph\/latest\/introduction.html) extends [oneDNN](https:\/\/spec.oneapi.io\/versions\/latest\/elements\/oneDNN\/source\/index.html) with a flexible graph API to maximize the optimization opportunity for generating efficient code on AI hardware. \n* It automatically identifies the graph partitions to be accelerated via fusion. \n* The [fusion patterns](https:\/\/github.com\/oneapi-src\/oneDNN\/blob\/dev-graph\/doc\/programming_model\/ops_and_patterns.md#fusion-patterns) focus on fusing compute-intensive operations such as convolution, matmul and their neighbor operations for both inference and training use cases.  \n* Although work is ongoing to integrate oneDNN Graph with TorchDynamo as well, its integration with the PyTorch JIT Fuser attained beta status in PyTorch 2.0 for [Float32](https:\/\/github.com\/pytorch\/pytorch\/tree\/master\/torch\/csrc\/jit\/codegen\/onednn#example-with-float) & [BFloat16](https:\/\/github.com\/pytorch\/pytorch\/tree\/master\/torch\/csrc\/jit\/codegen\/onednn#example-with-bfloat16) inference (on machines that support AVX512_BF16 ISA).","__index_level_0__":6116}
+{"text":"\nFrom a developer\u2019s\/researcher\u2019s perspective, the usage is quite simple & intuitive, with the only change in code being an API invocation:\n* Leverage oneDNN Graph, with [JIT-tracing](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.jit.trace.html), a model is profiled with an example input. \n* The context manager _with torch.jit.fuser(\u201cfuser3\u201d):_ can also be used instead of invoking _torch.jit.enable_onednn_fusion(True)_.\n* For accelerating [BFloat16 inference](https:\/\/github.com\/pytorch\/pytorch\/tree\/master\/torch\/csrc\/jit\/codegen\/onednn#example-with-bfloat16), we rely on eager-mode AMP (Automatic Mixed Precision) support in PyTorch & disable JIT mode\u2019s AMP, as both of them are currently divergent:","__index_level_0__":6117}
+{"text":"```\n# Assuming we have a model of the name 'model'\n \nexample_input = torch.rand(1, 3, 224, 224)\n \n# enable oneDNN Graph\ntorch.jit.enable_onednn_fusion(True)\n# Disable AMP for JIT\ntorch._C._jit_set_autocast_mode(False)\nwith torch.no_grad(), torch.cpu.amp.autocast():\n\tmodel = torch.jit.trace(model, (example_input))\n\tmodel = torch.jit.freeze(model)\n \t# 2 warm-ups (2 for tracing\/scripting with an example, 3 without an example)\n\tmodel(example_input)\n\tmodel(example_input)\n \n\t# speedup would be observed in subsequent runs.\n\tmodel(example_input)\n```","__index_level_0__":6118}
+{"text":"\nLearn more [here](https:\/\/pytorch.org\/tutorials\/recipes\/recipes\/tuning_guide.html#use-onednn-graph-with-torchscript-for-inference).","__index_level_0__":6119}
+{"text":"\n## Prototype Features","__index_level_0__":6120}
+{"text":"### Distributed API","__index_level_0__":6121}
+{"text":"#### [Prototype] DTensor","__index_level_0__":6122}
+{"text":"PyTorch [DistributedTensor](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/torch\/distributed\/_tensor\/README.md) (DTensor) is a prototyping effort with distributed tensor primitives to allow easier distributed computation authoring in the SPMD (Single Program Multiple Devices) paradigm. The primitives are simple but powerful when used to express tensor distributions with both sharded and replicated parallelism strategies. PyTorch DTensor empowered PyTorch [Tensor Parallelism](https:\/\/pytorch.org\/docs\/master\/distributed.tensor.parallel.html) along with other advanced parallelism explorations. In addition, it also offers a uniform way to save\/load state_dict for distributed checkpointing purposes, even when there\u2019re complex tensor distribution strategies such as combining tensor parallelism with parameter sharding in FSDP. More details can be found in this [RFC](https:\/\/github.com\/pytorch\/pytorch\/issues\/88838) and the [DTensor examples notebook](https:\/\/colab.research.google.com\/drive\/12Pl5fvh0eLPUrcVO7s6yY4n2_RZo8pLR#scrollTo=stYPKb9Beq4e).","__index_level_0__":6123}
+{"text":"\n#### [Prototype] TensorParallel","__index_level_0__":6124}
+{"text":"We now support DTensor based Tensor Parallel which users can distribute their model parameters across different GPU devices. We also support Pairwise Parallel which shards two concatenated linear layers in a col-wise and row-wise style separately so that only one collective(all-reduce\/reduce-scatter) is needed in the end. More details can be found in this [example](https:\/\/github.com\/pytorch\/examples\/blob\/main\/distributed\/tensor_parallelism\/example.py).","__index_level_0__":6125}
+{"text":"\n#### [Prototype] 2D Parallel","__index_level_0__":6126}
+{"text":"We implemented the integration of the aforementioned TP with FullyShardedDataParallel(FSDP) as 2D parallel to further scale large model training. More details can be found in this [slide](https:\/\/docs.google.com\/presentation\/d\/17g6WqrO00rP3MsxbRENsPpjrlSkwiA_QB4r93_eB5is\/edit?usp=sharing) and [code example](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/test\/distributed\/tensor\/parallel\/test_2d_parallel.py).","__index_level_0__":6127}
+{"text":"\n#### [Prototype] torch.compile(dynamic=True)","__index_level_0__":6128}
+{"text":"Experimental support for PT2 compilation with dynamic shapes is available in this release. Inference compilation with inductor for simple models is supported, but there are a lot of limitations:","__index_level_0__":6129}
+{"text":"* Training available in a future release (This is partially fixed in nightlies!)\n* Minifier available in a future release.\n* It is easy to end up in a situation where the dimension you wanted to be dynamic gets specialized anyway. Some of these issues are fixed in nightlies, others are not.\n* We do not appropriately propagate Inductor guards to the top-level, this is tracked at [#96296](https:\/\/github.com\/pytorch\/pytorch\/issues\/96296).\n* Data-dependent operations like nonzero still require a graph break.\n* Dynamic does not work with non-standard modes like reduce-overhead or max-autotune.\n* There are many bugs in Inductor compilation. To track known bugs, check the [dynamic shapes](https:\/\/github.com\/pytorch\/pytorch\/issues?q=is%3Aopen+is%3Aissue+label%3A%22module%3A+dynamic+shapes%22) label on the PyTorch issue tracker.","__index_level_0__":6130}
+{"text":"For the latest and greatest news about dynamic shapes support on master, check out [our status reports](https:\/\/dev-discuss.pytorch.org\/t\/state-of-symbolic-shapes-branch\/777\/43).","__index_level_0__":6131}
+{"text":"\n## Highlights\/Performance Improvements","__index_level_0__":6132}
+{"text":"\n### [Deprecation of Cuda 11.6 and Python 3.7 support](https:\/\/pytorch.org\/blog\/deprecation-cuda-python-support\/) for PyTorch 2.0","__index_level_0__":6133}
+{"text":"If you are still using or depending on CUDA 11.6 or Python 3.7 builds, we strongly recommend moving to at least CUDA 11.7 and Python 3.8, as it would be the minimum versions required for PyTorch 2.0. For more detail, please refer to the [Release Compatibility Matrix for PyTorch](https:\/\/github.com\/pytorch\/pytorch\/blob\/master\/RELEASE.md#release-compatibility-matrix) releases.","__index_level_0__":6134}
+{"text":"\n### Python 3.11 support on Anaconda Platform","__index_level_0__":6135}
+{"text":"Due to lack of Python 3.11 support for packages that PyTorch depends on, including NumPy, SciPy, SymPy, Pillow and others on the Anaconda platform. We will not be releasing Conda binaries compiled with Python 3.11 for PyTorch Release 2.0. The Pip packages with Python 3.11 support will be released, hence if you intend to use PyTorch 2.0 with Python 3.11 please use our Pip packages. Please note: Conda packages with Python 3.11 support will be made available on our nightly channel. Also we are planning on releasing Conda Python 3.11 binaries as part of future release once Anaconda provides these key dependencies. More information and instructions on how to download the Pip packages can be found [here](https:\/\/dev-discuss.pytorch.org\/t\/pytorch-2-0-message-concerning-python-3-11-support-on-anaconda-platform\/1087).","__index_level_0__":6136}
+{"text":"\n### Optimized PyTorch Inference with AWS Graviton processors  ","__index_level_0__":6137}
+{"text":"The optimizations focused on three key areas: GEMM kernels, bfloat16 support, primitive caching and the memory allocator. For aarch64 platforms, PyTorch supports Arm Compute Library (ACL) GEMM kernels via Mkldnn(OneDNN) backend. The ACL library provides Neon\/SVE GEMM kernels for fp32 and bfloat16 formats. The bfloat16 support on c7g allows efficient deployment of bfloat16 trained, AMP (Automatic Mixed Precision) trained, or even the standard fp32 trained models. The standard fp32 models leverage bfloat16 kernels via OneDNN fast math mode, without any model quantization. Next we implemented primitive caching for conv, matmul and inner product operators. More information on the updated PyTorch user guide with the upcoming 2.0 release improvements and TorchBench benchmark details can be found [here](https:\/\/github.com\/aws\/aws-graviton-getting-started).\n \n source: https:\/\/pytorch.org\/blog\/pytorch-2.0-release\/ \n category: pytorch blogs","__index_level_0__":6138}
+{"text":"text: ---\nlayout: blog_detail\ntitle: \"Case Study: PathAI Uses PyTorch to Improve Patient Outcomes with AI-powered Pathology\"\nauthor: Logan Kilpatrick - Sr. Technology Advocate, Harshith Padigela - ML Engineer, Syed Ashar Javed - ML Technical Lead, Robert Egger - Biomedical Data Scientist\nfeatured-img: \"\/assets\/images\/2022-7-15-PathAI-Uses-PyTorch-to-Improve-Patient-Outcomes-with-AI-powered-Pathology-1.png\"\n---","__index_level_0__":6139}
+{"text":"\u200b[\u200bPathAI](https:\/\/pathai.com) is the leading provider of AI-powered technology tools and services for pathology (the study of disease). Our platform was built to enable substantial improvements to the accuracy of diagnosis and the measurement of therapeutic efficacy for complex diseases, leveraging modern approaches in machine learning like image segmentation, graph neural networks, and multiple instance learning.","__index_level_0__":6140}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-PathAI-Uses-PyTorch-to-Improve-Patient-Outcomes-with-AI-powered-Pathology-1.png\" width=\"100%\">\n<\/p>","__index_level_0__":6141}
+{"text":"Traditional manual pathology is prone to [subjectivity and observer variability](https:\/\/www.journal-of-hepatology.eu\/article\/S0168-8278(20)30399-8\/fulltext) that can negatively affect diagnoses and drug development trials. Before we dive into how we use PyTorch to improve our diagnosis workflow, let us first lay out the traditional analog Pathology workflow without machine learning.","__index_level_0__":6142}
+{"text":"## How Traditional Biopharma Works","__index_level_0__":6143}
+{"text":"There are many avenues that biopharma companies take to discover novel therapeutics or diagnostics. One of those avenues relies heavily on the analysis of pathology slides to answer a variety of questions: how does a particular cellular communication pathway work? Can a specific disease state be linked to the presence or lack of a particular protein? Why did a particular drug in a clinical trial work for some patients but not others? Might there be an association between patient outcomes and a novel biomarker?","__index_level_0__":6144}
+{"text":"To help answer these questions, biopharma companies rely on expert pathologists to analyze slides and help evaluate the questions they might have.\u00a0","__index_level_0__":6145}
+{"text":"As you might imagine, it takes an expert board certified pathologist to make accurate interpretations and diagnosis. In [one study](https:\/\/www.bmj.com\/content\/357\/bmj.j2813.full), a single biopsy result was given to 36 different pathologists and the outcome was 18 different diagnoses varying in severity from no treatment to aggressive treatment necessary. Pathologists also often solicit feedback from colleagues in difficult edge cases. Given the complexity of the problem, even with expert training and collaboration, pathologists can still have a hard time making a correct diagnosis. This potential variance can be the difference between a drug being approved and it failing the clinical trial.","__index_level_0__":6146}
+{"text":"## How PathAI utilizes machine learning to power drug development","__index_level_0__":6147}
+{"text":"PathAI develops machine learning models which provide insights for drug development R&D, for powering clinical trials, and for making diagnoses. To this end, PathAI leverages PyTorch for slide level inference using a variety of methods including graph neural networks (GNN) as well as multiple instance learning. In this context, \u201cslides\u201d refers to full size scanned images of glass slides, which are pieces of glass with a thin slice of tissue between them, stained to show various cell formations. PyTorch enables our teams using these different methodologies to share a common framework which is robust enough to work in all the conditions we need. PyTorch\u2019s high level, imperative, and pythonic syntax allows us to prototype models quickly and then take those models to scale once we have the results we want.\u00a0","__index_level_0__":6148}
+{"text":"## Multi-instance learning on gigabyte images","__index_level_0__":6149}
+{"text":"One of the uniquely challenging aspects of applying ML to pathology is the immense size of the images. These digital slides can often be 100,000 x 100,000 pixels or more in resolution and gigabytes in size. Loading the full image in GPU memory and applying traditional computer vision algorithms on them is an almost impossible task. It also takes both a considerable amount of time and resources to have a full slide image (100k x 100k) annotated, especially when annotators need to be domain experts (board-certified pathologists). We often build models to predict image-level labels, like the presence of cancer, on a patient slide which covers a few thousand pixels in the whole image. The cancerous area is sometimes a tiny fraction of the entire slide, which makes the ML problem similar to finding a needle in a haystack. On the other hand, some problems like the prediction of certain histological biomarkers require an aggregation of information from the whole slide which is again hard due to the size of the images. All these factors add significant algorithmic, computational, and logistical complexity when applying ML techniques to pathology problems.","__index_level_0__":6150}
+{"text":"Breaking down the image into smaller patches, learning patch representations, and then pooling those representations to predict an image-level label is one way to solve this problem as is depicted in the image below. One popular method for doing this is called [Multiple Instance Learning (MIL)](https:\/\/paperswithcode.com\/task\/multiple-instance-learning). Each patch is considered an \u2018instance\u2019 and a set of patches forms a \u2018bag\u2019. The individual patch representations are pooled together to predict a final bag-level label. Algorithmically, the individual patch instances in the bag do not require labels and hence allow us to learn bag-level labels in a weakly-supervised way. They also use permutation invariant pooling functions which make the prediction independent of the order of patches and allows for an efficient aggregation of information. Typically, attention based pooling functions are used which not only allow for efficient aggregation but also provide attention values for each patch in the bag. These values indicate the importance of the corresponding patch in the prediction and can be visualized to better understand the model predictions. This element of interpretability can be very important to drive adoption of these models in the real world and we use variations like [Additive MIL models](https:\/\/arxiv.org\/pdf\/2206.01794.pdf) to enable such spatial explainability. Computationally, MIL models circumvent the problem of applying neural networks to large image sizes since patch representations are obtained independently of the size of the image.","__index_level_0__":6151}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-PathAI-Uses-PyTorch-to-Improve-Patient-Outcomes-with-AI-powered-Pathology-2.png\" width=\"100%\">\n<\/p>","__index_level_0__":6152}
+{"text":"At PathAI, we use custom MIL models based on deep nets to predict image-level labels. The overview of this process is as follows:","__index_level_0__":6153}
+{"text":"1. Select patches from a slide using different sampling approaches.\n2. Construct a bag of patches based on random sampling or heuristic rules.\n3. Generate patch representations for each instance based on pre-trained models or large-scale representation learning models.\n4. Apply permutation invariant pooling functions to get the final slide-level score.","__index_level_0__":6154}
+{"text":"Now that we have walked through some of the high-level details around MIL in PyTorch, let\u2019s look at some code to see how simple it is to go from ideation to code in production with PyTorch. We begin by defining a sampler, transformations, and our MIL dataset:","__index_level_0__":6155}
+{"text":"```python\n# Create a bag sampler which randomly samples patches from a slide\nbag_sampler = RandomBagSampler(bag_size=12)","__index_level_0__":6156}
+{"text":"# Setup the transformations\ncrop_transform = FlipRotateCenterCrop(use_flips=True)","__index_level_0__":6157}
+{"text":"# Create the dataset which loads patches for each bag\ntrain_dataset = MILDataset(\n  bag_sampler=bag_sampler,\n  samples_loader=sample_loader,\n  transform=crop_transform,\n)\n```","__index_level_0__":6158}
+{"text":"After we have defined our sampler and dataset, we need to define the model we will actually train with said dataset. PyTorch\u2019s familiar model definition syntax makes this easy to do while also allowing us to create bespoke models at the same time.","__index_level_0__":6159}
+{"text":"```python\nclassifier = DefaultPooledClassifier(hidden_dims=[256, 256], input_dims=1024, output_dims=1)","__index_level_0__":6160}
+{"text":"pooling = DefaultAttentionModule(\n  input_dims=1024,\n  hidden_dims=[256, 256],\n  output_activation=StableSoftmax()\n)","__index_level_0__":6161}
+{"text":"# Define the model which is a composition of the featurizer, pooling module and a classifier\nmodel = DefaultMILGraph(featurizer=ShuffleNetV2(), classifier=classifier, pooling = pooling)\n```","__index_level_0__":6162}
+{"text":"Since these models are trained end-to-end, they offer a powerful way to go directly from a gigapixel whole slide image to a single label. Due to their wide applicability to different biological problems, two aspects of their implementation and deployment are important:","__index_level_0__":6163}
+{"text":"1. Configurable control over each part of the pipeline including the data loaders, the modular parts of the model, and their interaction with each other.\n2. Ability to rapidly iterate through the ideate-implement-experiment-productionize loop.","__index_level_0__":6164}
+{"text":"PyTorch has various advantages when it comes to MIL modeling. It offers an intuitive way to create dynamic computational graphs with flexible control flow which is great for rapid research experimentation. The map-style datasets, configurable sampler and batch-samplers allow us to customize how we construct bags of patches, enabling faster experimentation. Since MIL models are IO heavy, data parallelism and pythonic data loaders make the task very efficient and user friendly. Lastly, the object-oriented nature of PyTorch enables building of reusable modules which aid in the rapid experimentation, maintainable implementation and ease of building compositional components of the pipeline.","__index_level_0__":6165}
+{"text":"## Exploring spatial tissue organization with GNNs in PyTorch","__index_level_0__":6166}
+{"text":"<p align=\"center\">\n  <img src=\"\/assets\/images\/2022-7-15-PathAI-Uses-PyTorch-to-Improve-Patient-Outcomes-with-AI-powered-Pathology-3.png\" width=\"100%\">\n<\/p>","__index_level_0__":6167}
+{"text":"In both healthy and diseased tissue, the spatial arrangement and structure of cells can oftentimes be as important as the cells themselves. For example, when assessing lung cancers, pathologists try to look at the overall grouping and structure of tumor cells (do they form solid sheets? Or do they occur in smaller, localized clusters?) to determine if the cancer belongs to specific subtypes which can have vastly [different prognosis](https:\/\/www.ncbi.nlm.nih.gov\/pmc\/articles\/PMC3369269\/). Such spatial relationships between cells and other tissue structures can be modeled using graphs to capture tissue topology and cellular composition at the same time. [Graph Neural Networks](https:\/\/openaccess.thecvf.com\/content_CVPRW_2020\/papers\/w16\/Lu_Capturing_Cellular_Topology_in_Multi-Gigapixel_Pathology_Images_CVPRW_2020_paper.pdf) (GNNs) allow learning spatial patterns within these graphs that relate to other clinical variables, for example overexpression of genes in certain cancers.","__index_level_0__":6168}
+{"text":"In late 2020, when PathAI started using GNNs on tissue samples, PyTorch had the best and most mature support for GNN functionality via the [PyG package](https:\/\/pytorch-geometric.readthedocs.io\/en\/latest\/). This made PyTorch the natural choice for our team given that GNN models were something that we knew would be an important ML concept we wanted to explore.\u00a0","__index_level_0__":6169}
+{"text":"One of the main value-adds of GNN\u2019s in the context of tissue samples is that the graph itself can uncover spatial relationships that would otherwise be very difficult to find by visual inspection alone. In our recent [AACR publication](https:\/\/aacrjournals.org\/cancerres\/article\/82\/12_Supplement\/1922\/701539), we showed that by using GNNs, we can better understand the way the presence of immune cell aggregates (specifically tertiary lymphoid structures, or TLS) in the tumor microenvironment can influence patient prognosis. In this case, the GNN approach was used to predict expression of genes associated with the presence of TLS, and identify histological features beyond the TLS region itself that are relevant to TLS. Such insights into gene expression are difficult to identify from tissue sample images when unassisted by ML models.\u00a0","__index_level_0__":6170}
+{"text":"One of the most promising GNN variations we have had success with is [self attention graph pooling](https:\/\/arxiv.org\/pdf\/1904.08082.pdf). Let\u2019s take a look at how we define our Self Attention Graph Pooling (SAGPool) model using PyTorch and PyG:","__index_level_0__":6171}
+{"text":"```python\nclass SAGPool(torch.nn.Module):\n  def __init__(self, ...):\n    super().__init__()\n    self.conv1 = GraphConv(in_features, hidden_features, aggr='mean')\n    self.convs = torch.nn.ModuleList()\n    self.pools = torch.nn.ModuleList()\n    self.convs.extend([GraphConv(hidden_features, hidden_features, aggr='mean') for i in range(num_layers - 1)])\n    self.pools.extend([SAGPooling(hidden_features, ratio, GNN=GraphConv, min_score=min_score) for i in range((num_layers) \/\/ 2)])\n    self.jump = JumpingKnowledge(mode='cat')\n    self.lin1 = Linear(num_layers * hidden_features, hidden_features)\n    self.lin2 = Linear(hidden_features, out_features)\n    self.out_activation = out_activation\n    self.dropout = dropout\n```","__index_level_0__":6172}
+{"text":"In the above code, we begin by defining a single convolutional graph layer and then add two [module list layers](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.ModuleList.html) which allow us to pass in a variable number of layers. We then take our [empty module list and append](https:\/\/pytorch.org\/docs\/stable\/generated\/torch.nn.ModuleList.html?highlight=extend#torch.nn.ModuleList.extend) a variable number of `GraphConv` layers followed by a variable number of `SAGPooling` layers. We finish up our `SAGPool` definition by adding a [JumpingKnowledge Layer](https:\/\/pytorch-geometric.readthedocs.io\/en\/latest\/modules\/nn.html#torch_geometric.nn.models.JumpingKnowledge), two linear layers, our activation function, and our dropout value. PyTorch\u2019s intuitive syntax allows us to abstract away the complexity of working with state of the art methods like SAG Poolings while also maintaining the common approach to model development we are familiar with.","__index_level_0__":6173}
+{"text":"Models like our SAG Pool one described above are just one example of how GNNs with PyTorch are allowing us to explore new and novel ideas. We also recently explored [multimodal CNN - GNN hybrid models](https:\/\/openaccess.thecvf.com\/content\/CVPR2022W\/CVMI\/papers\/Dwivedi_Multi_Stain_Graph_Fusion_for_Multimodal_Integration_in_Pathology_CVPRW_2022_paper.pdf) which ended up being 20% more accurate than traditional Pathologist consensus scores. These innovations and interplay between traditional CNNs and GNNs are again enabled by the short research to production model development loop.","__index_level_0__":6174}
+{"text":"## Improving Patient Outcomes\nIn order to achieve our mission of improving patient outcomes with AI-powered pathology, PathAI needs to rely on an ML development framework that (1) facilitates quick iteration and easy extension (i.e. Model configuration as code) during initial phases of development and exploration (2) scales model training and inference to massive images (3) easily and robustly serves models for production uses of our products (in clinical trials and beyond). As we\u2019ve demonstrated, PyTorch offers us all of these capabilities and more. We are incredibly excited about the future of PyTorch and cannot wait to see what other impactful challenges we can solve using the framework. \n source: https:\/\/pytorch.org\/blog\/PathAI-Uses-PyTorch-to-Improve-Patient-Outcomes-with-AI-powered-Pathology\/ \n category: pytorch blogs","__index_level_0__":6175}