May 2022 – Vedere AI

Seamlessly connect Amazon Athena with Amazon Lookout for Metrics to detect anomalies

Amazon Lookout for Metrics is an AWS service that uses machine learning (ML) to automatically monitor the metrics that are most important to businesses with greater speed and accuracy. The service also makes it easier to diagnose the root cause of anomalies, such as unexpected dips in revenue, high rates of abandoned shopping carts, spikes in payment transaction failures, increases in new user sign-ups, and many more. Lookout for Metrics goes beyond simple anomaly detection. It allows developers to set up autonomous monitoring for important metrics to detect anomalies and identify their root cause in a matter of a few clicks to detect anomalies in its metrics—all with no ML experience required.

Amazon Athena is an interactive query service that makes it easy to analyze data in Amazon Simple Storage Service (Amazon S3) using standard SQL. Simply point to your data in Amazon S3, define the schema, and start querying using standard SQL. Most results are delivered within seconds. With Athena, there’s no need for complex ETL jobs to prepare your data for analysis. This makes it easy for anyone with SQL skills to quickly analyze large-scale datasets.

With today’s launch, Lookout for Metrics can now seamlessly connect to your data in Athena to set up highly accurate anomaly detectors. This lets you quickly deploy state-of-the-art anomaly detection via ML with Lookout for Metrics against any datasets that are available in Athena.

Athena connectivity extends the capabilities of Lookout for Metrics by bringing the following benefits:

It extends the capabilities of Lookout for Metrics in terms of filetype support. Prior to this, Lookout for Metrics supported CSV and JSONLines formatted files, but with Athena this has been expanded to Parquet, Avro, Plaintext, and more. If you can parse it via Athena, then it’s now possible to import and leverage with Lookout for Metrics.
It also introduces support for data with federated queries. Prior to this launch, if your data was stored in multiple databases or sources, you would need to define a complete complex ETL process as well as manage its performance characteristics before you could export all of the data into a CSV or JSONLines file and input it into Lookout for Metrics for Anomaly Detection. With federated queries from Athena, you define the disparate sources as well as how the join should be performed and when the data has been processed and can be queried by Athena, it’s immediately ready for Lookout for Metrics. This enables you to hand over the burden for data transformation, aggregation, and delivery location to Athena and just focus on the identified anomalies from Lookout for Metrics.

Solution overview

In this post, we demonstrate how to integrate an Athena table and detect anomalies in the revenue metrics. We also track how order rate and inventory metrics are impacted. The source data lies in Amazon S3 and we’ve configured Athena tables to be able to query the data in it. An AWS Lambda is responsible for updating the partitions within Athena, which are used by Lookout for Metrics to detect anomalies. This solution enables you to use an Athena data source for Lookout for Metrics.

You could use the provided AWS CloudFormation stack to set up resources for the walkthrough. It contains resources to continuously generate live data and makes them query-able in Athena.

Launch the stack from the following link and select next on the Create Stack page.
On the Specify stack details page, add the values from above, give it a Stack name (for example, L4MAthenaDetector), and select Next.
On the Configure stack options page, leave everything as-is and select Next.

Set up a new detector with Athena as the data source

Step 1

Log in to the AWS Console to get started with creating an Anomaly Detector with Lookout for Metrics. The first step is to select the “Create detector” button.

Step 2

Fill out the mandatory detector fields like name. Select the detection interval for the detector, which is determined by the frequency at which you want Lookout for Metrics to query your data and monitor them for anomalies. Encryption information is not mandatory. Encryption information allows Lookout for Metrics to encrypt your data using your AWS Key Management Service (KMS) key. In this example, we’ll skip adding an encryption key, Lookout for Metrics would use default encryption to encrypt your data if no encryption information is provided, and proceed by selecting the “Create” button.

Step 3

Upon creation of the anomaly detector, you’ll see confirmation in a banner at the top. You can proceed by selecting “Add a dataset” through either the banner or the button under “Add a dataset”.

Fill out the basic information for the data source. Timezone is an optional field. Select the dropdown to select a data source.

Lookout for Metrics supports multiple data sources as a convenience for customers. For this example, we’ll select Athena.

Once Athena is selected as the data source, you’ll have the option of selecting Backtest or Continuous mode for the detector. For this example, we’ll proceed by using the Continuous mode. Proceed by adding details for the Athena table that you want to monitor for anomalies.

You can allow the service to create a Service role or you could use an existing AWS Identity and Access Management (IAM) role in your account for federated queries. Note that Lookout for Metrics doesn’t support automated creation of IAM roles for federated queries. Therefore, you would have to create a new IAM role to allow Athena to perform the following actions on your data,

CreatePreparedStatement
GetPreparedStatement
GetQueryResultsStream
DeletePreparedStatement
GetDatabase
GetQueryResults
GetWorkGroup
GetTableMetadata
StartQueryExecution
GetQueryExecution

The IAM role created by the service looks like the following:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": [
        "glue:GetTable",
        "glue:GetDatabase",
        "glue:GetPartitions"
      ],
      "Resource": [
        "arn:aws:glue:us-east-1:111122223333:catalog",
        "arn:aws:glue:us-east-1:111122223333:database/sample_db",
        "arn:aws:glue:us-east-1:111122223333:table/sample_db/*"
      ],
      "Effect": "Allow"
    },
    {
      "Action": [
        "athena:CreatePreparedStatement",
        "athena:GetPreparedStatement",
        "athena:GetQueryResultsStream",
        "athena:DeletePreparedStatement",
        "athena:GetDatabase",
        "athena:GetQueryResults",
        "athena:GetWorkGroup",
        "athena:GetTableMetadata",
        "athena:StartQueryExecution",
        "athena:GetQueryExecution"
      ],
      "Resource": [
          "arn:aws:athena:us-east-1:111122223333:datacatalog/AWSDataCatalog",
          "arn:aws:athena:us-east-1:111122223333:workgroup/sampleWorkgroup"
      ],
      "Effect": "Allow"
    },
    {
      "Action": [
        "s3:GetObject",
        "s3:ListBucket",
        "s3:PutObject",
        "s3:GetBucketLocation",
        "s3:ListBucketMultipartUploads",
        "s3:ListMultipartUploadParts",
        "s3:AbortMultipartUpload"
      ],
      "Resource": [
        "arn:aws:s3:::sample-data-bucket",
        "arn:aws:s3:::sample-results-bucket",
        "arn:aws:s3:::sample-data-bucket/*",
        "arn:aws:s3:::sample-results-bucket/*"
      ],
      "Effect": "Allow"
    },
    {
      "Effect": "Allow",
      "Action": [
        "kms:GenerateDataKey",
        "kms:Decrypt"
      ],
      "Resource": [
        "*"
      ],
      "Condition": {
        "ForAllValues:StringEquals": {
          "kms:ViaService": "s3.us-east-1.amazonaws.com",
          "kms:CallerAccount": [
            "111122223333"
          ]
        }
      }
    }
  ]
}

Step 4

Now we’ll define relevant metrics for the detector. Lookout for Metrics will populate the drop-downs with the columns present in the supplied Athena table. You can select up to five metrics and five dimensions. Lookout for Metrics requires the data in your table to be partitioned as timestamps for the timestamp column. You will also have an option to estimate the cost for this detector by adding the number of values across your dimensions.

Once you have selected all of the metrics, proceed by selecting the “Next” button. Review the details and select the “Save dataset” button to save the dataset.

Step 5

Once the dataset is created, we’ll activate the detector by either selecting the “Activate” button at the top or the “Activate Detector” button under the “How it works” section.

You’ll be prompted to confirm if you want to activate the detector for continuous detection. Select “Activate” to confirm.

You’ll see a confirmation informing that the detector is activating.

Step 6

Once the Anomaly Detector is Active, you can use the “Detector log” tab on the Detector details page to review detection executions that have been performed by the service.

Step 7

You can select the “View anomalies” button from the detector details page to manually inspect anomalies that may have been detected by the service.

Step 8

On the Anomalies review page, you can adjust the severity score threshold on the threshold dial to filter anomalies above a selected score.

Review and analyze the results

When detecting an anomaly, Lookout for Metrics helps you focus on what matters most by assigning a severity score to aid prioritization. To help you find the root cause, it intelligently groups anomalies that may be related to the same incident, and then summarizes the different sources of impact.

Lookout for Metrics also lets you provide real-time feedback on the relevance of detected anomalies, thereby enabling a powerful human-in-the-loop mechanism. This information is fed back to the anomaly detection model to improve its accuracy in near-real time.

Clean up

To avoid incurring additional charges for the resource set up for the demo, you can delete the created detector under Lookout for Metrics and the stack created via CloudFormation.

Conclusion

You can seamlessly connect to your data in Athena to Lookout for Metrics to set up highly accurate anomaly detector across metrics and dimensions within your Athena tables. To get started with this capability, see Using Amazon Athena with Lookout for Metrics. You can use this capability in all Regions where Lookout for Metrics is publicly available. For more information about Region availability, see AWS Regional Services.

About the Authors

Devesh Ratho is a Software Development Engineer in the Lookout for Metrics team. His interests lie in building scalable distributed systems. In his spare time, he enjoys sim racing.

Chris King is a Senior Solutions Architect in Applied AI with AWS. He has a special interest in launching AI services and helped grow and build Amazon Personalize and Amazon Forecast before focusing on Amazon Lookout for Metrics. In his spare time he enjoys cooking, reading, boxing, and building models to predict the outcome of combat sports.

The opportunity at home – can AI drive innovation in personal assistant devices and sign language?

The post The opportunity at home – can AI drive innovation in personal assistant devices and sign language? appeared first on The AI Blog.

The Closer: Machine Learning Helps Banks, Buyers Finalize Real Estate Transactions

The home-buying process can feel like an obstacle course — finding the perfect place, putting together an offer and, the biggest hurdle of all, securing a mortgage.

San Francisco-based real-estate technology company Doma is helping prospective homeowners clear that hurdle more quickly with the support of AI. Its machine learning models accelerate properties through the title search, underwriting and closing processes, helping complete home transactions up to 15 percent faster.

“There’s a lot of paperwork involved in this process,” said Brian Holligan, director of data science at Doma. “The better we are at using machine learning to identify different document types and extract relevant information, the faster and more seamless the process can be.”

Doma uses machine learning to identify different types of real estate documents and extract insights from those files. It’s also developing natural language understanding models to help everyone involved in a real estate transaction — from loan officers to real estate agents to homebuyers — rapidly interpret the numerous requests and inquiries that typically occur during the process.

Since its beginnings in 2016, Doma has accelerated over 100,000 real estate transactions with machine learning.

The company uses machine learning models — both transformer-based NLP tools and convolutional neural networks for computer vision — that rely on NVIDIA V100 Tensor Core GPUs through Microsoft Azure for model training.

“Working with a remote team, it’s nice to have the flexibility of GPUs in the cloud,” said Keesha Erickson, a data scientist at Doma. “We can spin up the right-sized machines based on the project or task at hand. If there’s a larger-scale model with a longer run time, we can grab the GPUs that are appropriate for the time constraints we’re under.”

Doma Machine Intelligence Delves Into Real Estate Docs

Once a seller and buyer have agreed on a purchase price for a home, they enter into a contract. But typically, a few weeks pass before keys actually change hands — a period known as escrow. During this process, the buyer’s mortgage loan is finalized and a title company investigates the home’s ownership, balance fees and tax history.

Doma’s GPU-accelerated machine learning models speed the title examination process by analyzing property records and mortgage files to help identify any risks that could disrupt the transaction.

Like other fields such as drug discovery or architecture, the real estate industry has jargon that a general NLP model may not be able to interpret. To tailor its AI to this lingo, Doma fine-tunes a suite of models, including BERT-based models, using a corpus of proprietary real estate data.

Doma’s technology also uses computer vision models to analyze older real estate documents. Many records come from county courthouses and clerk’s offices — and depending on the age of the home, records can be incredibly low-quality scans of paper documents that are decades old.

Doma machine learning engineer Juhi Chandalia, who works on machine learning models for this kind of document processing, found that using NVIDIA GPUs for inference cut the team’s time to insights by 4x, to under a minute.

“I’ve started training models on CPU instead of GPU before, and realized it would take weeks to complete,” Chandalia said. “My team relies on NVIDIA GPUs because otherwise, by the time we finished training and testing our machine learning models, they’d be out of date.”

Doma offers application programming interfaces, predefined integrations and custom versions of its platform to its lender partners. The company has teamed up with major mortgage lenders around the U.S., including Chase, Homepoint Financial, PennyMac and Sierra Pacific Mortgage, to accelerate the mortgage transaction and refinance process.

The company is also bringing some of its machine learning tools to individuals — real estate agents, buyers and sellers — to further streamline the complex process for all parties in a real estate transaction.

Learn more about how AI can help predict mortgage delinquencies, improve credit risk management and power banks of the future.

Subscribe to the latest financial services news from NVIDIA.

The post The Closer: Machine Learning Helps Banks, Buyers Finalize Real Estate Transactions appeared first on NVIDIA Blog.

Identifying causal effects is an integral part of scientific inquiry. It helps us understand everything from educational outcomes to the effects of social policies to risk factors for diseases. Questions of cause-and-effect are also critical for the design and data-driven evaluation of many technological systems we build today.

To help data scientists better understand and deploy causal inference, Microsoft researchers built a tool that implements the process of causal inference analysis from end to end. The ensuing DoWhy library has been doing just that since 2018 and has cultivated a community devoted to applying causal inference principles in data science. To broaden access to this critical knowledge base, DoWhy is migrating to an independent open-source governance model in a new PyWhy GitHub organization. As a first step toward this model, we are announcing a collaboration with Amazon Web Services (AWS), which is contributing new technology based on structural causal models.

What is causal inference?

The goal of conventional machine learning methods is to predict an outcome. In contrast, causal inference focuses on the effect of a decision or action—that is, the difference between the outcome if an action is completed versus not completed. For example, consider a public utility company seeking to reduce their customers’ usage of water through a marketing and rewards program. The effectiveness of a rewards program is difficult to ascertain, as any decrease in water usage by participating customers is confounded with their choice to participate in the program. If we observe that a rewards program member uses less water, how do we know whether it is the program that is incentivizing their lower water usage or if customers who were already planning to reduce water usage also chose to join the program? Given information about the drivers of customer behavior, causal methods can disentangle confounding factors and identify the effect of this rewards program.

How do we know when we have the right answer? The effect of an action like signing up for a customer loyalty program is typically not an observable value. For any given customer, we see only one of the two respective outcomes and cannot directly observe the difference the program made. This means that processes developed to validate conventional machine learning models—based on comparing predictions to observed, ground truths—cannot be used. Instead, we need new processes to gain confidence in the reliability of causal inference. Most critically, we need to capture our domain knowledge, reason about our modeling choices, then validate our core assumptions when possible and analyze the sensitivity of our results to violations of assumptions when validation is not possible.

Four steps of causal inference analysis

Data scientists just beginning to explore causal inference are most challenged by the new modeling assumptions of causal methods. DoWhy can help them understand and implement the process. The library focuses on the four steps of an end-to-end causal inference analysis, which are discussed in detail in a previous paper, DoWhy: an End-to-End Library for Causal Inference, and related blog post:

Modeling: Causal reasoning begins with the creation of a clear model of the causal assumptions being made. This involves documenting what is known about the data generating process and mechanisms. To get a valid answer to our cause-and-effect questions, we must be explicit about what we already know.

Identification: Next, we use the model to decide whether the causal question can be answered, and we provide the required expression to be computed. Identification is the process of analyzing our model.

Estimation: Once we have a strategy for identifying the causal effect, we can choose from several different statistical and machine learning-based estimation methods to answer our causal question. Estimation is the process of analyzing our data.

Refutation: Once we have our answer, we must do everything we can to test our underlying assumptions. Is our model consistent with the data? How sensitive is the answer to the assumptions made? If the model missed an unobserved confounder, will that change our answer a little or a lot?

This focus on the four steps of the end-to-end causal inference process differentiates the DoWhy library from prior causal inference toolkits. DoWhy complements other libraries—which focus on individual steps—and offers users the benefits of those libraries in a seamless, unified API. For example, for estimation, DoWhy offers the ability to call out to Microsoft’s EconML library for its advanced estimation methods.

Current DoWhy deployments

Today, DoWhy has been installed over one million times. It is widely deployed in production scenarios across industry and academia—from evaluating the effects of customer loyalty and marketing programs to identifying the controllable drivers of key business metrics. DoWhy’s rich API has enabled the creation of downstream solutions such as AutoCausality from Wise.com, which automates comparison of different methods, and ShowWhy from Microsoft, which provides a no-code GUI experience for causal inference analysis. In academia, DoWhy has been used in a range of research scenarios, including sustainable building design, environmental data analyses, and health studies. At Microsoft, we continue to use DoWhy to power causal analyses and test their validity, for example, estimating who benefits most from messages to avoid overcommunicating to large groups.

A community of more than 40 researchers and developers continually enrich the library with critical additions. Highly impactful contributions, such as customizable backdoor criterion implementation and a user-friendly Pandas integration, have come from external contributors. Instructors in courses and workshops around the world use DoWhy as a pedagogical tool to teach causal inference.

With such broad support, DoWhy continues to improve and expand. In addition to more complete implementations of identification algorithms and new sensitivity analysis methods, DoWhy has added experimental support for causal discovery and more powerful methods for testing the validity of a causal estimate. Using the four steps as a set of fundamental operations for causal analysis, DoWhy is now expanding into other tasks, such as representation learning.

Microsoft continues to expand the frontiers of causal learning through its research initiatives, with new approaches to robust learning, statistical advances for causal estimation, deep learning-based methods for end-to-end causal discovery and inference, and investigations into how causal learning can help with fairness, explainability and interpretability of machine learning models. As each of these technologies mature, we expect to make them available to the broader causal community through open source and product offerings.

An independent organization for DoWhy and other open-source causal inference projects

Making causality a pillar of data science practice requires an even broader, collaborative effort to create a standardized foundation for our industry.

To this end, we are happy to announce that we are shifting DoWhy into an independent open-source governance model, in a new PyWhy effort.

The mission of PyWhy is to build an open-source ecosystem for causal machine learning that advances the state of the art and makes it available to practitioners and researchers. In PyWhy, we will build and host interoperable libraries, tools, and other resources spanning a variety of causal tasks and applications, connected through a common API on foundational causal operations and a focus on the end-to-end analysis process.

Our first collaborator in this initiative is AWS, which is contributing new technology for causal attribution based on a structural causal model that complements DoWhy’s current functionalities.

We are looking forward to accelerating and broadening adoption of our open-source causal learning tools through this new Github organization. We invite data scientists, researchers, and engineers, whether you are just learning about causality or already designing new algorithms or even building your own tools, to join us on the open-source journey towards building a useful causal analysis ecosystem.

We encourage you to explore DoWhy and invite you to contact us to learn more. We are excited by what lies ahead as we aim to transform data science practice to drive improved modeling and decision making.

The post DoWhy evolves to independent PyWhy model to help causal inference grow appeared first on Microsoft Research.

AWS contributes novel causal machine learning algorithms to DoWhy

New features go beyond conventional effect estimation by attributing events to individual components of complex systems.Read More

Fantastical 3D Creatures Roar to Life ‘In the NVIDIA Studio’ With Artist Massimo Righi

Editor’s note: This post is part of our weekly In the NVIDIA Studio series, which celebrates featured artists, offers creative tips and tricks, and demonstrates how NVIDIA Studio technology accelerates creative workflows.

The year of the tiger comes into focus this week In the NVIDIA Studio, which welcomes 3D creature artist Massimo Righi.

An award-winning 3D artist with two decades of experience in the film industry, Righi has received multiple artist-of-the-month accolades and features in top creative publications. He’s also worked with clients including Autodesk, Discovery Channel, Google, Netflix and the World Wildlife Fund.

A sampling of Righi’s impressive 3D animal collection.

A native of Italy, Righi now lives in Thailand, a move he says was artistically inspired as he’s an avid lover of animals and nature. This is evident from his stunning portfolio of animal renders renowned for their lifelike photorealism and individualistic tone.

The story behind Waiting for the Year of the Tiger is a personal one for the artist.

“In my illustrations, I try to show the iconic image of that specific animal, or at least what’s my personal idea of that,” Righi says. “It’s a mix of my childhood vision with added real-life experience.”

Righi’s dedication to the craft means he often visits animal sanctuaries to observe and take pictures and video footage to use as reference.

The creative process begins in Autodesk Maya.

Righi’s creative workflow begins in Autodesk Maya on a Lenovo laptop powered by a GeForce RTX 3080 GPU. He creates a base model and unwrapping UV, translating 3D mesh into 2D data so a 2D texture can be wrapped around it.

Righi then uses custom brushes in ZBrush to sculpt the tiger in finer detail. With a mix of photos and custom brushes, Righi creates the main textures in Adobe Photoshop, using AI-powered Enhance Details technology, one of over a dozen GPU-accelerated features, to sharpen photo details before returning to Maya and applying new textures to the 3D model.

Deploying spline primitives across 10 different sections unlocks profound realism.

Righi prioritizes achieving a highly photorealistic look with detailed, lifelike fur, created with the XGen interactive groom editor within Maya. “Before starting, it’s very important to study the fur flow so that I can decide how many fur descriptions I would need,” Righi says. “The tiger, for example, has been made with 10 descriptions, such as main body, head, cheeks and whiskers.”

Righi’s fur creation technique adds stunning realism to his virtual animals.

Righi uses spline primitives — predefined shapes which provide a method for freehand drawing — manually placing and shaping the guides. Righi notes, “I usually create three or four clump modifiers and break them up with a few noise cuts, stray and maybe curl modifiers.”

The artist tinkers and tests in real time until he meets the desired output, then bakes the fur consisting of millions of spline primitives. This process is accelerated by a factor of 6x with his GeForce RTX 3080 GPU, saving valuable time.

With the model in a good place, Righi animates the scene in 3D using Blendshapes to interpolate the different sets of geometry. According to Righi, getting the little details right is critical to capturing the essence of lifelike movement. “Researching anatomy is equally important,” he says. “To get the right shapes and sculpt every detail, you need to take your time and study.”

Righi begins to test scene lighting. Here, the GPU-accelerated viewport enables incredibly smooth, interactive 3D modeling — another benefit of using the GeForce RTX 3080 GPU. Righi can tinker with the lighting, shadows, animations and more in real time, without having to wait for his system to catch up.

*Waiting for the Year of the Tiger* is complete.

Once final renders are ready to export, AI denoising with the default Autodesk Arnold renderer produces incredibly photorealistic renders that export up to 6x faster on Righi’s GPU-accelerated laptop than on a comparable unit with integrated graphics.

And like that, the year of the tiger is upon us.

Righi’s NVIDIA Studio-powered creative zone.

View Righi’s portfolio on ArtStation and his 3D models marketplace to see more of his work.

Animals and Creatures Inspire In the NVIDIA Studio

Talented artists who share Righi’s passion for design join us In the NVIDIA Studio. They share their artist and character-inspired 3D journeys, passing along valuable tips and tricks through tutorials.

Ringling College of Art and Design Professor Ana Carolina injects Greek mythology and lore in her fantasy-style Studio Session, How to Model & Render A 3D Fantasy Hippocampus Creature, offering an inside look at sculpting in Zbrush and applying colors in Adobe Substance 3D Painter.

Character concept artist Tadej Blažič’ shares his Blender tips and tricks in a two-part Studio Session tutorial. Part 1, Blender Tutorial: Create a Cute 3D Character Animation Part 1: Character Concept, covers 3D character animations, while Part 2, Modeling & Hair, demonstrates hair and fur techniques similar to Righi’s.

Freelancer Wesley Trankle’s six-part Studio Session tutorial, How to Create a 3D Animation Video, provides an in-depth look at the 3D journey. Videos cover a wide range of topics: Modeling Main Character, Character Rigging, Creating Environment, Animation, Texturing & Materials & Lighting and Final Touches.

Follow NVIDIA Studio on Instagram, Twitter and Facebook. Access tutorials on the Studio YouTube channel and get updates directly in your inbox by subscribing to the NVIDIA Studio newsletter.

The post Fantastical 3D Creatures Roar to Life ‘In the NVIDIA Studio’ With Artist Massimo Righi appeared first on NVIDIA Blog.

Language Model Pretraining

Language models (LMs), like BERT ¹ and the GPT series ², achieve remarkable performance on many natural language processing (NLP) tasks. They are now the foundation of today’s NLP systems. ³ These models serve important roles in products and tools that we use every day, such as search engines like Google ⁴ and personal assistants like Alexa ⁵.

These LMs are powerful because they can be pretrained via self-supervised learning on massive amounts of text data on the web without the need for labels, after which the pretrained models can be quickly adapted to a wide range of new tasks without much task-specific finetuning. For instance, BERT is pretrained to predict randomly masked words in original text (masked language modeling), e.g. predicting the masked word “dog” from “My __ is fetching the ball”. GPTs are pretrained to predict the next word given a previous sequence of text (causal language modeling), e.g. predicting the next word “ball” from “My dog is fetching the”. In either cases, through pretraining, LMs learn to encode various knowledge from a text corpus that helps to perform downstream applications involving language understanding or generation. In particular, LMs can learn world knowledge (associations between concepts like “dog”, “fetch”, “ball”) from training text where the concepts appear together, and help for knowledge-intensive applications like question answering. ⁶

Challenges.
A challenge with most common LM pretraining strategies is that they model a single document at a time. That is, one would split a text corpus into a list of documents and draw training instances for LMs from each document independently. Treating each document independently may pose limitations because documents often have rich dependencies with each other. For instance, text from the web ⁷ or scientific literature ⁸ is often used for LM training, but they all have document links, such as hyperlinks and citation links. Document links are crucial because knowledge can span across multiple documents beyond a single document. As an example, the Wikipedia article “Tidal Basin, Washington D.C.” shown on the left of the figure below describes that the basin hosts “National Cherry Blossom Festival”, and if we jump to the hyperlinked article shown on the right, we see that the festival celebrates “Japanese cherry trees”. Combined, the hyperlink offers new, multi-hop knowledge such as “Tidal Basin has Japanese cherry trees”, which is not available in the original single document alone.

Models that train without these dependencies may fail to capture knowledge or facts that are spread across multiple documents. Learning such multi-hop knowledge in pretraining can be important for various applications including question answering and knowledge discovery (e.g. “What trees can you see at the Tidal Basin?”). Indeed, document links like hyperlinks and citations are ubiquitous and we humans also use them all the time to learn new knowledge and make discoveries. A text corpus is thus not simply a list of documents but a graph of documents with links connecting each other.

In our recent work ⁹ published at ACL 2022, we develop a new pretraining method, LinkBERT, that incorporates such document link information to train language models with more world knowledge.

Approach: LinkBERT

At a high level, LinkBERT consists of three steps: (0) obtaining links between documents to build a document graph from the text corpus, (1) creating link-aware training instances from the graph by placing linked documents together, and finally (2) pretraining the LM with link-aware self-supervised tasks: masked language modeling (MLM) and document relation prediction (DRP).

Document Graph Construction.
Given a text corpus, we link related documents to make a graph so that the links can bring together useful knowledge. Although this graph can be derived in any way, we will focus on using hyperlinks and citation links as they generally have high quality of relevance (i.e. low false-positive rate) and are available ubiquitously at scale. ¹⁰ To make the document graph, we treat each document as a node, and add a directed edge (i, j) if there is a hyperlink from document i to document j.

Link-aware LM Input Creation.
Given the document graph, we then create link-aware inputs that will be fed into our LM. As LMs can learn token dependency effectively if the tokens are shown in the same input instance ¹¹, we want to place linked documents together in the input instance. In this way, the LM can learn multi-hop or multi-document dependencies of concepts as the LM will see training instances where these concepts appear together in the same sequence. To achieve this, we first chunk each document into segments of roughly 256 tokens, which is half of the maximum BERT LM input length. Then, we concatenate two segments (Segment A and B) together as an input sequence for the LM according to the links in the document graph. We have three options for how to choose segments to concatenate together:

Option 1: contiguous segments. Take two contiguous segments from the same document. This is essentially the same as previous LMs.
Option 2: random segments. Sample one segment from a random document and sample a second segment from another random document.
Option 3: linked segments. Sample one segment from a random document and sample a second segment randomly from a document linked to the first document in the document graph.
The reason we have these three options is to create a training signal for LinkBERT such that the model will learn to recognize relations between text segments. We will explain this in the next paragraph.

Link-aware LM Pretraining.
After creating input instances made up of pairs of segments, the last step is to use these created inputs to train the LM with link-aware self-supervised tasks. We consider the following two tasks:

Masked language modeling (MLM), which masks some tokens in the input text and then predicts the tokens using the surrounding tokens. This encourages the LM to learn multi-hop knowledge of concepts brought into the same context by document links. For instance, in our running example about Tidal Basin, the LM would be able to learn the multi-hop relations from “Tidal Basin” to “National Cherry Blossom Festival” to “Japanese cherry trees”, as these three concepts will be all presented together in the same training instances.
Document relation prediction (DRP), which makes the model classify the relation of Segment B to Segment A as to whether the two segments are contiguous, random or linked. This task encourages the LM to learn relevance and dependencies between documents, and also learn bridging concepts such as “National Cherry Blossom Festival” in our running example.

We pretrain the LM with these two objectives jointly.

We can also motivate these two pretraining tasks as performing self-supervised learning algorithms on the document graph:

Node feature prediction ¹², which is to predict masked features of a node using neighbor nodes. This corresponds to MLM, where we predict masked tokens in Segment A using Segment B and vice versa.
Link prediction ¹³, which is to predict the existence or type of an edge between two nodes. This corresponds to DRP, where we predict if two segments are linked (edge), contiguous (self-loop), or random (no edge).

Let’s use LinkBERT!

We will now see how LinkBERT performs on several downstream natural language processing tasks. We pretrained LinkBERT in two domains:

General domain: we use Wikipedia as the pretraining corpus, which is the same as previous language models like BERT, except that here we also use the hyperlinks between Wikipedia articles.
Biomedical domain: we use PubMed as the pretraining corpus, which is the same as previous biomedical language models like PubmedBERT ¹⁴, except that here we also use the citation links between PubMed articles.

LinkBERT improves previous BERT models on many applications.
We evaluated the pretrained LinkBERT models on diverse downstream tasks in each domain:

General question answering (MRQA) and general NLP (GLUE) benchmarks
Biomedical NLP (BLURB) and biomedical question answering (MedQA, MMLU) benchmarks.

LinkBERT improves the baseline language models pretrained without document links (i.e. BERT and PubmedBERT) consistently across tasks and domains. The gain for the biomedical domain is especially large, likely because scientific literature has crucial dependencies with each other via citation links, which are captured by LinkBERT. The biomedical LinkBERT, which we call BioLinkBERT, achieves new state-of-the-art performance on the BLURB, MedQA and MMLU benchmarks.

Effective for multi-hop reasoning.
LinkBERT exhibits several interesting strengths. The first strength is multi-hop reasoning. Within the MRQA benchmarks, there are several tasks that involve multi-hop reasoning such as HotpotQA and triviaQA, and we find that LinkBERT provides large improvements for BERT on those tasks. As an example, the figure below shows an example from HotpotQA. Answering the given question needs 2-hop reasoning because we need to know what organization took over Roden Brothers in 1953 (the first document), and then we need to know where that organization was headquartered (the second document). BERT tends to simply predict a location name that appears in the same document as the one about Roden Brothers (“Toronto”), but LinkBERT is able to correctly connect information across the two documents to predict the answer (“Montreal”). The intuition is that because LinkBERT brings together multiple related concepts/documents into the same input instances during pretraining, it helps the model to reason with multiple concepts/documents in downstream tasks.

Effective for document relation understanding.
Another strength of LinkBERT is that it can better model the relationships between multiple documents. For instance, in open-domain QA, a model must identify an answer from multiple retrieved documents, where many of the documents are likely noisy or otherwise unrelated to the question. ¹⁵ To simulate this, we added distracting documents to the original MRQA tasks such as SQuAD and HotpotQA. We find that LinkBERT is robust to irrelevant documents and maintains the QA accuracy, while BERT incurs a performance drop in this setup. Our intuition is that the Document Relation Prediction task used in pretraining helps recognizing document relevance in downstream tasks.

Effective for few-shot and data-efficient QA.
The third strength is few-shot and data-efficient QA. For each QA dataset, we tried finetuning LinkBERT or BERT with only 10% or 1% of the available training data. We find that LinkBERT provides large improvements for BERT on these low-resource paradigms. This finding suggests that LinkBERT has internalized more knowledge than BERT during pretraining, and supports the original intuition that document links can bring in new, useful knowledge for LMs.

Use LinkBERT for your own applications

LinkBERT can be used easily as a drop-in replacement for BERT. The pretrained LinkBERT models (LinkBERT and BioLinkBERT) are available on HuggingFace, and you can load them by

from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained('michiyasunaga/LinkBERT-large')
model = AutoModel.from_pretrained('michiyasunaga/LinkBERT-large')
inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
outputs = model(**inputs)

from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained('michiyasunaga/BioLinkBERT-large')
model = AutoModel.from_pretrained('michiyasunaga/BioLinkBERT-large')
inputs = tokenizer("Sunitinib is a tyrosine kinase inhibitor", return_tensors="pt")
outputs = model(**inputs)

To use LinkBERT for downstream applications such as question answering and text classification, you can use the finetuning scripts provided at https://github.com/michiyasunaga/LinkBERT, or simply replace the BERT model path with LinkBERT in your favorite BERT finetuning scripts.

Summary

We introduced LinkBERT, a new pretraining method that leverages document links such as hyperlinks and citations to train a knowledgeable language model (LM). Specifically, we place linked documents in the same LM input sequence, and train the LM with two joint self-supervised tasks: masked language modeling and document relation prediction.

LinkBERT can be used as a drop-in replacement for BERT. In addition to improving performance for general language understanding tasks (e.g. text classification), LinkBERT better captures document or concept relations, and is effective for multi-hop reasoning and cross-document understanding. LinkBERT also internalizes more world knowledge and is effective for knowledge-intensive tasks, such as few-shot question answering.

We release the pretrained LinkBERT models. We hope they can be helpful for your projects and research, especially knowledge or reasoning-intensive applications. Finally, we think that LinkBERT opens up many exciting future projects, such as generalizing to GPT or sequence-to-sequence ¹⁶ style language models to perform document link-aware text generation, and generalizing the notion of document links to other modalities, e.g., incorporating source code dependency links in the training of language models for code ¹⁷.

This blog post is based on the paper:

LinkBERT: Pretraining Language Models with Document Links. Michihiro Yasunaga, Jure Leskovec and Percy Liang. ACL 2022. The models, code, data are available on GitHub and HuggingFace.

If you have questions, please feel free to email us.

Michihiro Yasunaga: myasu@cs.stanford.edu

Acknowledgments

Many thanks to the members of the Stanford P-Lambda group, SNAP group and NLP group for their valuable feedback. Many thanks to Jacob Schreiber and Michael Zhang for edits on this blog post.

BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. Jacob Devlin, Ming-Wei Chang, Kenton Lee, Kristina Toutanova. 2019. ↩
Language Models are Few-Shot Learners. Tom B. Brown, et al. 2020. ↩
On the Opportunities and Risks of Foundation Models. Rishi Bommasani et al. 2021. ↩
Google uses BERT for its search engine: https://blog.google/products/search/search-language-understanding-bert/ ↩
Language Model is All You Need: Natural Language Understanding as Question Answering. Mahdi Namazifar et al. Alexa AI. 2020. ↩
Language Models as Knowledge Bases? Fabio Petroni, et al. 2019. COMET: Commonsense Transformers for Automatic Knowledge Graph Construction. Antoine Bosselut et al. 2019. ↩
For example, text corpora like Wikipedia and WebText are used for training BERT and GPTs. ↩
For example, text corpora like PubMed and Semantic Scholar are used for training language models in scientific domains, such as BioBERT and SciBERT. ↩
LinkBERT: Pretraining Language Models with Document Links. Michihiro Yasunaga, Jure Leskovec and Percy Liang. 2022. ↩
Hyperlinks have been found useful in various NLP research, e.g., Learning to Retrieve Reasoning Paths over Wikipedia Graph for Question Answering. Akari Asai, Kazuma Hashimoto, Hannaneh Hajishirzi, Richard Socher, Caiming Xiong. 2019. HTLM: Hyper-Text Pre-Training and Prompting of Language Models. Armen Aghajanyan, Dmytro Okhonko, Mike Lewis, Mandar Joshi, Hu Xu, Gargi Ghosh, Luke Zettlemoyer. 2022. ↩
The Inductive Bias of In-Context Learning: Rethinking Pretraining Example Design. Yoav Levine, Noam Wies, Daniel Jannai, Dan Navon, Yedid Hoshen, Amnon Shashua. 2022. ↩
Strategies for Pre-training Graph Neural Networks. Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay Pande, Jure Leskovec. 2020. ↩
Translating Embeddings for Modeling Multi-relational Data. Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, Oksana Yakhnenko. 2013. ↩
Domain-Specific Language Model Pretraining for Biomedical Natural Language Processing. Yu Gu, Robert Tinn, Hao Cheng, Michael Lucas, Naoto Usuyama, Xiaodong Liu, Tristan Naumann, Jianfeng Gao, Hoifung Poon. 2021. ↩
Reading Wikipedia to Answer Open-Domain Questions. Danqi Chen, Adam Fisch, Jason Weston, Antoine Bordes. 2017. ↩
For instance, BART and T5. ↩
Training language models for source code data is an active area of research, e.g., CodeX, AlphaCode. ↩

NVIDIA Accelerates AI, Digital Twins, Quantum Computing and Edge HPC at ISC 2022

Researchers grappling with today’s grand challenges are getting traction with accelerated computing, as showcased at ISC, Europe’s annual gathering of supercomputing experts.

Some are building digital twins to simulate new energy sources. Some use AI+HPC to peer deep into the human brain.

Others are taking HPC to the edge with highly sensitive instruments or accelerating simulations on hybrid quantum systems, said Ian Buck, vice president of accelerated computing at NVIDIA, at an ISC special address in Hamburg.

Delivering 10 AI Exaflops

For example, a new supercomputer at Los Alamos National Laboratory (LANL) called Venado will deliver 10 exaflops of AI performance to advance work in areas such as materials science and renewable energy.

LANL researchers target 30x speedups in their computational multi-physics applications with NVIDIA GPUs, CPUs and DPUs in the system, named after a peak in northern New Mexico.

Venado will use NVIDIA Grace Hopper Superchips to run workloads up to 3x faster than prior GPUs. It also packs NVIDIA Grace CPU Superchips to provide twice the performance per watt of traditional CPUs on a long tail of unaccelerated applications.

BlueField Gathers Momentum

The LANL system is among the latest of many around the world to embrace NVIDIA BlueField DPUs to offload and accelerate communications and storage tasks from host CPUs.

Similarly, the Texas Advanced Computing Center is adding BlueField-2 DPUs to the NVIDIA Quantum InfiniBand network on Lonestar6. It will become a development platform for cloud-native supercomputing, hosting multiple users and applications with bare-metal performance while securely isolating workloads.

“That’s the architecture of choice for next-generation supercomputing and HPC clouds,” said Buck.

Exascale in Europe

In Europe, NVIDIA and SiPearl are collaborating to expand the ecosystem of developers building exascale computing on Arm. The work will help the region’s users port applications to systems that use SiPearl’s Rhea and future Arm-based CPUs together with NVIDIA accelerated computing and networking technologies.

Japan’s Center for Computational Sciences, at the University of Tsukuba, is pairing NVIDIA H100 Tensor Core GPUs and x86 CPUs on an NVIDIA Quantum-2 InfiniBand platform. The new supercomputer will tackle jobs in climatology, astrophysics, big data, AI and more.

The new system will join the 71% on the latest TOP500 list of supercomputers that have adopted NVIDIA technologies. In addition, 80% of new systems on the list also use NVIDIA GPUs, networks or both and NVIDIA’s networking platform is the most popular interconnect for TOP500 systems.

HPC users adopt NVIDIA technologies because they deliver the highest application performance for established supercomputing workloads — simulation, machine learning, real-time edge processing — as well as emerging workloads like quantum simulations and digital twins.

Powering Up With Omniverse

Showing what these systems can do, Buck played a demo of a virtual fusion power plant that researchers in the U.K. Atomic Energy Authority and the University of Manchester are building in NVIDIA Omniverse. The digital twin aims to simulate in real time the entire power station, its robotic components — even the behavior of the fusion plasma at its core.

NVIDIA Omniverse, a 3D design collaboration and world simulation platform, lets distant researchers on the project work together in real time while using different 3D applications. They aim to enhance their work with NVIDIA Modulus, a framework for creating physics-informed AI models.

“It’s incredibly intricate work that’s paving the way for tomorrow’s clean renewable energy sources,” said Buck.

AI for Medical Imaging

Separately, Buck described how researchers created a library of 100,000 synthetic images of the human brain on NVIDIA Cambridge-1, a supercomputer dedicated to advances in healthcare with AI.

A team from King’s College London used MONAI, an AI framework for medical imaging, to generate lifelike images that can help researchers see how diseases like Parkinson’s develop.

“This is a great example of HPC+AI making a real contribution to the scientific and research community,” said Buck.

HPC at the Edge

Increasingly, HPC work extends beyond the supercomputer center. Observatories, satellites and new kinds of lab instruments need to stream and visualize data in real time.

For example, work in lightsheet microscopy at Lawrence Berkeley National Lab is using NVIDIA Clara Holoscan to see life in real time at nanometer scale, work that would require several days on CPUs.

To help bring supercomputing to the edge, NVIDIA is developing Holoscan for HPC, a highly scalable version of our imaging software to accelerate any scientific discovery. It will run across accelerated platforms from Jetson AGX modules and appliances to quad A100 servers.

“We can’t wait to see what researchers will do with this software,” said Buck.

Speeding Quantum Simulations

In yet another vector of supercomputing, Buck reported on the rapid adoption of NVIDIA cuQuantum, a software development kit to accelerate quantum circuit simulations on GPUs.

Dozens of organizations are already using it in research across many fields. It’s integrated into major quantum software frameworks so users can access GPU acceleration without any additional coding.

Most recently, AWS announced the availability of cuQuantum in its Braket service. And it demonstrated how cuQuantum can provide up to a 900x speedup on quantum machine learning workloads while reducing costs 3.5x.

“Quantum computing has tremendous potential, and simulating quantum computers on GPU supercomputers is essential to move us closer to valuable quantum computing” said Buck. “We’re really excited to be at the forefront of this work,” he added.

A video of the full address will be posted here Tuesday, March 31 at 9am PT.

The post NVIDIA Accelerates AI, Digital Twins, Quantum Computing and Edge HPC at ISC 2022 appeared first on NVIDIA Blog.

The Man With 100,000 Brains: AI’s Big Donation to Science

Jorge Cardoso wears many hats, and that’s appropriate given he has so many brains. A hundred thousand of them to be exact.

Cardoso is a teacher, a CTO, an entrepreneur, a founding member of the MONAI open source consortium and a researcher in AI for medical imaging. In that last role, Cardoso and his team just discovered ways to create realistic, high resolution 3D images of human brains with AI.

The researcher at King’s College London and CTO at the London AI Centre is making 100,000 synthetic brain images available free to healthcare researchers. It’s a treasure trove that could accelerate understanding of dementia, aging or any sort of brain disease.

Accelerating AI in Healthcare

“In the past, many researchers avoided working in healthcare because they couldn’t get enough good data, but now they can,” said Cardoso.

“We want to direct the energy of AI research into healthcare,” he said.

It’s a major donation compared to the world’s largest repository of freely available brain images. The UK Biobank currently maintains multiple brain images taken from more than 50,000 participants, curated at an estimated cost of $150 million.

Synthetic Data for Science

The images represent an emerging branch in healthcare of synthetic data, something that’s already widely used in computer vision for consumer and business apps. Ironically, those fields also have access to open datasets with millions of real-world images.

By contrast, medical images are relatively scarce, typically only available to researchers connected to large hospitals, given the need to protect patient privacy. Even then, medical images tend to reflect the demographics the hospital serves, not necessarily the broader population.

A fortunate feature of the new AI approach is it can make images to order. Female brains, male brains, old ones, young ones, brains with or without disease. Plug in what you need, and it creates them.

Though they’re simulated, the images are highly useful because they preserve key biological characteristics, so they look and act like real brains would.

Scaling with MONAI on Cambridge-1

The work required a supercomputer running super software.

NVIDIA Cambridge-1, a supercomputer dedicated to breakthrough AI research in healthcare, was the engine. MONAI, an AI framework for medical imaging, provided the software fuel.

Together they created an AI factory for synthetic data that let researchers run hundreds of experiments, choose the best AI models and run inference to generate images.

“We couldn’t have done this work without Cambridge-1 and MONAI, it just wouldn’t have happened,” Cardoso said.

Massive Images, Up to 10x Speedups

An NVIDIA DGX SuperPOD, Cambridge-1 packs 640 NVIDIA A100 Tensor Core GPUs, each with enough memory to process one or two of the team’s massive images made up of 16 million 3D pixels.

MONAI’s building blocks include domain-specific data loaders, metrics, GPU accelerated transforms and an optimized workflow engine. The software’s smart caching and multi-node scaling can accelerate jobs up to 10x, said Cardoso.

He also credited cuDNN and “the whole NVIDIA AI software stack that helped us work much faster.”

Beyond the Brain

Cardoso is working with Health Data Research UK, a national repository, to host the 100,000 brain images. The AI models will be available, too, so researchers can create whatever images they need.

There’s more. The team is exploring how the models can make 3D images of any part of the human anatomy in any mode of medical imaging — MRIs, CAT or PET scans, you name it.

“In fact, this technique can be applied to any volumetric image,” he said, noting users may need to optimize the models for different types of images.

Many Directions Ahead

The work points to many directions Cardoso described enthusiastically as if unloading the contents of multiple minds.

Synthetic images will help researchers see how diseases evolve over time. Meanwhile his team is still exploring how to apply the work to body parts beyond the brain and what kinds of synthetic images (MRI, CAT, PET) are most useful.

The possibilities are exciting and, like his many roles, “it can be a bit overwhelming,” he said. “There are so many different things we can start thinking about now.”

The post The Man With 100,000 Brains: AI’s Big Donation to Science appeared first on NVIDIA Blog.

The Road to the Hybrid Quantum-HPC Data Center Starts Here

It’s time to start building tomorrow’s hybrid quantum computers.

The motivation is compelling, the path is clear and key components for the job are available today.

Quantum computing has the potential to bust through some of today’s toughest challenges, advancing everything from drug discovery to weather forecasting. In short, quantum computing will play a huge role in HPC’s future.

Today’s Quantum Simulations

Creating that future won’t be easy, but the tools to get started are here.

Taking the first steps forward, today’s supercomputers are simulating quantum computing jobs at scale and performance levels beyond the reach of today’s relatively small, error-prone quantum systems.

Dozens of quantum organizations are already using the NVIDIA cuQuantum software development kit to accelerate their quantum circuit simulations on GPUs.

Most recently, AWS announced the availability of cuQuantum in its Braket service. It also demonstrated on Braket how cuQuantum can provide up to a 900x speedup on quantum machine learning workloads.

And cuQuantum now enables accelerated computing on the major quantum software frameworks, including Google’s qsim, IBM’s Qiskit Aer, Xanadu’s PennyLane and Classiq’s Quantum Algorithm Design platform. That means users of those frameworks can access GPU acceleration without any additional coding.

Quantum-Powered Drug Discovery

Today, Menten AI joins companies using cuQuantum to support its quantum work.

The Bay Area drug-discovery startup will use cuQuantum’s tensor network library to simulate protein interactions and optimize new drug molecules. It aims to harness the potential of quantum computing to speed up drug design, a field that, like chemistry itself, is thought to be among the first to benefit from quantum acceleration.

Specifically, Menten AI is developing a suite of quantum computing algorithms including quantum machine learning to break through computationally demanding problems in therapeutic design.

“While quantum computing hardware capable of running these algorithms is still being developed, classical computing tools like NVIDIA cuQuantum are crucial for advancing quantum algorithm development,” said Alexey Galda, a principal scientist at Menten AI.

Forging a Quantum Link

As quantum systems evolve, the next big leap is a move to hybrid systems: quantum and classical computers that work together. Researchers share a vision of systems-level quantum processors, or QPUs, that act as a new and powerful class of accelerators.

So, one of the biggest jobs ahead is bridging classical and quantum systems into hybrid quantum computers. This work has two major components.

First, we need a fast, low-latency connection between GPUs and QPUs. That will let hybrid systems use GPUs for classical jobs where they excel, like circuit optimization, calibration and error correction.

GPUs can speed the execution time of these steps and slash communication latency between classical and quantum computers, the main bottlenecks for today’s hybrid quantum jobs.

Second, the industry needs a unified programming model with tools that are efficient and easy to use. Our experience in HPC and AI has taught us and our users the value of a solid software stack.

Right Tools for the Job

To program QPUs today, researchers are forced to use the quantum equivalent of low-level assembly code, something outside of the reach of scientists who aren’t experts in quantum computing. In addition, developers lack a unified programming model and compiler toolchain that would let them run their work on any QPU.

This needs to change, and it will. In a March blog, we discussed some of our initial work toward a better programming model.

To efficiently find ways quantum computers can accelerate their work, scientists need to easily port parts of their HPC apps first to a simulated QPU, then to a real one. That requires a compiler enabling them to work at high performance levels and in familiar ways.

With the combination of GPU-accelerated simulation tools and a programming model and compiler toolchain to tie it all together, HPC researchers will be empowered to start building tomorrow’s hybrid quantum data centers.

How to Get Started

For some, quantum computing may sound like science fiction, a future decades away. The fact is, every year researchers are building more and larger quantum systems.

NVIDIA is fully engaged in this work and we invite you to join us in building tomorrow’s hybrid quantum systems today.

To learn more, you can watch a GTC session and attend an ISC tutorial on the topic. For a deep dive into what you can do with GPUs today, read about our State Vector and Tensor Network libraries.

The post The Road to the Hybrid Quantum-HPC Data Center Starts Here appeared first on NVIDIA Blog.