Tantangan yang berulang dalam desain molekuler, baik untuk aplikasi farmasi, kimia, atau material, adalah membuat molekul yang dapat disintesis. Penilaian Sintesizabilitas Seringkali membutuhkan pemetaan jalur sintesis untuk suatu molekul: urutan reaksi kimia yang diperlukan untuk mengubah molekul prekursor menjadi molekul produk target. Posting ini memperkenalkan Rasyn, model generatif dari NVIDIA yang dirancang untuk memprediksi jalur sintesis molekuler yang juga membahas keterbatasan dalam pendekatan saat ini.
Mengapa Penalaran Rantai Pikiran Masalah untuk AI dalam Kimia
Model Bahasa Besar (LLM) telah menjadi bagian integral dari kehidupan sehari-hari, memberi daya pada aplikasi dari asisten virtual ke pemecahan masalah yang kompleks. LLM modern memecahkan masalah kompleks dengan menghasilkan rantai pemikiran (COT), yang merupakan serangkaian langkah penalaran perantara yang mengarah pada jawaban akhir. Menggabungkan metode pencarian COT dan waktu tes, seperti menghasilkan beberapa jalur COT, sangat penting untuk peningkatan akurasi LLM terbaru.
Kimia menghadapi tantangan yang sama dalam prediksi jalur sintesis molekuler, di mana jalur berisi serangkaian langkah sintesis menengah. Prediksi jalur adalah langkah penting dalam pengembangan obat, bahan kimia, dan bahan karena molekul, betapapun menjanjikannya, hanya berharga jika dapat disintesis. Reasyn adalah kerangka generatif baru yang secara efisien memprediksi jalur sintesis molekuler. Ini menggunakan notasi rantai reaksi (COR) yang unik, yang terinspirasi oleh pendekatan COT di LLMS, dikombinasikan dengan algoritma pencarian waktu tes.
Jalur sintetis mengikuti struktur pohon bottom-up: molekul sederhana, atau blok bangunan (BB), digabungkan melalui reaksi kimia (RXN) untuk menghasilkan produk menengah (INT), yang pada gilirannya mengalami reaksi lebih lanjut untuk membentuk molekul yang semakin kompleks (Gambar 1). Proses ini multi-langkah, dengan setiap reaksi diterapkan pada reaktan yang mungkin merupakan blok bangunan atau perantara. Dalam praktiknya, ahli kimia menyimpulkan jalur seperti itu langkah demi langkah, alasan melalui setiap transformasi untuk mencapai molekul target akhir.
Gambar 1. Notasi Cor melihat jalur sintetis sebagai jalur penalaran ranjang
Rasyn menangkap penalaran langkah demi langkah ini melalui notasi cor-nya, terinspirasi oleh pendekatan COT di LLMS. Di COR, seluruh jalur sintetis direpresentasikan sebagai urutan linier di mana setiap langkah secara eksplisit mencakup reaktan, aturan reaksi, dan produk yang dihasilkan. Reaktan dan produk dikodekan sebagai senyum (string, dibungkus dengan token khusus yang menandai batas mereka), sementara setiap reaksi dilambangkan dengan token kelas reaksi tunggal. Representasi ini tidak hanya mencerminkan bagaimana ahli kimia berpikir tentang sintesis tetapi juga memungkinkan model untuk menerima pengawasan menengah pada setiap langkah untuk belajar lebih kaya aturan reaksi kimia dan pembuatan jalur multi-langkah yang lebih andal.
Gambar 2. Kerangka kerja keseluruhan dari RECYN
Membangun di atas notasi COR dan desain berurutan, Reasyn beroperasi sebagai model generatif autoregresif (Gambar 2) yang memperlakukan jalur sintetis sebagai rantai penalaran – masing -masing langkah yang sesuai dengan reaksi kimia tunggal. Sama seperti penalaran COT di LLMS menghasilkan langkah -langkah perantara sebelum jawaban akhir, Reasyn secara bertahap membangun jalur mulai dari blok bangunan sederhana ke molekul target. Ini memungkinkannya untuk merekonstruksi jalur untuk molekul yang dapat disintesis dan ke proyek Molekul yang tidak dapat disinkronkan ke dalam ruang kimia yang dapat disintesis, memproduksi analog yang dapat disintesiskan yang dapat dibuat dalam praktiknya.
Setelah model memprediksi reaktan dan aturan reaksi pada setiap langkah, produk menengah dapat dengan mudah diperoleh dengan menggunakan pelaksana reaksi seperti RDKI. Informasi menengah ini tidak hanya memberikan sinyal pelatihan yang lebih kaya untuk model untuk mempelajari aturan kimia, tetapi juga memandu proses pembuatan jalur sintetis.
Melihat generasi jalur sintetis sebagai penalaran LLM juga memungkinkan kami untuk mengadopsi teknik penalaran LLM tambahan seperti penguatan pembelajaran (RL) finetuning dan pencarian waktu tes. Rasyn mengeksplorasi dua teknik ini untuk generasi jalur sintetis.
Bagaimana RL Finetuning Berbasis Hasil Meningkatkan Eksplorasi
Mungkin ada beberapa jalur yang mengarah ke molekul produk yang sama. Reasyn mendapat manfaat dari pengambilan sampel berbagai jalur sintetis dan mendapatkan umpan balik melalui GRPO). Hadiah berbasis hasil untuk jalur diatur ke kesamaan molekuler antara molekul produk akhir dan molekul input. Karena hadiah hanya diterapkan pada hasilnya, alih -alih langkah -langkah penalaran, model ini diberkahi dengan kemampuan untuk mengeksplorasi berbagai jalur sintetis.
Gambar 3. Pembelajaran Penguatan (RL) Finetuning dari RECYN Menggunakan GRPO
Pencarian yang diarahkan pada tujuan: jalur panduan
Selama generasi, Reasyn menggunakan pencarian balok, yang mempertahankan kumpulan urutan yang dihasilkan dan memperluasnya blok demi blok (BB atau RXN). Pencarian memungkinkan RECYN untuk menghasilkan beragam jalur untuk molekul input tunggal, dan memandu generasi dalam arah yang disukai dengan mencetak urutan melalui fungsi hadiah. Dalam perencanaan retrosintesis, fungsi hadiah dapat menjadi kesamaan dengan molekul input. Dalam tugas optimasi yang diarahkan pada tujuan, fungsi hadiah dapat menjadi properti kimia yang diinginkan.
Gambar 4. Pencarian waktu tes yang diarahkan pada tujuan dari Rasyn
Menghasilkan jalur sintetis dengan reasyn
Proyeksi Sintesizable Reasyn sangat fleksibel: memungkinkan perencanaan retrosintesis, menyarankan analog untuk molekul yang tidak dapat disinkronkan, mendukung optimasi molekuler yang diarahkan pada tujuan, dan memfasilitasi ekspansi hit yang dapat disintesis. Di bawah ini, kami memeriksa kinerjanya pada tugas -tugas ini.
Perencanaan retrosintesis
Tabel 1. Tingkat keberhasilan perencanaan retrosintesis (%)
Bahkan dengan ruang yang dapat disintesiskan secara luas, metode pembuatan molekul yang dapat disintesis sebelumnya telah berjuang untuk menutupi ruang ini secara luas. Rasyn menunjukkan tingkat keberhasilan yang tinggi dalam menghasilkan jalur sintetis yang diberikan molekul yang dapat disintesis, menunjukkan eksplorabilitasnya yang kuat dalam ruang kimia yang dapat disintesis.
Optimalisasi molekul yang diarahkan sasaran yang dapat disintalkan
Tabel 2. Rata -rata skor optimasi yang dapat disintesis dari tugas optimasi molekuler 15 pmo
Reasyn dapat memproyeksikan molekul yang dihasilkan oleh metode optimasi molekuler di luar rak untuk melakukan optimasi yang diarahkan pada tujuan yang dapat disintesi. Dikombinasikan dengan grafik GA, grafik GA-Reasyn menunjukkan kinerja optimasi yang lebih tinggi daripada metode berbasis sintesis sebelumnya.
Ekspansi hit yang dapat disintesis: Menjelajahi lingkungan molekul
Skema pencarian memungkinkan RECYN untuk menyarankan beberapa analog yang dapat disintesis untuk molekul target yang diberikan dengan memproyeksikannya secara berbeda. RECYN mengeksplorasi lingkungan molekul yang diberikan dalam ruang yang dapat disintesis, dan dapat diterapkan untuk menghitung ekspansi untuk menemukan analog yang dapat disintesis dari molekul hit (Gambar 5).
Gambar 5. Ekspansi hit yang dapat disintesis dengan Reasyn
Sebagian besar model generatif menciptakan molekul yang tidak dapat disintesional dalam praktiknya. Rasyn membangun kemajuan penalaran baru -baru ini di LLMS, melengkapi para ilmuwan dengan alat generatif yang efektif untuk memproyeksikan molekul kecil ke dalam ruang kimia yang dapat disintesis. Dengan peningkatan kemampuan penalaran, keanekaragaman, dan keserbagunaan, Reasyn menunjukkan janji sebagai sarana untuk menavigasi ruang kimia yang dapat disintesis secara kombinatorial dalam penemuan obat dunia nyata.
Cari tahu lebih lanjut tentang Reasyn dengan membaca makalah kami tentang ARXIV dan kode tersedia di GitHub.
Unlike traditional LLM-based systems that are limited by their training data, retrieval-augmented generation (RAG) improves text generation by incorporating relevant external information. Agentic RAG goes a step further by leveraging autonomous systems integrated with LLMs and retrieval mechanisms. This allows these systems to make decisions, adapt to changing requirements, and perform complex reasoning tasks dynamically.
In this guide to the self-paced workshop for building a RAG agent, you’ll gain:
Understanding of the core principles of agentic RAG, including NVIDIA Nemotron, an open model family with open data and weights.
Knowledge of how to build agentic RAG systems using LangGraph.
A turnkey, portable development environment.
Your own customized agentic RAG system, ready to share as an NVIDIA Launchable.
Video walkthrough
Video 1. Build a RAG Agent with NVIDIA Nemotron
Opening the workshop
Launch the workshop as an NVIDIA Launchable:
Figure 1. Click on the ‘Deploy Now’ button to deploy the NVIDIA DevX Workshop in the cloud
With your Jupyter Lab environment running, locate the NVIDIA DevX Learning Path section of the Jupyterlab Launcher. Select the Agentic RAG tile to open up the lab instructions and get started.
Figure 2. Click on the “Agentic RAG” tile in NVIDIA DevX Learning Path to open lab instructions.
Setting up secrets
In order to follow along with this workshop, you’ll need to gather and configure a few project secrets.
NGC API Key: This enables access to NVIDIA software, models, containers, and more
(optional) LangSmith API Key: This connects the workshop to LangChain’s platform for tracing and debugging your AI Agent
You can utilize the Secrets Manager tile under NVIDIA DevX Learning Path of the Jupyterlab Launcher to configure these secrets for your workshop development environment. Verify in the logs tab that the secrets have been added successfully.
Figure 3. Use the “Secrets Manager” tile under the NVIDIA DevX Learning Path section to configure project secrets (API keys).
Introduction to RAG architecture
Once your workshop environment has been set up, the next step is understanding the architecture of the agentic RAG system you’ll build.
RAG enhances the capabilities of LLMs by incorporating relevant external information during output text generation. Traditional language models generate responses based solely on the knowledge captured in their training data, which can be a limiting factor, especially when dealing with rapidly changing information, highly specialized knowledge domains, or enterprise confidential data. RAG, on the other hand, is a powerful tool for generating responses based on relevant unstructured data retrieved from an external knowledge base.
Figure 4. Traditionally, RAG utilizes a user prompt to retrieve contextually-relevant documents, providing them as context to the LLM for a more informed response.
The typical flow for a RAG system is:
Prompt: A user generates a natural language query.
Embedding Model: The prompt is converted into vectors
Vector Database Search: After a user’s prompt is embedded into a vector, the system searches a vector database filled with semantically indexed document chunks, enabling fast retrieval of contextually relevant data chunks.”
Reranking Model: The retrieved data chunks are reranked to prioritize the most relevant data.
LLM: The LLM generates responses informed by the retrieved data.
This approach ensures that the language model can access up-to-date and specific information beyond its training data, making it more versatile and effective.
Understanding ReAct agent architecture
Unlike traditional LLM-based applications, agents can dynamically choose tools, incorporate complex reasoning, and adapt their analysis approach based on the situation at hand.
Figure 5. A ReAct agent can iteratively reason and call out to user-defined tools to generate a higher quality RAG-based response.
ReAct Agents are a simple agentic architecture that use “reasoning and acting” via tool calling supported LLMs. If the LLM requests any tool calls after taking in the prompt, those tools will be run, added to the chat history, and sent back to the model to be invoked again.
RAG works well, but it’s limited because the LLM can’t determine how data is retrieved, control for data quality, or choose between data sources. Agentic RAG takes the concept of RAG a step further by combining the strengths of LLMs such as language comprehension, contextual reasoning, and flexible generation, with dynamic tool usage, and advanced retrieval mechanisms such as semantic search, hybrid retrieval, reranking, and data source selection. Making a ReAct Agent for RAG just requires giving it the Retrieval Chain as a tool so the agent can decide when and how to search for information.
Figure 6. The full agentic RAG pipeline will involve adding the ReAct agent to the Retrieval Chain where the contextual documents are stored.
Agentic RAG employs a ReAct agent architecture in which the reasoning LLM systematically decides whether to retrieve information via tool calling or respond directly, activating the retrieval pipeline only when additional context is needed to better address the user’s request.
Learn and implement the code
Now that we understand the concepts, let’s dive into the technical implementation. We’ll start with the foundational components before building up to the complete agentic RAG system:
Models
Tools
Data Ingestion
Text Splitting
Vector Database Ingestion
Document Retriever and Reranker
Retriever Tool Creation
Agent Configuration
Foundations: the models
The workshop relies on NVIDIA NIM endpoints for the core model powering the agent. NVIDIA NIM provides high-performance inference capabilities, including:
Tool binding: Native support for function calling.
Structured output: Built-in support for Pydantic models.
Async operations: Full async/await support for concurrent processing.
To ensure the quality of the LLM-based application, it’s crucial that the agent receives clear instructions to clarify decision-making, remove ambiguity, and clarify how it should treat retrieved documents. One such example from code/rag_agent.py is provided as follows:
SYSTEM_PROMPT = (
"You are an IT help desk support agent.\n"
"- Use the 'company_llc_it_knowledge_base' tool for questions likely covered by the internal IT knowledge base.\n"
"- Always write grounded answers. If unsure, say you don't know.\n"
"- Cite sources inline using [KB] for knowledge base snippets.\n"
"- If the knowledge base doesn't contain sufficient information, clearly state what information is missing.\n"
"- Keep answers brief, to the point, and conversational."
)
This prompt shows a few key principles of reliable LLM prompting for RAG-based applications:
Role specification: Clear definition of the agent’s expertise and responsibilities.
Tool Utilization: Instruct the agent on which tools to use for specific tasks.
Grounding: Emphasize the importance of providing answers based on reliable sources and the importance of admitting to uncertainty.
Source Citation: Provide guidelines for citing sources to ensure transparency.
Communication Style: Specify the desired communication style.
In code/rag_agent.py we define the models necessary for the IT Help Desk agent to answer user queries by utilizing the Knowledge Base.
The LLM Model, Nemotron Nano 9b V2, is the primary reasoning model used for generating responses.
The NVIDIA NeMo Retriever Embedding Model, Llama 3.2 EmbedQA 1b V2, is used for converting documents into vector embedding representations for storage and retrieval.
The NeMo Retriever Reranking Model, Llama 3.2 RerankQA 1b V2, is used for reranking for the most relevant retrieved documents and data.
These models collectively enable the IT Help Desk agent to answer user queries accurately by leveraging a combination of language generation, document retrieval, and reranking capabilities.
Foundations: the tools
Our RAG agent will have access to the knowledge base provided at ./data/it-knowledge-base that contains markdown files documenting common IT-related procedures. The retriever tool enables the agent to search the internal IT knowledge base for documents relevant to the user’s query.
A vector database stores, indexes, and queries numerical representations of vectorized embeddings, allowing for fast similarity searches of unstructured data like text, images, and audio. For our purposes, we use an in-memory FAISS database, which is efficient for spinning up small databases. In terms of data ingestion to utilize the data in the knowledge base, we’ll focus on text ingestion. Additional features like multimodality should be considered for production use cases.
Foundations: data ingestion
The embedding model utilized is NeMo Retriever llama-3.2-nv-embedqa-1b-v2. This model creates embeddings for documents and queries that help in efficiently retrieving relevant documents from the knowledge base by comparing the semantic similarity between the query and the documents.
To ingest the documents, we’ll chunk the documents, embed those chunks into vectors, and then insert the vectors into the database. Before doing that, we need to load the data from our ./data/it-knowledge-base directory using the LangChain DirectoryLoader.
from langchain_community.document_loaders import DirectoryLoader, TextLoader
# Read the data
_LOGGER.info(f"Reading knowledge base data from {DATA_DIR}")
data_loader = DirectoryLoader(
DATA_DIR,
glob="**/*",
loader_cls=TextLoader,
show_progress=True,
)
docs = data_loader.load()
Foundations: text splitting
Document splitting is controlled by two things: chunk size and chunk overlap.
Chunk size defines the maximum length of each text chunk. This ensures that each chunk is of an optimized size for processing by language models and retrieval systems. A chunk size that is too large may contain information less relevant to specific queries, while one too small may miss important context.
Chunk overlap defines the number of tokens that overlap between consecutive chunks. The goal is to ensure continuity and preserve context across chunks, thereby maintaining coherence in the retrieved information.
To perform text splitting efficiently, we use the RecursiveCharacterTextSplitter. This tool recursively splits documents into smaller chunks based on character length, so each chunk adheres to the defined chunk size and overlap parameters. It’s particularly useful for processing large documents, improving the information retrieval’s overall accuracy.
To facilitate efficient retrieval of relevant information, we need to ingest our large corpus of documents into a vector database. Now that we have broken down our documents into manageable chunks, we utilize the embedding model to generate vector embeddings for each document chunk.
These embeddings are numerical representations of the semantic content of the chunks. High-quality embeddings enable efficient similarity searches, allowing the system to quickly identify and retrieve the most relevant chunks in response to a user’s query.
The next step is to store the generated embeddings in an in-memory FAISS database, which ensures fast indexing and querying capabilities for real-time information retrieval. In this example, we leverage the fact that LangChain’s FAISS `from_documents` method conveniently generates the embeddings for the document chunks and also stores them in the FAISS vector store in one function call.
from langchain_community.vectorstores import FAISS
from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings,
embeddings = NVIDIAEmbeddings(model=RETRIEVER_EMBEDDING_MODEL, truncate="END")
vectordb = FAISS.from_documents(chunks, embeddings)
By following these steps and taking advantage of the power of the embedding model, we ensure that the IT Help Desk agent can efficiently retrieve and process relevant information from the knowledge base.
Foundations: document retriever and reranker
With our vector database populated, we can build a chain for content retrieval. This involves creating a seamless workflow that includes both the embedding step and the lookup step.
Figure 7. A basic retrieval chain consists of an embedding model and a database to store the converted vector embeddings.
In the embedding step, user queries are converted into embeddings using the same model that we previously used for document chunks. This ensures that both the queries and document chunks are represented in the same semantic space, enabling accurate similarity comparisons.
To initialize the retriever in this example, we’ll use semantic similarity and search for the top six returned results compared to our query.
The embeddings of the user’s queries are compared against the embeddings stored in the vector database during the lookup step. The system retrieves the most similar document chunks, which are then used to generate responses.
Figure 8. A more complex retrieval chain consists of attaching a Reranking model to reorganize retrieved context to put the most relevant chunks first.
For both the embedding and the reranking models, we’ll use NIM microservices from NVIDIA NeMo Retriever. LangChain allows us to easily create a basic retrieval chain from our Vector Database object that has both the embedding step and the lookup step.
For improving the relevance and order of retrieved documents, we can utilize the NVIDIA Rerank class, built on the NVIDIA NeMo Retriever Reranker model. The Reranker model evaluates and ranks the retrieved document chunks based on their relevance to the user’s query so that the most pertinent information is presented to the user first. In this example, we initialize the Reranker as follows:
from langchain_nvidia_ai_endpoints import NVIDIARerank
reranker = NVIDIARerank(model=RETRIEVER_RERANK_MODEL)
Foundations: Retriever tool creation
Taking the document retriever and the documenter reranker, we can now create the final document retriever as below:
The LangChain ContextualCompressionRetriever makes it easy to combine a retriever with additional processing steps, attaching the retrieval chain to the reranking model. Now we can create the retriever tool that enables our ReAct Agent.
In this example, we can initialize the retriever tool by using the LangChain tools package below, passing in our initialized retriever:
from langchain.tools.retriever import create_retriever_tool
RETRIEVER_TOOL = create_retriever_tool(
retriever=RETRIEVER,
name="company_llc_it_knowledge_base",
description=(
"Search the internal IT knowledge base for Company LLC IT related questions and policies."
),
)
Foundations: agent configuration
With our vector database and retriever chain in place, we’re ready to construct the agent graph. This agent graph acts as a kind of flowchart, mapping out the possible steps the model can take to accomplish its task. In traditional, step-by-step LLM applications, these are called “chains.” When the workflow involves more dynamic, non-linear decision-making, we refer to them as “graphs.” The agent can choose different paths based on the context and requirements of the task at hand, branching out into different decision nodes.
Given the prevalence of the ReAct agent architecture, LangGraph provides a function that’ll create ReAct Agent Graphs. In this example, we utilized as below:
By constructing an agent graph, we create a dynamic and flexible workflow that enables our IT Help Desk agent to handle complex decision-making processes. This approach ensures that the agent can efficiently retrieve and process information, provide accurate responses, and adapt to various scenarios.
Running your agent
Congratulations! You have successfully built your agent! Now, the next step is to try it out.
To get started with running your agent from your terminal, cd into the code directory that has the Python file containing your code for the agent. Once there, start your Agent API with the LangGraph CLI. Your agent will automatically reload as you make changes and save your code.
To chat with your agent, a simple Streamlit app has been included in the Simple Agents Client. You can also access the Streamlit Client from the Jupyter Launcher page. In the sidebar, ensure the rag_agent client is selected and try chatting!
Figure 9. Click on the “Simple Agents Client” tile in NVIDIA DevX Learning Path to open the Streamlit chat application.
As your agents become more sophisticated, managing their internal complexity can become difficult. Tracing helps visualize each step your agent takes, which makes it easier to debug and optimize your agent’s behavior. In the workshop, you can optionally configure the LANGSMITH_API_KEY and view traces on the LangSmith dashboard.
Migrate to local NIM microservices
This workshop utilizes the nvidia-nemotron-nano-9b-v2 LLM from the NVIDIA API Catalog. These APIs are useful for evaluating many models, quick experimentation, and getting started is free. However, for the unlimited performance and control needed in production, deploy models locally with NVIDIA NIM microservice containers.
In a typical development workflow, both your agent and NIM containers would run in the background, allowing you to multitask and iterate quickly. For this exercise, we can run the NIM in the foreground to easily monitor its output and ensure proper start up.
First, you need to log in to the NGC container registry as follows:
The next step is to create a location for NIM containers to save their downloaded model files.
docker volume create nim-cache
Now, we need to use a Docker run command to pull the NIM container image and model data files before hosting the model behind a local, OpenAI-compliant API.
With your langgraph server still running, go back to our Simple Agents Client and try prompting the agent again. If everything was successful, you should notice no change!
Congratulations! You have now migrated to using Local NIM microservices for your LangGraph Agent!
Conclusion and next steps
This workshop provides a comprehensive path from basic concepts to sophisticated agentic systems, emphasizing hands-on learning with production-grade tools and techniques.
By completing this workshop, developers gain practical experience with:
Fundamental concepts: Understanding the difference between standard and agentic RAG.
State management: Implementing complex state transitions and persistence.
Tool integration: Creating and managing agentic tool-calling capabilities.
Modern AI stack: Working with LangGraph, NVIDIA NIM, and associated tooling.
Learn More
For hands-on learning, tips, and tricks, join our Nemotron Labs livestream, “Build a RAG Agent with NVIDIA Nemotron” on Tuesday, September 23, 2025 at 9am PT.
Stay up to date on Agentic AI, Nemotron, and more by subscribing to NVIDIA news, joining the community, and following NVIDIA AI on LinkedIn, Instagram, X, and Facebook.
Explore the self-paced video tutorials and livestreams here.
Yang terbaru untuk devs dari made by google, pembaruan ke Gemini di Android Studio, ditambah androidify baru: episode musim panas kami dari The Android Show
Diposting oleh Matthew McCullough – VP manajemen produk, pengembang Android dalam ekosistem yang dinamis dan kompleks ini, komitmen kami adalah untuk …
Yang terbaru untuk devs dari made by google, pembaruan ke Gemini di Android Studio, ditambah androidify baru: episode musim panas kami dari The Android Show
Diposting oleh Matthew McCullough – VP manajemen produk, pengembang Android dalam ekosistem yang dinamis dan kompleks ini, komitmen kami adalah untuk …
Para ilmuwan dari NVIDIA, bekerja sama dengan Lawrence Berkeley National Laboratory (Berkeley Lab), merilis alat pembelajaran mesin yang disebut besar ansambel (HENS) untuk prediksi cuaca ekstrem yang membawa peramalan kelas superkomputer tetapi pada kekuatan dan biaya komputasi yang jauh lebih sedikit. Tersedia sebagai kode open source atau model siap pakai, itu memperkirakan peristiwa berdampak rendah, berdampak tinggi-dari gelombang panas yang berkepanjangan hingga badai 100 tahun. Teknologi ini dapat membantu para ilmuwan iklim, pejabat kota, dan manajer darurat dengan cepat menguji skenario dan memperbarui rencana respons dengan sumber daya komputasi minimal.
Studi dua bagian yang diterbitkan dalam jurnal Pengembangan Model Geoscientificmemperkenalkan metode yang disebut ayam untuk menghasilkan data 27.000 tahun dan merupakan salah satu ansambel cuaca dan simulasi iklim terbesar dan paling andal yang tersedia.
Menggunakan Nvidia Physicsnemo, kerangka kerja Python open source untuk membangun, pelatihan, dan fine-tuning fisika AI model pada skala, dan kerangka kerja open source, para peneliti melatih model cuaca global untuk memperbaiki metodologi ayam.
“Dua puluh tujuh ribu tahun simulasi adalah tambang emas untuk mempelajari statistik dan pendorong peristiwa cuaca ekstrem,” kata Ankur Mahesh, rekan penulis studi dan peneliti mahasiswa pascasarjana di wilayah Bumi dan Ilmu Lingkungan Berkeley Lab. “Ukuran sampel yang besar ini benar -benar pada skala yang belum pernah terlihat sebelumnya.”
Menurut penelitian, ayam dapat memprediksi cuaca lebih cepat daripada metode lain, mengambil menit daripada jam. Ini juga memperluas jendela perkiraan, memprediksi peristiwa cuaca ekstrem dari enam jam hingga 14 hari ke depan pada resolusi 15 mil (25 kilometer). Ini dapat membantu para peneliti mempelajari pola cuaca di resolusi tinggi selama beberapa dekade untuk mengidentifikasi petunjuk baru yang mengarah ke peristiwa ekstrem.
“Dengan ayam betina, kami sekarang memiliki kemewahan untuk mengejar peristiwa ekstrem yang berdampak rendah dan berdampak tinggi yang diprediksi selama bertahun-tahun dan beberapa dekade alih-alih acara tunggal jangka pendek,” kata rekan penulis senior Bill Collins, seorang ilmuwan senior fakultas di Bumi Lab Berkeley dan Area Ilmu Lingkungan dan seorang profesor di UC Berkeley.
Pendekatan baru ini juga membutuhkan energi dan orang yang jauh lebih sedikit daripada metode lain, dan menghemat energi dengan melatih kembali model pada data baru – teknik untuk memastikan akurasi – lebih cepat dari metode lain, tambah Collins.
Ayam Pelatihan: Physicsnemo dan 40 tahun data iklim
Hens menggunakan model AI yang dilatih menggunakan Physicsnemo pada 40 tahun data ERA5, salah satu sumber negara atmosfer historis terbaik. Setelah dilatih, model ini menawarkan pendekatan komputasi yang jauh lebih murah untuk perkiraan, kata Shashank Subramanian, seorang insinyur pembelajaran mesin di Pusat Komputasi Ilmiah Penelitian Energi Nasional (NERSC) di Berkeley Lab dan rekan penulis studi yang membantu Mahesh mengembangkan dan menguji alur kerja pelatihan dan evaluasi.
“Hens adalah pengubah permainan. Sampai hari ini, menghasilkan 1.000 atau 10.000 ansambel simulasi hanya tidak praktis karena komputasi penghitungan dan biaya penyimpanan data,” kata rekan penulis Michael Pritchard, direktur penelitian simulasi iklim di NVIDIA dan seorang profesor di UC Irvine. “Berkat pekerjaan yang hati-hati dari tim ini mengkalibrasi teknologi simulasi AI, sekarang cocok untuk tujuan untuk menghasilkan ansambel besar termasuk kontrafaktual gelombang panas yang realistis dengan pesanan penyelesaian lebih cepat daripada simulasi numerik tradisional.”
Bagaimana Anda dapat meningkatkan akurasi prediksi cuaca menggunakan ayam?
Untuk menangkap berbagai kemungkinan hasil cuaca di masa depan, Layanan Cuaca Nasional menjalankan beberapa simulasi yang berbeda, atau “anggota ensemble,” masing -masing dengan perubahan kecil pada kondisi awal. Model -model numerik ini didasarkan pada Laws fisika seperti konservasi massa, konservasi momentum, dan konservasi energi. Ada banyak kepercayaan pada simulasi berbasis fisika ini, tetapi mereka juga sangat mahal secara komputasi karena mereka membutuhkan superkomputer.
Karena biaya ini, model cuaca tradisional hanya dapat memiliki 50 anggota ensemble. Untuk menemukan cuaca ekstrem, kondisi awal model perlu terganggu ribuan kali dan membutuhkan ratusan jam superkomputer.
Para peneliti menggunakan ayam untuk menciptakan 7.424 anggota ensembel berdasarkan kondisi cuaca awal dari setiap hari musim panas 2023, yang terpanas pada catatan pada saat itu – hampir 150x lebih banyak anggota daripada apa yang mungkin dengan model konvensional – masing -masing anggota ensemble mewakili lintasan cuaca alternatif, atau cara yang berbeda dengan cuaca bisa terjadi musim panas lalu.
“Ini memungkinkan kami untuk mendapatkan perkiraan yang lebih baik dari ekor distribusi dan memahami peristiwa ekstrem yang bisa terjadi musim panas itu,” kata Mahesh.
Prediksi yang dibuat oleh ayam memiliki ketidakpastian yang lebih dari 10 kali lebih kecil dari yang dari model tradisional. Itu mampu menangkap 96% dari peristiwa cuaca ekstrem yang langka namun parah yang biasanya dilewatkan oleh model lain. Bersama -sama, kekuatan ini telah memungkinkan tim untuk membuat dataset yang sangat besar, sekitar 27.000 tahun data iklim (20 petabyte).
Selama percobaan validasi yang ketat di NERSC, Mahesh dan tim menimbang prediksi ensemble pada berbagai metrik diagnostik, menunjukkan bahwa ayam sangat dekat dengan standar emas.
Apa selanjutnya?
Dalam pekerjaan di masa depan, Mahesh mengatakan bahwa tim berencana untuk mempelajari simulasi 27.000 tahun dengan harapan mengungkap wawasan baru tentang pengemudi di balik peristiwa berdampak tinggi yang mirip dengan rendah, seperti gelombang panas bencana, badai, dan sungai atmosfer, yang telah menghancurkan komunitas dalam beberapa tahun terakhir. Mereka juga bertujuan untuk lebih mengurangi persyaratan komputasi untuk menjalankan ayam.
NERSC adalah Fasilitas Pengguna Kantor Sains DOE di Berkeley Lab. Pekerjaan ini didukung oleh Kantor Sains DOE.
NVIDIA HGX B200 merevolusi komputasi yang dipercepat dengan membuka kinerja dan efisiensi energi yang belum pernah terjadi sebelumnya. Posting ini menunjukkan bagaimana HGX B200 mengungguli pendahulunya NVIDIA HGX H100 dalam metrik lingkungan, termasuk berkurangnya intensitas karbon, melalui perbandingan ringkasan produk karbon (PCF) yang baru -baru ini diterbitkan.
Secara khusus, analisis data PCF mengungkapkan bahwa HGX B200 menunjukkan pengurangan 24% dari emisi karbon yang diwujudkan di seluruh beban kerja besar seperti pelatihan dan inferensi AI.
HGX B200 dan HGX H100 adalah platform komputasi yang dipercepat masing-masing terdiri dari delapan GPU, dengan interkoneksi berkecepatan tinggi melalui NVIDIA NVLink dan NVIDIA NVSWITCH untuk mempercepat kinerja AI pada skala. Keduanya dirancang untuk komputasi kinerja tinggi (HPC) dan beban kerja analisis data pendukung.
NVIDIA HGX B200 bergantung pada GPU NVIDIA Blackwell B200 yang ditingkatkan, yang dirancang untuk menawarkan kinerja AI yang lebih baik secara dramatis. B200 GPUs incorporate 180 GB of HBM3E memory—more than double the memory of the NVIDIA HGX H100 and other performance enhancing features, including a second-generation Transformer Engine that introduces FP4 alongside FP8, fifth‑generation NVLink/NVSwitch (up to 1.8 TB/s per‑GPU and 14.4 TB/s aggregate bandwidth), to boost higher throughput at presisi lebih rendah.
Throughput HGX B200 adalah 2.3x lebih cepat (FP16) daripada HGX H100. Kinerja komputasi yang ditingkatkan ini juga lebih hemat energi. Untuk inferensi AI, HGX B200 dapat sebanyak 15x lebih hemat energi. Itu adalah pengurangan energi 93% untuk beban kerja inferensi yang sama.
HGX B200 juga menghasilkan lebih sedikit emisi terkait manufaktur per jepit komputasi. Secara khusus, intensitas karbon yang diwujudkan untuk komputasi berkurang dari 0,66 GCO2E per exaflop dengan HGX H100 menjadi 0,50 GCO2E per exaflop dengan HGX B200 (diperkirakan berdasarkan presisi FP16). Ini adalah penurunan 24% secara keseluruhan antara dua generasi. Ini diperkirakan berdasarkan data PCF dan jumlah total kegagalan pada presisi FP16 yang dieksekusi selama masa pakai produk.
Gambar 1. HGX B200 menghasilkan pengurangan 24% dalam intensitas karbon komputasi yang dibubarkan perangkat keras dibandingkan dengan HGX H100
Selain itu, ada penurunan bahan dan komponen – kategori penghasil emisi tertinggi untuk setiap alas tiang – antara HGX B200 dan HGX H100. Pengurangan yang paling menonjol adalah untuk komponen termal, IC, dan memori.
Gambar 2. HGX B200 memberikan penurunan emisi yang signifikan untuk bahan dan komponen dalam berbagai kategori dibandingkan dengan HGX H100
Kombinasi kekuatan komputasi hemat energi HGX B200 dan mengurangi intensitas emisi yang terkandung dapat menyebabkan penurunan substansial emisi, terutama selama fase penggunaannya untuk beban kerja yang besar seperti pelatihan dan inferensi AI.
Dampak karbon operasional
Sementara ini berkurangnya intensitas karbon yang terkandung mencerminkan intensitas karbon hulu yang lebih rendah untuk HGX B200, peningkatan intensitas karbon hilir bahkan lebih jelas.
Misalnya, HGX B200 diproyeksikan untuk memberikan peningkatan 10x dalam efisiensi inferensi untuk model Deepseek-R1, yang diterjemahkan menjadi pengurangan 90% dalam emisi karbon operasional dibandingkan dengan HGX H100 untuk emisi karbon operasional GCO2E untuk memproses 1 juta token inferensi (100 TPS/pengguna).
Perhatikan bahwa data ini dihitung berdasarkan 2023 faktor emisi IEA yang ditimbang oleh konsumsi energi pusat data regional. Faktor emisi termasuk emisi hulu dan kerugian T&D yang terkait dengan produksi listrik.
Gambar 3. Pengurangan 90% dalam emisi karbon operasional diamati antara generasi
Metodologi dan proses pengumpulan data
Kedua ringkasan PCF yang diterbitkan secara eksternal sangat bergantung pada data primer dari pemasok yang dikumpulkan untuk lebih dari 90% dari kedua produk berdasarkan berat, termasuk komposisi material dan konsumsi energi produksi.
Sumber sekunder diintegrasikan dengan data ini, seperti alat IMEC.Netzero untuk emisi terkait fabrikasi, serta database Ecoinvent 3.10 dan Sphera LCA (database profesional 2024 dan database ekstensi XI: Electronics 2024) untuk bahan pemodelan, transportasi, dan energi.
Gambar 4. Lingkup jejak karbon produk cradle-to-gate HGX B200
Ringkasan PCF ini selaras dengan ISO Standard14040 dan 14044 pada penilaian siklus hidup dan ditinjau secara kritis sesuai dengan ISO Standard 14067 pada jejak kaki karbon.
Masa depan komputasi berkelanjutan
NVIDIA bertujuan untuk mengurangi jejak karbon produknya dengan setiap produk baru yang diproduksi, sambil memberikan kemajuan inovatif dalam kinerja. Praktik ini dalam transparansi melalui ringkasan PCF terperinci akan meningkatkan pemahaman tentang dampak komputasi yang dipercepat.
NVIDIA berkomitmen untuk bekerja untuk menerbitkan data tambahan yang dapat diandalkan tentang dampak lingkungan dari produk NVIDIA. NVIDIA akan terus berinovasi menuju masa depan komputasi berkelanjutan dan pengembangan AI, tanpa berkompromi pada kinerja dan skala.
Untuk mempelajari lebih lanjut, baca ringkasan jejak karbon produk untuk NVIDIA HGX B200.
Dalam rekayasa modern, laju inovasi terkait erat dengan kemampuan untuk melakukan simulasi yang dipercepat. Computer-Aided Engineering (CAE) memainkan peran penting dalam desain optimal dan…
Teknologi Autonomous Vehicle (AV) dengan cepat berkembang, dipicu oleh model AI yang semakin besar dan lebih kompleks yang digunakan di tepi. Kendaraan modern sekarang tidak hanya membutuhkan persepsi dan sensor lanjutan…
Yang terbaru untuk devs dari made by google, pembaruan ke Gemini di Android Studio, ditambah androidify baru: episode musim panas kami dari The Android Show
Diposting oleh Matthew McCullough – VP manajemen produk, pengembang Android dalam ekosistem yang dinamis dan kompleks ini, komitmen kami adalah untuk …
