# onnx

ONNX is a model-sharing and interoperability technology that defines extensible computation graphs, built-in operators, and standard data types for use across AI frameworks.

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

## A Practical Loop for Optimizing GPU Inference Throughput

DevFeed: [A Practical Loop for Optimizing GPU Inference Throughput](<https://devfeed.tech/articles/why-100-gpu-util-wasn-t-enough-22606.md>)

Original publisher: [Read original article](<https://medium.com/bumble-tech/why-100-gpu-util-wasnt-enough-d386d3979cb9?source=rss----6353b5325b1a---4>)

Author: Andrei Potapkin

Published: 2026-05-01T17:57:59Z

Content type: article

Language: en

Sources: [Bumble Tech](<https://devfeed.tech/sources/bumble-tech.md>)

Topics: [Inference](<https://devfeed.tech/topics/inference.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [TensorRT](<https://devfeed.tech/topics/tensorrt.md>), [onnx](<https://devfeed.tech/topics/onnx.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [migration](<https://devfeed.tech/topics/migration.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-migration](<https://devfeed.tech/tags/cloud-migration.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [inference](<https://devfeed.tech/tags/inference.md>), [nvidia-nsight-systems](<https://devfeed.tech/tags/nvidia-nsight-systems.md>), [onnx](<https://devfeed.tech/tags/onnx.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [python](<https://devfeed.tech/tags/python.md>), [tensorrt](<https://devfeed.tech/tags/tensorrt.md>)

### AI overview

This practical article describes a production-focused loop for optimizing GPU inference: benchmark under representative load, identify the current throughput bottleneck, fix it, and verify the operational outcome. In the described ML moderation service, TensorRT, BF16, and an attention-subgraph rewrite increased throughput from roughly 150 to roughly 1100 requests per second in the same saturated benchmark.

### Source excerpt

A practical loop for optimizing GPU inference without guessing It wasn't an incident. That made it interesting. A few days after a cloud migration, one of our highest-traffic ML services looked healthy. Traffic was flowing. Latency was fine. The rollout had gone the way you want these things to go: boringly. And yet a Slack thread started anyway. Not because anything was broken. Because something had become easier to see. On-prem, GPU efficiency tends to get folded into bigger conversations: capacity planning, hardware timelines, headroom for the next model. In the cloud, the same question sharpens. Throughput, utilization, and cost sit much closer together. A service can be perfectly healthy and still look expensive. That was our situation. We had a frontend text moderation model based on mT5, served through NVIDIA Triton as a two-component ensemble: a Python tokenizer and a static ONNX model. The service was stable, but throughput per GPU was much lower than our back-of-the-envelope estimates suggested Moments like that attract the usual optimization advice: Batch more aggressively. Tune Triton. Rewrite the Python stages. Enable TensorRT. Drop precision. None of that advice is silly. Some of it is very good. The problem is that it usually arrives before the diagnosis. GPU systems are awkward that way. By the time you go hunting for "the optimization", you are often already asking the wrong question. There usually isn't one magical fix. There is a bottleneck somewhere in the stack, and then another one behind it, and usually another one behind that. The loop that kept us honest was simple: TL;DR Benchmark the system under production-shaped load. Find the bottleneck limiting throughput right now. Fix that bottleneck. Check whether the operational outcome changed. In our case, that loop took us from roughly 150 requests per second to roughly 1100 in the same saturated benchmark: a bit over 7x baseline. TensorRT delivered the first big jump. BF16 moved the ceiling aga

## 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.

## Using Large ONNX Models with External Data in Vespa Embedders

DevFeed: [Using Large ONNX Models with External Data in Vespa Embedders](<https://devfeed.tech/articles/using-large-onnx-models-with-external-data-in-vespa-embedders-12794.md>)

Original publisher: [Read original article](<https://blog.vespa.ai/onnx-external-data-in-vespa-embedders/>)

Author: bjorncs thomas

Published: 2026-03-27T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [onnx](<https://devfeed.tech/topics/onnx.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [embedding](<https://devfeed.tech/tags/embedding.md>), [files](<https://devfeed.tech/tags/files.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [models](<https://devfeed.tech/tags/models.md>), [onnx](<https://devfeed.tech/tags/onnx.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [serialization-format](<https://devfeed.tech/tags/serialization-format.md>)

### AI overview

Vespa embedders now support large ONNX models whose weights are stored in external data files. Starting with Vespa 8.544, Vespa automatically downloads referenced external files when loading URL-based models, with support for private models through propagated authentication tokens. The feature is limited to embedders and supported model references.

### Source excerpt

Many ONNX models exceed the 2GB protobuf limit and store weights in external data files. Vespa now supports these models for embedders.

## Gemma 3 AI model in Clojure

DevFeed: [Gemma 3 AI model in Clojure](<https://devfeed.tech/articles/gemma-3-ai-model-in-clojure-20729.md>)

Original publisher: [Read original article](<http://dragan.rocks/articles/25/Gemma-3-AI-model-in-Clojure>)

Published: 2025-12-09T22:35:00Z

Content type: tutorial

Language: en

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

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Inference](<https://devfeed.tech/topics/inference.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [onnx](<https://devfeed.tech/topics/onnx.md>), [gemma](<https://devfeed.tech/topics/gemma.md>)

Tags: [3](<https://devfeed.tech/tags/3.md>), [ai](<https://devfeed.tech/tags/ai.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [deep](<https://devfeed.tech/tags/deep.md>), [diamond](<https://devfeed.tech/tags/diamond.md>), [gemma](<https://devfeed.tech/tags/gemma.md>), [inference](<https://devfeed.tech/tags/inference.md>), [llms](<https://devfeed.tech/tags/llms.md>), [onnx](<https://devfeed.tech/tags/onnx.md>)

### AI overview

This tutorial demonstrates loading and running a one-step Gemma 3 inference in Clojure through the ONNX runtime integration in Deep Diamond. It configures a smaller one-billion-parameter model, uses main-memory tensors with the oneDNN engine, and explains that the demonstrated output is a next-token tensor rather than a complete generated response.

### Source excerpt

Recently I've been working on the ONNX runtime integration into Deep Diamond, backed by the grant sponsored by the Clojurists Together Foundation. In the past few articles, we've seen how ONNX models are integrated into Deep Diamond, using only a single function onnx, with almost no need for additional configuration (which is available). I used a simple MNIST model in the demonstration. But, can we now load and run the inference on the real deal models, such as the open LLMs from the Hugging Face, for example? Let's see! The Hugging Face model card has this to say about Gemma 3: "Gemma is a family of lightweight, state-of-the-art open models from Google, built from the same research and technology used to create the Gemini models." (etc., etc.) So, it seems to be something worth trying. I'll try to be brief, and skip the unnecessary talk. Let's just show the code, which I've just lifted up and adapted from the Diamond's midje tests. What we need for this? First, decide on the backend engine; this time we'll use tensors in main memory backed up by the oneDNN engine (DNNL). (def fact (dnnl-factory)) (def neand-fact (neanderthal-factory fact)) Next, load and configure a particular flavor of Gemma 3 (a smaller one, only 1 billion parameters). The onnx function creates a generalized blueprint, which can create the actual functions when evaluated with the specific input tensors. (def onnx-bp (onnx fact "data/gemma-3-1b-it-ONNX-GQA/onnx/model.onnx" {:options (-> (options) (override-dimension! "batch_size" 1) (override-dimension! "sequence_length" 1) (override-dimension! "past_sequence_length" 1) (override-dimension! "total_sequence_length" 1))}) Gemma 3 has 63 inputs and 61 outputs. We'll need to provide these, but even here we can automate some parts with Clojure, since past-key values are pretty uniform. We only need to provide inputs, while the engine can create the outputs for us. (def src-tz (tensor fact [1 1 28 28] :float :nchw)) (def input-ids (tensor neand-fact [1

## 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

## 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

## Welcome EmbeddingGemma, Google's new efficient embedding model

DevFeed: [Welcome EmbeddingGemma, Google's new efficient embedding model](<https://devfeed.tech/articles/welcome-embeddinggemma-google-s-new-efficient-embedding-model-7180.md>)

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

Author: Tom Aarsen; Joshua; Alvaro Bartolome; Aritra Roy Gosthipaty; Pedro Cuenca; Sergio Paniego

Published: 2025-09-04T00:00:00Z

Content type: article

Language: en

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

Topics: [Embeddings](<https://devfeed.tech/topics/embeddings.md>), [sentence-transformers](<https://devfeed.tech/topics/sentence-transformers.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Google](<https://devfeed.tech/topics/google.md>), [Retrieval-Augmented Generation](<https://devfeed.tech/topics/retrieval-augmented-generation.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [transformers.js](<https://devfeed.tech/topics/transformers-js.md>), [Inference](<https://devfeed.tech/topics/inference.md>), [onnx](<https://devfeed.tech/topics/onnx.md>), [dataset](<https://devfeed.tech/topics/dataset.md>), [LangChain](<https://devfeed.tech/topics/langchain.md>), [llamaindex](<https://devfeed.tech/topics/llamaindex.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [community](<https://devfeed.tech/tags/community.md>), [embedding](<https://devfeed.tech/tags/embedding.md>), [google](<https://devfeed.tech/tags/google.md>), [guide](<https://devfeed.tech/tags/guide.md>), [langchain](<https://devfeed.tech/tags/langchain.md>), [llamaindex](<https://devfeed.tech/tags/llamaindex.md>), [nlp](<https://devfeed.tech/tags/nlp.md>), [on-device](<https://devfeed.tech/tags/on-device.md>), [onnx](<https://devfeed.tech/tags/onnx.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [rag](<https://devfeed.tech/tags/rag.md>), [sentence-transformers](<https://devfeed.tech/tags/sentence-transformers.md>), [transformers-js](<https://devfeed.tech/tags/transformers-js.md>)

### AI overview

Google introduces EmbeddingGemma, a compact multilingual embedding model designed for fast, efficient on-device use. The article covers its architecture, training, multilingual capabilities, benchmark performance, framework integrations, and domain fine-tuning for retrieval applications.

### Source excerpt

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

## KotlinDL 0.3: поддержка ONNX, Object Detection API, 20+ новых моделей в ModelHub, и много новых слоев

DevFeed: [KotlinDL 0.3: поддержка ONNX, Object Detection API, 20+ новых моделей в ModelHub, и много новых слоев](<https://devfeed.tech/articles/kotlindl-0-3-onnx-object-detection-api-20-modelhub-23937.md>)

Original publisher: [Read original article](<https://habr.com/ru/companies/JetBrains/articles/581462/>)

Author: zaleslaw (JetBrains)

Published: 2021-10-04T13:56:53Z

Content type: release

Language: ru

Sources: [JetBrains RU](<https://devfeed.tech/sources/jetbrains-ru.md>)

Topics: [onnx](<https://devfeed.tech/topics/onnx.md>), [object-detection](<https://devfeed.tech/topics/object-detection.md>), [Maven](<https://devfeed.tech/topics/maven.md>), [Maven Central](<https://devfeed.tech/topics/maven-central.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Keras](<https://devfeed.tech/topics/keras.md>), [PyTorch](<https://devfeed.tech/topics/pytorch.md>)

Tags: [big-data](<https://devfeed.tech/tags/big-data.md>), [central](<https://devfeed.tech/tags/central.md>), [deep-learning](<https://devfeed.tech/tags/deep-learning.md>), [fine-tuning](<https://devfeed.tech/tags/fine-tuning.md>), [image-recognition](<https://devfeed.tech/tags/image-recognition.md>), [keras](<https://devfeed.tech/tags/keras.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [maven-central](<https://devfeed.tech/tags/maven-central.md>), [object-detection](<https://devfeed.tech/tags/object-detection.md>), [onnx](<https://devfeed.tech/tags/onnx.md>), [onnx-runtime](<https://devfeed.tech/tags/onnx-runtime.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>), [tensorflow](<https://devfeed.tech/tags/tensorflow.md>)

### AI overview

This release article presents KotlinDL 0.3, adding ONNX model support through ONNX Runtime Java API, new ModelHub models, an experimental high-level image-recognition API, additional layers, and Maven Central availability. It also describes object-detection support and fine-tuning limitations for ONNX models.

### Source excerpt

Представляем версию 0.3 библиотеки глубокого обучения KotlinDL! Вас ждет множество новых фич: новые модели в ModelHub (включая модели для обнаружения объектов и распознавания лиц), возможность дообучать модели распознавания изображений, экспортированные из Keras и PyTorch в ONNX, экспериментальный высокоуровневый API для распознавания изображений и множество новых слоев, добавленных контрибьюторами. Также KotlinDL теперь доступен в Maven Central. В этой статье мы коснемся самых главных изменений релиза 0.3. Полный список изменений доступен по ссылке. Узнать больше о релизе

## 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