# tensors

Published articles for tensors.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Accelerating Dropless MoE Training in JAX with NVIDIA Transformer Engine

DevFeed: [Accelerating Dropless MoE Training in JAX with NVIDIA Transformer Engine](<https://devfeed.tech/articles/accelerating-dropless-moe-training-in-jax-with-nvidia-transformer-engine-21079.md>)

Original publisher: [Read original article](<https://developer.nvidia.com/blog/accelerating-dropless-moe-training-in-jax-with-nvidia-transformer-engine/>)

Author: Tanya Lenz

Published: 2026-09-14T16:39:15Z

Content type: article

Language: en

Sources: [NVIDIA Developer](<https://devfeed.tech/sources/nvidia-developer.md>), [NVIDIA Technical Blog](<https://devfeed.tech/sources/nvidia-technical-blog.md>)

Topics: [Mixture of Experts (MoE)](<https://devfeed.tech/topics/mixture-of-experts-moe.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Nvidia](<https://devfeed.tech/topics/nvidia.md>), [Routing (disambiguation)](<https://devfeed.tech/topics/routing.md>), [GB200](<https://devfeed.tech/topics/gb200.md>), [Network](<https://devfeed.tech/topics/network.md>), [Python](<https://devfeed.tech/topics/python.md>), [deepseek](<https://devfeed.tech/topics/deepseek.md>), [mixtral](<https://devfeed.tech/topics/mixtral.md>), [qwen](<https://devfeed.tech/topics/qwen.md>)

Tags: [agentic-ai-generative-ai](<https://devfeed.tech/tags/agentic-ai-generative-ai.md>), [ai](<https://devfeed.tech/tags/ai.md>), [communication](<https://devfeed.tech/tags/communication.md>), [deepseek](<https://devfeed.tech/tags/deepseek.md>), [developer-tools-techniques](<https://devfeed.tech/tags/developer-tools-techniques.md>), [gb200](<https://devfeed.tech/tags/gb200.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [mixtral](<https://devfeed.tech/tags/mixtral.md>), [mixture-of-experts-moe](<https://devfeed.tech/tags/mixture-of-experts-moe.md>), [mlops](<https://devfeed.tech/tags/mlops.md>), [moe](<https://devfeed.tech/tags/moe.md>), [networks](<https://devfeed.tech/tags/networks.md>), [nvfp4](<https://devfeed.tech/tags/nvfp4.md>), [nvidia](<https://devfeed.tech/tags/nvidia.md>), [performance](<https://devfeed.tech/tags/performance.md>), [python](<https://devfeed.tech/tags/python.md>), [qwen](<https://devfeed.tech/tags/qwen.md>), [router](<https://devfeed.tech/tags/router.md>), [routing](<https://devfeed.tech/tags/routing.md>), [tensors](<https://devfeed.tech/tags/tensors.md>), [token](<https://devfeed.tech/tags/token.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [training-ai-models](<https://devfeed.tech/tags/training-ai-models.md>)

### AI overview

This article explains how NVIDIA Transformer Engine and JAX kernel optimizations accelerate dropless Mixture of Experts (MoE) training. It describes bottlenecks from token routing, expert dispatch and gathering, all-to-all communication, and ragged expert matrix operations. In DeepSeek-V3 training on NVIDIA GB200, the optimized approach increased performance from 103 to 1,068 TFLOPS per GPU, a 10.4x improvement.

### Source excerpt

Mixture of experts (MoE) has become one of the defining architectural trends in large-scale AI model training. DeepSeek, Qwen, and Mixtral are examples of MoE...

## Scaling a Vespa Application: Feeding Fast and Furiously

DevFeed: [Scaling a Vespa Application: Feeding Fast and Furiously](<https://devfeed.tech/articles/scaling-a-vespa-application-feeding-fast-and-furiously-12797.md>)

Original publisher: [Read original article](<https://blog.vespa.ai/scaling-a-vespa-application-feeding-fast-and-furiously/>)

Author: Kai Borgen

Published: 2026-04-28T00:00:00Z

Content type: tutorial

Language: en

Sources: [Vespa Blog](<https://devfeed.tech/sources/vespa-blog.md>)

Topics: [AI search](<https://devfeed.tech/topics/ai-search.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [datasets](<https://devfeed.tech/topics/datasets.md>), [information retrieval](<https://devfeed.tech/topics/information-retrieval.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [Homebrew](<https://devfeed.tech/topics/homebrew.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [onnx](<https://devfeed.tech/topics/onnx.md>), [optimum](<https://devfeed.tech/topics/optimum.md>), [XML](<https://devfeed.tech/topics/xml.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-search](<https://devfeed.tech/tags/ai-search.md>), [cli](<https://devfeed.tech/tags/cli.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [genai](<https://devfeed.tech/tags/genai.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [information-retrieval](<https://devfeed.tech/tags/information-retrieval.md>), [install](<https://devfeed.tech/tags/install.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [onnx](<https://devfeed.tech/tags/onnx.md>), [optimum](<https://devfeed.tech/tags/optimum.md>), [performance](<https://devfeed.tech/tags/performance.md>), [rag](<https://devfeed.tech/tags/rag.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [tensors](<https://devfeed.tech/tags/tensors.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

This tutorial demonstrates how to scale a Vespa application while feeding the full MS_marco passages dataset. It covers preparing the dataset, configuring access, deploying a sample application, and using scaling and metrics to improve feed throughput and performance.

### Source excerpt

A tutorial on how to scale the resources in a Vespa application to increase feed throughput. Using the metrics dashboard for informed and optimised scaling.

## Four ways to run ONNX models on a GPU with CUDA in Clojure

DevFeed: [Four ways to run ONNX models on a GPU with CUDA in Clojure](<https://devfeed.tech/articles/not-one-not-two-not-even-three-but-four-ways-to-run-an-onnx-ai-model-on-gpu-with-cuda-20728.md>)

Original publisher: [Read original article](<http://dragan.rocks/articles/25/Four-Ways-to-ONNX-on-GPU-in-Clojure-and-CUDA>)

Published: 2025-11-09T17:49:00Z

Content type: tutorial

Language: en

Sources: [Dragan Djuric](<https://devfeed.tech/sources/dragan-djuric.md>)

Topics: [CUDA](<https://devfeed.tech/topics/cuda.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [onnx](<https://devfeed.tech/topics/onnx.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Deep neural networks](<https://devfeed.tech/topics/deep-neural-networks.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [cuda](<https://devfeed.tech/tags/cuda.md>), [deep](<https://devfeed.tech/tags/deep.md>), [diamond](<https://devfeed.tech/tags/diamond.md>), [examples](<https://devfeed.tech/tags/examples.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [image-recognition](<https://devfeed.tech/tags/image-recognition.md>), [model](<https://devfeed.tech/tags/model.md>), [neural-networks](<https://devfeed.tech/tags/neural-networks.md>), [onnx](<https://devfeed.tech/tags/onnx.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

A tutorial presents four ways to run ONNX models on a GPU with CUDA using Clojure libraries including Diamond ONNX RT, Deep Diamond, and ClojureCUDA. It covers GPU tensor backends and a configuration that keeps input and output tensors in main memory while executing the model on the GPU.

### Source excerpt

Two weeks ago, I announced a new Clojure ML library, Diamond ONNX RT, which integrates ONNX Runtime into Deep Diamond. In that post, we explored the classic Hello World example of Neural Networks, MNIST handwritten image recognition, step-by-step. We run that example on the CPU, from main memory. The next logical step is to execute this stuff on the GPU. You'll see that with a little help of ClojureCUDA and Deep Diamond built-in CUDA machinery, this is both easy and simple, requiring almost no effort from a curious Clojure programmer. But don't just trust me; let's fire up your REPL, and we can continue together. Here's how you can evaluate this directly in your REPL (you can use the Hello World that is provided in the ./examples sub-folder of Diamond ONNX RT as a springboard). Require Diamond's namespaces First things first, we refer functions that we're going to use. (require '[uncomplicate.commons.core :refer [with-release]] '[uncomplicate.neanderthal.core :refer [transfer! iamax native]] '[uncomplicate.diamond [tensor :refer [tensor with-diamond]] [dnn :refer [network]] [onnxrt :refer [onnx]]] '[uncomplicate.diamond.internal.dnnl.factory :refer [dnnl-factory]] '[uncomplicate.diamond.internal.cudnn.factory :refer [cudnn-factory]] '[hello-world.native :refer [input-desc input-tz mnist-onnx]]) None of the following ways to run CUDA models has preference, you use the one that best suits your needs. Way one One of the ways to run ONNX models on your GPU is to simply use Deep Diamond's cuDNN factory as the backend for your tensors. Then, the machinery recognizes what you need and proceeds doing everything on the GPU, using the right stream for tensors, Deep Diamond operations, and ONNX Runtime operations. This looks exactly the same as any other Deep Diamond example from this blog or the DLFP book. (with-diamond cudnn-factory [] (with-release [cuda-input-tz (tensor input-desc) mnist (network cuda-input-tz [mnist-onnx]) classify! (mnist cuda-input-tz)] (transfer! input

## Get Ready for Clojure, GPU, and AI in 2026 with CUDA 13.0

DevFeed: [Get Ready for Clojure, GPU, and AI in 2026 with CUDA 13.0](<https://devfeed.tech/articles/get-ready-for-clojure-gpu-and-ai-in-2026-with-cuda-13-0-20730.md>)

Original publisher: [Read original article](<http://dragan.rocks/articles/25/Get-Ready-Clojure-GPU-AI-2026-CUDA-13>)

Published: 2025-10-30T16:37:00Z

Content type: tutorial

Language: en

Sources: [Dragan Djuric](<https://devfeed.tech/sources/dragan-djuric.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [CUDA](<https://devfeed.tech/topics/cuda.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [OpenCL](<https://devfeed.tech/topics/opencl.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [coding](<https://devfeed.tech/tags/coding.md>), [cuda](<https://devfeed.tech/tags/cuda.md>), [deep](<https://devfeed.tech/tags/deep.md>), [diamond](<https://devfeed.tech/tags/diamond.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [opencl](<https://devfeed.tech/tags/opencl.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

The article introduces ClojureCUDA 0.25.0, which supports CUDA 13.0.2, and encourages Clojure developers to try GPU programming interactively through the Clojure REPL. It explains that GPU acceleration is most useful for large vectors and sufficiently complex workloads because data transfer costs can outweigh computation gains.

### Source excerpt

A little anniversary Did you know that CUDA has been available in Clojure for the last 9 years through ClojureCUDA, and GPU programming through OpenCL for more than 10? I almost forgot about these anniversaries. Ten years ago most people liked it a lot, starred it on Github, patted me on the back, but then concluded that they don't have an Nvidia card available on their laptops, or, if they had GPUs, that they won't have time to learn to think in massive parallel algorithms, or if they have time and will, that there are no GPUs in the servers, so what would they do with their applications, even if they created them in Clojure, and so on, and so off :) But, ClojureCUDA and ClojureCL continued living on for these 10 years, I used them in creating Neanderthal, Deep Diamond, and Diamond ML, and they proved themselves as simple and reliable tools. I still had trouble convincing Clojure programmers that they can write GPU programs that run as fast as they'd wrote them in C++, but interactively in the Cloujre REPL, without C++ hell. But I'm not easy to shake off! If it's necessary, I'll continue for 10 more years, for I'm convinced there'd be a moment when Clojure programmers are going to say "hmmm, this is something that we can use and be good at!". CUDA 13 is here! I've recently released ClojureCUDA 0.25.0, with support for the latest CUDA 13.0.2! Why not celebrate that by opening the REPL, and coding your first Hello World application on the GPU? I promise, it won't be a usual GPU carpet of text; this is ClojureCUDA, it follows the Clojure philosophy by being simple and interactive! There's not much sense in wielding a GPU to print out "Hello World". Note that it is also not very useful to work with scalar numbers and call a GPU function to add or multiply two numbers. No. Unless you have many, many, numbers to crunch, stay by your trusty CPU. For our purposes, many, many, numbers would be two vectors of dimension 3 (hey, it's hello world; imagine it's 3 billion). Also,

## Clojure API for Running ONNX Models with ONNX Runtime

DevFeed: [Clojure API for Running ONNX Models with ONNX Runtime](<https://devfeed.tech/articles/clojure-runs-onnx-ai-models-now-join-the-ai-fun-20727.md>)

Original publisher: [Read original article](<http://dragan.rocks/articles/25/Clojure-Runs-ONNX-AI-Models-Now>)

Published: 2025-10-26T15:56:00Z

Content type: tutorial

Language: en

Sources: [Dragan Djuric](<https://devfeed.tech/sources/dragan-djuric.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [onnx](<https://devfeed.tech/topics/onnx.md>), [AI Models](<https://devfeed.tech/topics/ai-models.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [deep](<https://devfeed.tech/tags/deep.md>), [diamond](<https://devfeed.tech/tags/diamond.md>), [onnx](<https://devfeed.tech/tags/onnx.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

The author describes work on a Clojure API for using pre-trained models exported in ONNX format through ONNX Runtime. The approach uses ONNX Runtime's underlying C library rather than Python interoperability.

### Source excerpt

Hello, Clojurians! I haven't written here in a long time. Was I tired? Is anybody reading blogs anymore? Who knows. But that was not the main reason. I've been working on several Clojure projects sponsored by the Clojurists Together Foundation. I did a ton of things, but after all this programming, I was kinda tired, and kept slugging when it comes to telling people about the work done! That's not very smart, but you know how it goes... :) But, then, if we don't tell people about awesome software that we have, nobody is going to use it, so finally I had to stop kicking this down the road, sit, and write the first post. It's been long overdue, so expect more posts soon! ONNX Runtime in one line of Clojure The most recent thing I'm currently working on started its life as Clojure ML (again, superthanks to Clojurists Together for sponsoring this). I proposed to create a human-friendly Clojure API for AI/DL/ML models, and back it by the first implementation, in this case based on ONNX Runtime. Of course, it should all be integrated into existing Clojure libraries, and follow the Clojure way of doing stuff as much as possible! The idea is to get an existing, pre-trained ML model previously exported to the ONNX format from whatever technology the authors chose (which in today's world is typically Python and PyTorch), and put it into production in Clojure and JVM. It should be seamless and in-process, without any clunky interoperability, copy, translation, etc. Of course, our Clojure numerical libraries fully support GPU computing, so it goes without saying that we want that, too! Just to be clear, we do not use nor need any Python or Python interop for this, we use the ONNX Runtime's underlying C library. Nice idea, but what parts of this well intended story can we evaluate in our REPLs right now? At least some promising demo? Are we on the trail? To access that AI goodness, we surely have to do a sophisticated dance? Are the steps hard to learn? Do we need to watch careful

## Remote VAEs for decoding with Inference Endpoints 🤗

DevFeed: [Remote VAEs for decoding with Inference Endpoints 🤗](<https://devfeed.tech/articles/remote-vaes-for-decoding-with-inference-endpoints-7456.md>)

Original publisher: [Read original article](<https://huggingface.co/blog/remote_vae>)

Author: hlky; Sayak Paul

Published: 2025-02-24T00:00:00Z

Content type: tutorial

Language: en

Sources: [Hugging Face - Blog](<https://devfeed.tech/sources/hugging-face-blog.md>)

Topics: [VAE](<https://devfeed.tech/topics/vae.md>), [inference-endpoints](<https://devfeed.tech/topics/inference-endpoints.md>), [diffusers](<https://devfeed.tech/topics/diffusers.md>), [hugging face](<https://devfeed.tech/topics/hugging-face.md>), [Inference Performance](<https://devfeed.tech/topics/inference-performance.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [data](<https://devfeed.tech/tags/data.md>), [diffusers](<https://devfeed.tech/tags/diffusers.md>), [diffusion](<https://devfeed.tech/tags/diffusion.md>), [generate](<https://devfeed.tech/tags/generate.md>), [generation](<https://devfeed.tech/tags/generation.md>), [getting-started](<https://devfeed.tech/tags/getting-started.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hdd](<https://devfeed.tech/tags/hdd.md>), [inference](<https://devfeed.tech/tags/inference.md>), [inference-endpoints](<https://devfeed.tech/tags/inference-endpoints.md>), [nvme](<https://devfeed.tech/tags/nvme.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [queue](<https://devfeed.tech/tags/queue.md>), [remote](<https://devfeed.tech/tags/remote.md>), [tensors](<https://devfeed.tech/tags/tensors.md>), [time](<https://devfeed.tech/tags/time.md>), [vae](<https://devfeed.tech/tags/vae.md>)

### AI overview

This article presents an experimental approach for decoding latent-space diffusion outputs with remote VAEs hosted on Inference Endpoints. It explains how remote decoding can reduce consumer GPU memory pressure, avoid the quality loss associated with tiled decoding, and improve concurrency by queueing generation requests. The article includes setup and usage examples for random tensors and pipelines involving SD v1.5, Flux, and HunyuanVideo.

### Source excerpt

We're on a journey to advance and democratize artificial intelligence through open source and open science.

## Visualize and understand GPU memory in PyTorch

DevFeed: [Visualize and understand GPU memory in PyTorch](<https://devfeed.tech/articles/visualize-and-understand-gpu-memory-in-pytorch-7532.md>)

Original publisher: [Read original article](<https://huggingface.co/blog/train_memory>)

Author: Quentin Gallouédec

Published: 2024-12-24T00:00:00Z

Content type: tutorial

Language: en

Sources: [Hugging Face - Blog](<https://devfeed.tech/sources/hugging-face-blog.md>)

Topics: [PyTorch](<https://devfeed.tech/topics/pytorch.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [Deep neural networks](<https://devfeed.tech/topics/deep-neural-networks.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [graph](<https://devfeed.tech/tags/graph.md>), [memory](<https://devfeed.tech/tags/memory.md>), [neural-networks](<https://devfeed.tech/tags/neural-networks.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>), [tensors](<https://devfeed.tech/tags/tensors.md>), [train](<https://devfeed.tech/tags/train.md>), [training](<https://devfeed.tech/tags/training.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

A tutorial on visualizing and understanding GPU memory usage in PyTorch during training. It explains how model creation, input and output tensors, activations, forward passes, backpropagation, and variable reassignment affect memory, and discusses estimating requirements and optimizing usage.

### Source excerpt

We're on a journey to advance and democratize artificial intelligence through open source and open science.

## Faster Dynamically Quantized Inference with XNNPack

DevFeed: [Faster Dynamically Quantized Inference with XNNPack](<https://devfeed.tech/articles/faster-dynamically-quantized-inference-with-xnnpack-7410.md>)

Original publisher: [Read original article](<https://blog.tensorflow.org/2024/04/faster-dynamically-quantized-inference-with-xnnpack.html>)

Author: TensorFlow Blog (noreply@blogger.com)

Published: 2024-04-09T16:00:00Z

Content type: article

Language: en

Sources: [The TensorFlow Blog](<https://devfeed.tech/sources/the-tensorflow-blog.md>)

Topics: [Inference Performance](<https://devfeed.tech/topics/inference-performance.md>), [quantization](<https://devfeed.tech/topics/quantization.md>), [TensorFlow Lite](<https://devfeed.tech/topics/tensorflow-lite.md>), [cpu](<https://devfeed.tech/topics/cpu.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [model-deployment](<https://devfeed.tech/topics/model-deployment.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [announcement](<https://devfeed.tech/tags/announcement.md>), [article](<https://devfeed.tech/tags/article.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [inference](<https://devfeed.tech/tags/inference.md>), [inference-performance](<https://devfeed.tech/tags/inference-performance.md>), [learn](<https://devfeed.tech/tags/learn.md>), [ml](<https://devfeed.tech/tags/ml.md>), [performance](<https://devfeed.tech/tags/performance.md>), [precision](<https://devfeed.tech/tags/precision.md>), [quantization](<https://devfeed.tech/tags/quantization.md>), [range](<https://devfeed.tech/tags/range.md>), [scale](<https://devfeed.tech/tags/scale.md>), [tensorflow](<https://devfeed.tech/tags/tensorflow.md>), [tensorflow-lite](<https://devfeed.tech/tags/tensorflow-lite.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

This article explains how dynamic range quantization for XNNPack's Fully Connected and Convolution 2D operators improves CPU inference performance in TensorFlow Lite. The approach quantizes weights to 8-bit integers during model conversion and dynamically quantizes activations during inference, delivering most of the performance benefits of full quantization while retaining higher overall accuracy. The article reports a fourfold performance improvement over the single-precision baseline and describes how this can enable AI-powered features on older and lower-tier devices.

### Source excerpt

Posted by Alan Kelly, Software Engineer We are excited to announce that XNNPack's Fully Connected and Convolution 2D operators now support dynamic range quantization. XNNPack is TensorFlow Lite's CPU backend and CPUs deliver the widest reach for ML inference and remain the default target for TensorFlow Lite. Consequently, improving CPU inference performance is a top priority. We quadrupled inference performance in TensorFlow Lite's XNNPack backend compared to the single precision baseline by adding support for dynamic range quantization to the Fully Connected and Convolution operators. This means that more AI powered features may be deployed to older and lower tier devices. Previously, XNNPack offered users the choice between either full integer quantization, where the weights and activations are stored as signed 8-bit integers, or half-precision (fp16) or single-precision (fp32) floating-point inference. In this article we demonstrate the benefits of dynamic range quantization. Dynamic Range Quantization Dynamically quantized models are similar to fully-quantized models in that the weights for the Fully Connected and Convolution operators are quantized to 8-bit integers during model conversion. All other tensors are not quantized, they remain as float32 tensors. During model inference, the floating-point layer activations are converted to 8-bit integers before being passed to the Fully Connected and Convolution operators. The quantization parameters (the zero point and scale) for each row of the activation tensor are calculated dynamically based on the observed range of activations. This maximizes the accuracy of the quantization process as the activations make full use of the 8 quantized bits. In fully-quantized models, these parameters are fixed during model conversion, based on the range of the activation values observed using a representative dataset. The second difference between full quantization and dynamic range quantization is that the output of the Fully

## Hello Deep Learning: Hyperparameters, inspection, parallelism, ADAM

DevFeed: [Hello Deep Learning: Hyperparameters, inspection, parallelism, ADAM](<https://devfeed.tech/articles/hello-deep-learning-hyperparameters-inspection-parallelism-adam-36445.md>)

Original publisher: [Read original article](<https://berthub.eu/articles/posts/hyperparameters-inspection-adam/>)

Published: 2023-03-30T10:00:06Z

Content type: tutorial

Language: en

Sources: [Bert Hubert's writings](<https://devfeed.tech/sources/bert-hubert-s-writings.md>)

Topics: [Deep learning](<https://devfeed.tech/topics/deep-learning.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [parallel](<https://devfeed.tech/topics/parallel.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [cpu](<https://devfeed.tech/topics/cpu.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [cpu](<https://devfeed.tech/tags/cpu.md>), [deep-learning](<https://devfeed.tech/tags/deep-learning.md>), [faster](<https://devfeed.tech/tags/faster.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [matrices](<https://devfeed.tech/tags/matrices.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

A Hello Deep Learning tutorial explains how neural networks can train faster through parallel computation, including batched tensor operations, GPU capacity, CPU SIMD instructions, multiple CPU cores, and distributed processing. It also begins discussing network parameter inspection and matrix multiplication.

### Source excerpt

This page is part of the Hello Deep Learning series of blog posts. You are very welcome to improve this page via GitHub! In the previous chapter we successfully trained a network to recognize handwritten letters, but it took an awfully long time. This is not just inconvenient: networks that take too long to train mean we can experiment less. Some things really are out of reach if each iteration takes 24 hours, instead of 15 minutes.

## Vespa Product Updates, December 2018 - ONNX Import and Map Attribute Grouping

DevFeed: [Vespa Product Updates, December 2018 - ONNX Import and Map Attribute Grouping](<https://devfeed.tech/articles/vespa-product-updates-december-2018-onnx-import-and-map-attribute-grouping-20495.md>)

Original publisher: [Read original article](<https://yahooeng.tumblr.com/post/181089393751>)

Author: amberwilsonla-blog

Published: 2018-12-13T22:18:41Z

Content type: release

Language: en

Sources: [Yahoo](<https://devfeed.tech/sources/yahoo.md>)

Topics: [onnx](<https://devfeed.tech/topics/onnx.md>), [AI Models](<https://devfeed.tech/topics/ai-models.md>), [API](<https://devfeed.tech/topics/api.md>), [ci](<https://devfeed.tech/topics/ci.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>)

Tags: [cost](<https://devfeed.tech/tags/cost.md>), [format](<https://devfeed.tech/tags/format.md>), [import](<https://devfeed.tech/tags/import.md>), [maps](<https://devfeed.tech/tags/maps.md>), [onnx](<https://devfeed.tech/tags/onnx.md>), [streaming](<https://devfeed.tech/tags/streaming.md>), [tensorflow](<https://devfeed.tech/tags/tensorflow.md>), [tensors](<https://devfeed.tech/tags/tensors.md>), [yahoo-engineering](<https://devfeed.tech/tags/yahoo-engineering.md>)

### AI overview

This Vespa product update covers improved Streaming Search performance, ONNX model importing and conversion to Tensors for ranking, more precise transaction log pruning during restarts, and grouping on map attribute fields.

### Source excerpt

yahoodevelopers: Today we're kicking off a blog post series of need-to-know updates on Vespa, summarizing the features and fixes detailed in Github issues. We welcome your contributions and feedback about any new features or improvements you'd like to see. For December, we're excited to share the following product news: Streaming Search Performance Improvement Streaming Search is a solution for applications where each query only searches a small, statically determined subset of the corpus. In this case, Vespa searches without building reverse indexes, reducing storage cost and making writes more efficient. With the latest changes, the document type is used to further limit data scanning, resulting in lower latencies and higher throughput. Read more here. ONNX Integration ONNX is an open ecosystem for interchangeable AI models. Vespa now supports importing models in the ONNX format and transforming the models into Tensors for use in ranking. This adds to the TensorFlow import included earlier this year and allows Vespa to support many training tools. While Vespa's strength is real-time model evaluation over large datasets, to get started using single data points, try the stateless model evaluation API. Explore this integration more in Ranking with ONNX models. Precise Transaction Log Pruning Vespa is built for large applications running continuous integration and deployment. This means nodes restart often for software upgrades, and node restart time matters. A common pattern is serving while restarting hosts one by one. Vespa has optimized transaction log pruning with prepareRestart, due to flushing as much as possible before stopping, which is quicker than replaying the same data after restarting. This feature is on by default. Learn more in live upgrade and prepareRestart. Grouping on Maps Grouping is used to implement faceting. Vespa has added support to group using map attribute fields, creating a group for values whose keys match the specified key, or field valu

## Tensorphobia and the Outer Product

DevFeed: [Tensorphobia and the Outer Product](<https://devfeed.tech/articles/tensorphobia-and-the-outer-product-40397.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2016/03/28/tensorphobia-outer-product/>)

Published: 2016-03-28T09:00:46Z

Content type: article

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [math](<https://devfeed.tech/topics/math.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [linear-algebra](<https://devfeed.tech/tags/linear-algebra.md>), [math](<https://devfeed.tech/tags/math.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [matrices](<https://devfeed.tech/tags/matrices.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [primer](<https://devfeed.tech/tags/primer.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

An explanation of the outer product of vectors, connecting modern tensor concepts with practical linear algebra. The article develops why the construction of two vectors as a linear map should be understood as natural or canonical.

### Source excerpt

Variations on a theme Back in 2014 I wrote a post called How to Conquer Tensorphobia that should end up on Math $ \cap$ Programming's "greatest hits" album. One aspect of tensors I neglected to discuss was the connection between the modern views of tensors and the practical views of linear algebra. I feel I need to write this because every year or two I forget why it makes sense.

## Multiple Qubits and the Quantum Circuit

DevFeed: [Multiple Qubits and the Quantum Circuit](<https://devfeed.tech/articles/multiple-qubits-and-the-quantum-circuit-40374.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2015/01/26/multiple-qubits-and-the-quantum-circuit/>)

Published: 2015-01-26T09:00:00Z

Content type: article

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [circuit](<https://devfeed.tech/topics/circuit.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [bits](<https://devfeed.tech/tags/bits.md>), [circuits](<https://devfeed.tech/tags/circuits.md>), [entanglement](<https://devfeed.tech/tags/entanglement.md>), [linear-algebra](<https://devfeed.tech/tags/linear-algebra.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [physics](<https://devfeed.tech/tags/physics.md>), [quantum](<https://devfeed.tech/tags/quantum.md>), [quantum-computing](<https://devfeed.tech/tags/quantum-computing.md>), [tensor-product](<https://devfeed.tech/tags/tensor-product.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

This article explains why the tensor product is the natural mathematical representation of the joint state of multiple qubits. It also introduces basic quantum gates and the definition of a quantum circuit.

### Source excerpt

Last time we left off with the tantalizing question: how do you do a quantum "AND" operation on two qubits? In this post we'll see why the tensor product is the natural mathematical way to represent the joint state of multiple qubits. Then we'll define some basic quantum gates, and present the definition of a quantum circuit. Working with Multiple Qubits In a classical system, if you have two bits with values $ b_1, b_2$, then the "joint state" of the two bits is given by the concatenated string $ b_1b_2$.