Small molecule drug design method and system

Abstract

The invention discloses a small molecule drug design method and system, and the system comprises a FaaS function management module which is used for packaging and managing algorithm functions in molecular drug design; the embedded module is used for providing browsing, testing, debugging and visual calling capabilities of the FaaS function, and when a user calls a certain function, automatically generating a calling statement, uploading parameters, receiving a result and rendering the result; the flow arrangement and customization module is used for combining a plurality of FaaS functions to form a complete drug design flow and generating an executable flow description file after flow design is completed; and the execution scheduling and elastic resource module is used for dynamically evaluating required resources according to flow task parameters submitted by a user, scheduling functions to computing nodes in a distributed manner, and intelligently predicting a computing bottleneck and dynamically adjusting a resource quota and a queue strategy according to historical execution data. According to the system, the overall throughput rate and the response speed of the system during molecular drug design can be improved on the basis of HPC.

Description

Technical Field

[0001] The present invention relates to the field of high-performance computing integration technologies, and particularly to a method and system for small molecule drug design. Background Art

[0002] With the in-depth application of artificial intelligence (AI) technology in drug research and development, AI-based molecular drug design methods have become an important means for new drug research and development. Such methods usually involve a large number of computationally intensive operations, such as molecular structure prediction, virtual screening, energy calculation, and ADMET property prediction, etc., and need to rely on a high performance computing (HPC) platform to complete. However, traditional HPC resource scheduling modes have problems such as low resource utilization rate, complex task deployment, and insufficient system elasticity. Especially in the scenario of AI drug design workloads with small tasks submitted frequently, the traditional architecture is difficult to meet the dual requirements of fast task response and instant resource release. Summary of the Invention

[0003] In order to solve the problems existing in the prior art, embodiments of the present application provide a method, system, computing device, computer storage medium, and product containing a computer program for small molecule drug design, which can achieve improving the overall system throughput rate and response speed in molecular drug design on HPC.

[0004] In a first aspect, an embodiment of the present application provides a small molecule drug design system, characterized in that the system includes: a FaaS function management module for encapsulating and managing algorithm functions in molecular drug design, including at least one of a molecular conformation generation function, a QSAR prediction function, a molecular docking function, an ADMET property estimation function, an activity prediction function, and a toxicity prediction function. Each function is standardized and encapsulated as an independently deployable FaaS microservice unit, supporting remote calls via RESTful API; a Jupyter Notebook embedding module for providing browsing, testing, debugging, and visual call capabilities for FaaS functions. Based on the Jupyter Notebook front-end interface, scripts are written or preset Notebook templates are executed to individually call or comprehensively test the required functions; and communicate with the backend through the Notebook kernel. When a user calls a certain function, call statements, upload parameters, receive results, and render the results are automatically generated; a process orchestration and customization module for combining multiple FaaS functions to form a complete drug design process. When the process design is completed, an executable process description file is generated; an execution scheduling and elastic resource module for dynamically evaluating the required resources according to the process task parameters submitted by the user, distributing the functions to computing nodes in a distributed manner, and being able to intelligently predict computing bottlenecks based on historical execution data and dynamically adjust resource quotas and queue policies.

[0005] In some possible implementation manners, the FaaS function management module includes: a function registration sub-module for collecting and storing function metadata, including input parameter types, output formats, and runtime environment dependencies; a version control sub-module that supports the coexistence of multiple versions of the same function, data switching, or rolling back to historical versions; a deployment scheduling sub-module that automatically allocates to the local HPC cluster or container environment according to the function resource requirements to achieve high-concurrency task scheduling.

[0006] In some possible implementation manners, the Jupyter Notebook embedding module is specifically used for: automatically generating Python code snippets for calling FaaS functions through a preset template; real-time rendering the raw data returned by the function into an interactive chart or a 3D molecular structure diagram; debugging function parameters and verifying results through graphical operations.

[0007] In some possible implementation manners, the process orchestration and customization module is specifically used for: providing a drag-and-drop graphical interface to define the input-output mapping relationships between function nodes; adding conditional branches, loop control logics, and parameter batch transfer rules; automatically converting the process designed by the user into a DAG directed acyclic graph or a YAML / JSON format description file.

[0008] In some possible implementation manners, the execution scheduling and elastic resource module is specifically configured to: monitor the resource utilization rate of the Kubernetes container cluster and the HPC computing nodes in real time; preferentially allocate lightweight tasks to the elastic container pool of the Kubernetes container cluster, and submit high-density tasks to the Slurm queue of the HPC computing nodes; dynamically adjust the number of Pod replicas or the number of HPC computing cores in response to load fluctuations.

[0009] In some possible implementation manners, the execution scheduling and elastic resource module is further configured to: automatically generate a Pod configuration for a Kubernetes task and mount a persistent storage volume; automatically generate an optimized Slurm script for an HPC task, set MPI parallel parameters and checkpoint intervals.

[0010] In some possible implementation manners, the system adopts a cold start optimization mechanism to automatically warm up the container image to the computing node when the function is called for the first time.

[0011] In some possible implementation manners, the process description file includes at least one of the topological structure of the function execution sequence and dependencies, the input and output parameter mapping rules of each node, and the resource requirement pre-declaration field, and the resource requirement pre-declaration field includes the number of GPUs and the memory quota.

[0012] In some possible implementation manners, the visualization result rendering includes the 3D dynamic display of the binding site of the molecular docking result, the automatic generation of the ADMET property radar chart and the toxicity heat map, and the sorting table and the structure comparison view of the virtual screening result.

[0013] Second aspect, an embodiment of the present application provides a small molecule drug design method, which is characterized in that it is applied to the system as described in any one of claims 1-9. The method includes: encapsulating and managing algorithm functions in molecular drug design, including at least one of: molecular conformation generation function, QSAR prediction function, molecular docking function, ADMET property estimation function, activity prediction function, and toxicity prediction function. Each function is standardized and encapsulated as an independently deployed FaaS microservice unit, supporting remote calls via RESTful API; providing browsing, testing, debugging, and visual call capabilities for FaaS functions. Based on the JupyterNotebook front-end interface, write scripts or execute preset Notebook templates to make individual calls or combined tests on the required functions; and communicate with the backend through the Notebook kernel. When a user calls a certain function, a call statement, upload parameters, receive results, and render the results are automatically generated; combine multiple FaaS functions to form a complete drug design process. When the process design is completed, a executable process description file is generated; dynamically evaluate the required resources according to the process task parameters submitted by the user, and distribute the functions to computing nodes, and can intelligently predict computing bottlenecks based on historical execution data, and dynamically adjust resource quotas and queue policies.

[0014] Third aspect, an embodiment of the present application provides a computer-readable storage medium, including computer-readable instructions. When a computer reads and executes the computer-readable instructions, the computer is caused to execute the method as described in any one of the first aspects.

[0015] Fourth aspect, an embodiment of the present application provides a computing device, including a processor and a memory. Among them, computer program instructions are stored in the memory. When the computer program instructions are run by the processor, the method as described in any one of the first aspects is executed.

[0016] Fifth aspect, an embodiment of the present application provides a product containing a computer program. When the computer program product runs on a processor, the processor is caused to execute the method as described in any one of the first aspects. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings required for description in the embodiments will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present invention. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative efforts.

[0018] Figure 1 It is a schematic structural diagram of a small molecule drug design system provided by an embodiment of the present application;

[0019] Figure 2It is a schematic diagram of the logical structure of a small molecule drug design system provided by an embodiment of the present application;

[0020] Figure 3 It is a schematic flowchart of a small molecule drug design method provided by an embodiment of the present application. Detailed implementation manners

[0021] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Apparently, the described embodiments are some but not all of the embodiments of the present invention. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present invention.

[0022] The term "and / or" in this document is an associative relationship describing associated objects, indicating that three relationships may exist. For example, A and / or B may represent: A exists alone, A and B exist simultaneously, and B exists alone. The symbol " / " in this document represents an "or" relationship between associated objects. For example, A / B represents A or B.

[0023] The terms "first", "second", etc. in the description and claims of this document are used to distinguish different objects, rather than to describe a specific order of objects. For example, the first response message and the second response message are used to distinguish different response messages, rather than to describe the specific order of the response messages.

[0024] In the embodiments of the present application, words such as "exemplary" or "for example" are used to represent examples, illustrations, or explanations. Any embodiment or design solution described as "exemplary" or "for example" in the embodiments of the present application should not be construed as being more preferred or having more advantages than other embodiments or design solutions. Rather, the use of words such as "exemplary" or "for example" is intended to present relevant concepts in a specific manner.

[0025] In the description of the embodiments of the present application, unless otherwise specified, the meaning of "a plurality of" refers to two or more. For example, a plurality of processing units refers to two or more processing units, and a plurality of elements refers to two or more elements.

[0026] To facilitate the understanding of the embodiments of the present application, the following will further explain with specific embodiments in conjunction with the accompanying drawings. The embodiments do not constitute a limitation to the embodiments of the present invention.

[0027] First, the technical terms involved in the embodiments of the present application will be introduced:

[0028] 1. Function as a Service (FaaS) is a cloud computing service model that allows developers to write, run, and manage code snippets or functions in an event-driven manner without having to maintain their own infrastructure.

[0029] Next, the technical solutions provided by the embodiments of the present application will be introduced.

[0030] With the development of the cloud-native computing model, the Function as a Service (FaaS) architecture, with its advantages of serverless, on-demand execution, high elasticity, etc., has become an ideal model for supporting the execution of fine-grained AI tasks. FaaSifying the AI-based molecular drug design task and integrating it into the HPC or edge computing platform can not only improve resource utilization but also contribute to building a standardized and automated molecular drug design process. However, there is currently no dedicated FaaS platform for molecular drug design that can support the release, scheduling, composition, and visual configuration of AI functions, nor is there a user-friendly task process definition and execution interface.

[0031] In view of this, the embodiments of the present application provide a small molecule drug design method, which is oriented to the research and development scenario of molecular drug design with high computational density and highly divisible tasks. The artificial intelligence algorithm functions are FaaS encapsulated, and through means such as process orchestration, interactive invocation, and elastic scheduling of computing resources, a molecular drug design platform with modular combination, visual configuration, and efficient resource utilization is provided, meeting the dual requirements of rapid task response and instant resource release, and capable of greatly improving the overall system throughput and response speed in molecular drug design.

[0032] Exemplarily, Figure 1 shows a schematic structural diagram of a small molecule drug design system provided by the embodiments of the present application. This system is used for the research and development design of small molecule drugs. It should be noted that unless otherwise specified, the molecular drugs referred to in the present application are all small molecule drugs, and the molecules referred to are all small molecules. As Figure 1 shown, the small molecule drug design system 100 includes a FaaS function management module 101, a Jupyter Notebook embedding module 102, a process orchestration and customization module 103, and an execution scheduling and elastic resource module 104.

[0033] Among them, the FaaS function management module 101 is used to encapsulate and manage the core functional algorithms commonly used in artificial intelligence drug design. These include, but are not limited to: molecular conformation generation function, quantitative structure-activity relationship (QSAR) prediction function, molecular docking function, pharmacokinetics method (ADMET) property estimation function, activity prediction function, toxicity prediction function, etc. Each function is standardized and encapsulated into an independently deployable FaaS microservice unit, supporting remote calls via RESTful API, and can be deployed in a local HPC cluster or container environment according to the platform resource situation. The FaaS function management module 101 also includes a function registration sub-module 1011, a version control sub-module 1012, and a deployment scheduling sub-module 1013. Among them, the function registration sub-module 1011 is responsible for collecting and archiving function metadata (such as input and output types, parameter definitions, running environment, etc.); the version control sub-module 1012 supports multi-version switching and rollback of functions; the deployment scheduling sub-module 1013 automatically assigns tasks to available nodes based on function running time and computing requirements, realizing high-concurrency and elastic task scheduling, and fully releasing the heterogeneous computing resource capabilities.

[0034] Specifically, the FaaS function management module 101 is the core component of the entire system, responsible for encapsulating various algorithms and computing functions required in the artificial intelligence drug design process into independently deployable and callable microservice units. The main work of this module can be divided into three aspects: function encapsulation, registration management, and deployment scheduling. For function encapsulation, the commonly used algorithms in molecular drug research and development are standardized and encapsulated, such as core functions like molecular conformation generation, QSAR prediction, molecular docking, ADMET property estimation, activity prediction, and toxicity prediction. After being encapsulated, these algorithms will be converted into independent functions with clear input and output interfaces, and each function can be remotely called via RESTful API. Special attention needs to be paid to the function running environment configuration during the encapsulation process, including required software dependencies, hardware resource requirements, etc., to ensure that the function can be correctly executed in different computing environments.

[0035] In terms of function registration management, the system provides a complete life cycle management function. The function registration sub-module 1011 is responsible for collecting and archiving all function metadata information, including function name, function description, input parameter definition, output result format, running environment requirements, etc. This information will be stored in the platform's metadata database for subsequent query and invocation. To support the iterative update of algorithms, the version control sub-module 1012 allows multiple versions of the same function to exist. Researchers can select a specific version for invocation as needed or roll back to a previous stable version at any time. This multi-version management mechanism not only ensures the continuous iteration of new functions but also guarantees the repeatability of key experiments.

[0036] When a function needs to be actually deployed and executed, the deployment scheduling sub-module 1013 comes into play. This sub-module will intelligently determine on what type of computing nodes to deploy the function based on the computing characteristics of the function and the current system resource status. For functions with relatively small computational requirements and short running times, they are usually deployed in a Kubernetes container cluster, taking advantage of its fast startup and elastic scaling characteristics; while for computationally intensive long-term tasks, such as molecular dynamics simulations, etc., they will be preferentially allocated to an HPC high-performance computing cluster for execution. The scheduling system will monitor the load conditions of each computing node in real time and dynamically adjust the task allocation strategy to ensure that system resources are fully utilized and at the same time ensure that critical tasks can be completed in a timely manner.

[0037] The Jupyter Notebook embedding module 102, as an interactive invocation interface layer for researchers, provides the ability to browse, test, debug, and visually invoke all FaaS functions in the platform. Based on the Jupyter Notebook front-end interface, researchers can directly make individual invocations or combined tests of the required functions by writing Python scripts or executing preset Notebook templates, achieving a "what you see is what you get" function testing experience. Inside the module, communication with the platform backend is carried out through the Notebook kernel. When a user invokes a certain function, the system automatically generates invocation statements, uploads parameters, receives results, and renders them in intuitive forms such as charts, tables, or structure diagrams. This module improves the interpretability and transparency of functions, enabling researchers without a programming background to easily verify the behavior and performance of AI models, while reducing the function debugging cost and the probability of errors.

[0038] Specifically, the Jupyter Notebook embedding module 102 provides researchers with an intuitive interactive operation interface, enabling them to directly call various FaaS functions in the platform for drug design-related research work. The core function of this module is to serve as a bridge between the platform and users, presenting the underlying complex computing functions to scientific researchers in a simple and easy-to-use manner. Researchers can call various algorithm functions provided by the platform by writing Python code or using preset templates in the familiar Jupyter Notebook environment. When a user needs to execute a certain computing task, such as molecular docking or toxicity prediction, they only need to write a few simple call codes in the Notebook, and the system will automatically handle all subsequent complex processes, including parameter passing, task scheduling, calculation execution, and result return. The implementation of the Jupyter Notebook embedding module 102 relies on the close integration between the Jupyter Notebook kernel and the platform backend. When a user executes a function call in the Notebook, the system will automatically generate a corresponding API request, package the parameters entered by the user, and send them to the FaaS gateway at the backend. In this process, the module will help users handle many technical details, such as parameter format conversion, addition of authentication information, etc., allowing researchers to focus on the scientific problems themselves without having to worry about the underlying technical implementation. After the function execution is completed, the returned results will be automatically parsed and converted into a format suitable for display in the Notebook, such as data tables, statistical charts, or molecular structure diagrams. For the molecular structure data commonly used in drug design, the module also provides a dedicated 3D visualization function, which allows researchers to intuitively observe the spatial conformation and interaction patterns of molecules.

[0039] To lower the usage threshold, the Jupyter Notebook embedding module 102 provides a large number of preset Notebook templates that cover common drug R & D scenarios. These templates contain complete code examples and documentation, enabling even researchers with limited programming experience to quickly get started. For example, for researchers who want to conduct compound activity screening, they can directly open the corresponding template Notebook, fill in their molecular data according to the prompts, and then execute the code to obtain the prediction results. The templates also include typical result analysis code, which can help researchers quickly understand the meaning of the output data. For more advanced users, they can modify and expand based on these templates to create workflows that meet their specific needs. In terms of debugging and development, the Jupyter Notebook embedding module 102 provides complete tool support. Researchers can step through the code in the Notebook and view the intermediate results at any time, facilitating problem troubleshooting and verifying the correctness of the algorithm. The system also integrates a log output function that can display the detailed process of function calls in real time, helping to understand the execution of each step. When encountering problems, users can quickly consult relevant documents through the built-in help system or view the usage cases of other users. These features greatly reduce the difficulty of algorithm debugging and shorten the research cycle. The Jupyter Notebook embedding module 102 significantly reduces the technical threshold of artificial intelligence drug R & D. Tasks that traditionally required professional computing knowledge and programming skills can now be achieved through simple interactive operations. For example, a medicinal chemist who wants to evaluate a newly designed compound series can import the molecular structure in the Notebook and then sequentially call functions such as physicochemical property prediction, target affinity calculation, and ADMET evaluation to obtain a comprehensive analysis of the compound properties in a short time. The entire process does not require writing complex code or configuring the computing environment, greatly improving the research efficiency. At the same time, since all calculations are performed in the standard environment of the platform, the results have good consistency and comparability, which is conducive to data integration and analysis between different studies.

[0040] The process orchestration and customization module 103 enables users to combine multiple FaaS functions in a visual or domain-specific language (DSL) manner to form a complete molecular drug design process. The platform provides a drag-and-drop process orchestration interface where users can select the required function nodes in the graphical interface and define the dependency relationships, input and output parameter passing methods, execution order, and control flow logic (such as conditional judgment, loop, branch execution, etc.) between them. After the process design is completed, the system automatically converts it into an executable process description file (such as a DAG graph or YAML / JSON structure) and submits it to the backend engine for execution. This module supports process template reuse, batch parameter setting, and process snapshot saving functions, facilitating the reuse of existing design frameworks between different tasks and rapid deployment in specific research scenarios. This module can construct a structured process chain through the combination of "atomic functions" to achieve a modular, parameterized, and traceable AI drug design process, effectively enhancing the flexibility and task adaptation ability of the platform.

[0041] Specifically, the process orchestration and customization module 103 allows researchers to combine multiple independent computing functions into a complete workflow, automating end-to-end drug R & D tasks. The core value of the process orchestration and customization module 103 lies in connecting scattered computing steps into a repeatable and standardized process, greatly improving the execution efficiency of complex drug design tasks. Researchers can create processes in two main ways: one is to use an intuitive graphical interface for drag-and-drop orchestration, and the other is to define the process in code through a domain-specific language (DSL). The graphical interface lowers the usage threshold. Users can select the required function nodes on the canvas, use lines to represent the data flow, and set conditional judgment and loop control logic. The whole process is similar to drawing a flowchart. For users more familiar with programming, the DSL provides more flexible control capabilities and can precisely describe the process logic using syntax similar to natural language. During the process design, the system will verify in real time whether the connections of each node are reasonable, such as checking whether the output type of the upstream node matches the input requirements of the downstream node. This real-time verification mechanism helps users detect design errors early and avoid problems during execution. Users can set specific parameter values for each node or define parameter passing rules to let the output of the upstream node automatically fill the input parameters of the downstream node. For tasks that require batch processing, such as simultaneously evaluating multiple candidate molecules, the system supports the parameter scanning function and can automatically distribute a set of input data to each execution instance of the process. After the process design is completed, the system will convert it into a standard process description file, usually in JSON or YAML format based on the DAG (directed acyclic graph) structure. This standardized representation enables the process to be transplanted and reused in different computing environments.

[0042] In some possible embodiments, the process arrangement and customization module 103 will also intelligently manage the dependencies between nodes. When a node completes the calculation, it automatically triggers all subsequent tasks that depend on the node. For branches that can be executed in parallel, the engine will use the system's computing resources to run simultaneously as much as possible to shorten the overall execution time. During the execution process, the engine will continue to monitor the status of each node and record detailed execution logs, including start and end time, resource usage, input and output data, etc. This information not only helps users understand the execution of the process, but also provides a basis for subsequent performance optimization. The system pre-sets standard processes for a variety of common drug development scenarios, such as lead compound optimization, virtual screening, ADMET property prediction, etc. Researchers can use these templates directly, or adjust them based on them to quickly start their own research projects. Users can also save their own successful processes as templates for their subsequent use or share with team members. The template reuse mechanism significantly reduces repetitive work and ensures the consistency of research methods. The system also supports process version management, records the history of each modification, and facilitates backtracking and comparison of differences between different versions.

[0043] In some possible embodiments, the process orchestration and customization module 103 may also include a parameter management function. The parameter management function allows users to centrally control the configuration of the entire process. The parameters of all nodes can be viewed and modified in one interface, avoiding the trouble of adjusting each node one by one. For experiments that require repeated testing of different parameter combinations, the system supports a parameter scanning function that can automatically run process instances of multiple parameter combinations and summarize the comparison results. This design is particularly suitable for optimization tasks in drug research and development, such as finding the best molecular modification scheme or screening the optimal formulation formula. Users can also embed Jupyter Notebook nodes in the process to retain the manual intervention link in the automated process; they can also call external data sources or third-party tools to expand the functional scope of the process. The system also supports setting some nodes as manual review points, introducing expert judgment in key decision-making links, and realizing a hybrid working mode of human-machine collaboration.

[0044] The Execution Scheduling and Elastic Resource Module 104 provides task execution scheduling and resource elastic expansion capabilities. The core of the module includes a function runtime monitoring unit, a computing resource load prediction unit, a container scheduling engine, a node manager, etc. After the user submits a process task, the system dynamically evaluates the required resources based on parameters such as task priority, function complexity, data size, and required devices (such as GPUs / TPUs), and distributes the function to computing nodes in a distributed manner. The system supports real-time monitoring of the function running status (including queuing, executing, completed, abnormal, etc.), and can intelligently predict computing bottlenecks based on historical execution data, dynamically adjusting resource quotas and queue policies to prevent task congestion or node idleness. At the same time, this module is compatible with task scheduling systems such as Kubernetes, Slurm, and Ray, and supports deployment on HPC, edge nodes, or cloud computing resources, ensuring task elastic scaling, computing load balancing, and on-demand resource reuse in different deployment environments, greatly improving the overall throughput and response speed of the system.

[0045] Specifically, the Execution Scheduling and Elastic Resource Module 104 is mainly responsible for handling the execution and resource allocation of various computing tasks submitted by users. The design goal of this module is to meet the large-scale and asynchronous concurrent AI function requests, and optimize the overall computing efficiency through intelligent scheduling and elastic resource expansion. The core functions of the module can be decomposed into three main aspects: task scheduling, resource management, and execution monitoring. When the user submits a task through the Jupyter Notebook or API interface, the system will first analyze the task and evaluate the types and scales of the required computing resources, including parameters such as CPU, GPU, memory requirements, and estimated running time. This information will be used as the key basis for resource scheduling to help the system make the optimal allocation decision.

[0046] In terms of task scheduling, the module adopts a hybrid scheduling strategy, which can support the unified management of Kubernetes container resources and HPC high-performance computing resources at the same time. For lightweight short-term tasks, such as molecular scoring or simple property prediction, the system will give priority to allocating them to the Kubernetes elastic container resource pool, and utilize the fast startup and flexible expansion characteristics of container technology to improve resource utilization. Such tasks usually take seconds to minutes to complete and are suitable for using on-demand allocated container resources. For computationally intensive long-term tasks, such as molecular dynamics simulations or full protein structure predictions, the system will submit them to the Slurm task queue of the HPC cluster and call parallel computing frameworks such as the message passing interface (MPI) to execute. This differentiated scheduling method ensures that different types of tasks can obtain the most suitable computing environment, avoiding resource waste and ensuring the execution efficiency of key tasks.

[0047] In terms of resource management, the system continuously monitors the load status of all computing nodes, including metrics such as CPU / GPU utilization, memory occupancy, network bandwidth, etc., and dynamically adjusts the resource allocation strategy based on this real-time data. When a bottleneck is detected in a certain resource pool, the module will automatically trigger the expansion mechanism, adding new worker nodes in the Kubernetes cluster or allocating more computing cores in the HPC environment. This elastic expansion ability enables the system to handle sudden large-scale computing demands without task backlogs due to insufficient resources. At the same time, when the resource utilization drops below a certain threshold, the system will also automatically reduce the resource scale to avoid unnecessary cost expenditures. This dynamic balance mechanism ensures that the computing resources always maintain the optimal configuration state.

[0048] In terms of execution monitoring, it can provide visualization and controllability for the entire scheduling process. The built-in runtime monitoring unit of the module will track the execution status of each task in real time, including different stages such as queuing, preparing, executing, completed, or abnormal. These status information will be displayed to system administrators and end-users through the dashboard, allowing them to understand the task progress at any time. For long-running tasks, the system will generate progress reports regularly, estimate the remaining execution time, and issue alarms in a timely manner when abnormalities are detected. The monitoring data will also be recorded in the log system for subsequent performance analysis and optimization. The accumulation of historical execution data enables the system to establish a prediction model, identify possible computing bottlenecks in advance, and actively adjust the resource allocation strategy to prevent task congestion or node idle situations.

[0049] In addition, the execution scheduling and elastic resource module 104 needs to work in coordination with various computing resource management platforms, including the Kubernetes container orchestration system, the Slurm job scheduling system, and the Ray distributed computing framework, etc. This multi-platform support ability enables the system to be flexibly deployed in different computing environments, whether it is a local HPC cluster, a private cloud, or a public cloud infrastructure. The unified scheduling interface masks the differences in the underlying platforms and provides a consistent experience for users. The module has also been specifically optimized for the interaction with the storage system to ensure that computing tasks can efficiently access the required input data and reliably save the output results to persistent storage. For tasks that need to process a large amount of intermediate data, the system will automatically manage the temporary storage space and clean it up in a timely manner after the task is completed to avoid waste of storage resources.

[0050] Figure 2 It is a schematic diagram of the logical structure of a small molecule drug design system provided by an embodiment of the present application. Please refer to Figure 2 , such as Figure 2As shown in the figure, the overall structure of the system adopts a four - layer hierarchical architecture, namely the user interaction layer, the FaaS service management layer, the hybrid computing resource scheduling layer, and the underlying resource pool. The four - layer architecture of the molecular drug design system constitutes a complete computing service system, forming a clear functional division from the user operation interface to the underlying hardware resources.

[0051] Among them, the user interaction layer, as the top - most layer, directly faces scientific researchers and provides diverse task entrances and operation interfaces. Researchers can submit computational tasks related to specific proteins or genes through the target research module, upload or construct candidate molecular structures in the molecular design module, and use the data precipitation module to manage historical experimental data, modeling data, and training data for reuse by FaaS functions. This layer pays particular attention to the user experience, encapsulating complex computational functions into intuitive operation processes, supporting access to system functions through multiple methods such as Web interfaces, Jupyter Notebook, or APIs, and meeting the operation habits and technical levels of different user groups.

[0052] The FaaS service management layer is in the middle of the architecture, undertaking the management and coordination of the core functions of the system, and realizing the scheduling and life - cycle control of FaaS computing functions. This layer mainly includes three functional modules: function registration, dependency management, and image management. The function registration module is responsible for maintaining the metadata of all available computing functions and supports the registration of AI modules (such as molecular docking, ADMET prediction, etc.). The dependency management module maintains the dependency environment required for function operation (such as Python packages, model files, etc.), ensures that each function can run in the correct software environment, and automatically handles compatibility issues of various libraries and frameworks. The image management module manages the cold start, pre - heating, and automatic caching of container images, improves the service start - up efficiency, optimizes the deployment efficiency of containerized functions, and reduces the cold start delay through pre - loading and caching mechanisms. This layer also implements a unified service gateway, which processes the authentication, routing, and monitoring of all function calls and is the key hub connecting user requests and computing resources.

[0053] The hybrid computing resource scheduling layer is the core for resource adaptation of FaaS functions. It supports the joint scheduling of elastic K8s container resources and high-performance HPC tasks, and can be responsible for dynamically allocating computing resources according to task characteristics, achieving seamless integration of the Kubernetes (i.e., K8s) container cluster and the HPC high-performance computing environment. This layer includes a resource scheduling policy engine that analyzes function attributes and determines the task resource path. That is, it intelligently analyzes the attributes of each task, such as GPU requirements, expected running time, and data scale, and then determines the optimal execution path. Some lightweight and short-cycle tasks will be allocated to the Kubernetes cluster to utilize its fast elastic scaling characteristics; while long-running compute-intensive tasks are submitted to the HPC system and executed by calling parallel computing frameworks such as MPI. This layer also implements cross-cluster load balancing, monitors the utilization rate of each resource pool in real time, and dynamically adjusts the task allocation strategy to ensure the overall efficient operation of the system.

[0054] The underlying resource pool provides the basic computing power and data transmission support for the entire system and integrates a variety of heterogeneous computing devices. The underlying resource pool includes heterogeneous computing nodes, a distributed storage system, and a high-speed network. The heterogeneous computing nodes include multiple types of devices such as GPUs / TPUs / ARMs. The distributed storage system can ensure the efficient reading and writing of function data input / intermediate results / output files. The high-speed network can improve the data interaction performance between containers and HPC nodes in distributed tasks. Specifically, the underlying resource pool includes accelerated computing nodes equipped with GPUs / TPUs for deep learning model training and molecular simulation; conventional CPU computing nodes for handling general tasks; a high-speed distributed storage system to ensure the reliable access of large-scale data; and a low-latency network connection to ensure efficient communication between nodes. The design of the resource pool focuses on flexibility and scalability, supporting both dedicated hardware in local data centers and the access to public cloud resources, and dynamically adjusting the computing capacity according to actual needs. All hardware resources are abstracted and managed through virtualization technology, providing a unified resource interface to the upper layer and hiding the complexity of the underlying implementation. This layered architecture design enables the system to fully utilize the capabilities of advanced computing hardware while maintaining sufficient flexibility to adapt to different deployment environments and the evolving needs of drug research and development.

[0055] The above is the introduction of the molecular drug design system provided by the embodiments of the present application. Based on this system, the embodiments of the present application provide a molecular drug design method.

[0056] Exemplarily, Figure 3 FIG. shows a schematic flowchart of a small molecule drug design method provided by the embodiments of the present application, which shows the overall process of hybrid invocation of HPC and K8S functions based on FaaS. As Figure 3 shown, the method may include the following steps:

[0057] S31: The user submits the target drug molecule data and calculation requirement parameters to the molecular drug design system, generating a function call request.

[0058] In this embodiment, the user can submit the function call task through Jupyter Notebook or the API interface. The system platform will package the parameters and mark the task type (such as prediction / screening / evaluation) and the resource configuration type.

[0059] Specifically, the user initiates the request mainly in two ways: the interactive Jupyter Notebook interface or directly calling the API interface provided by the system. When using Jupyter Notebook, the user can write Python code in a pre-configured working environment and call various drug design functions encapsulated by the platform, such as molecular docking, toxicity prediction, or ADMET property calculation. The system provides detailed documentation and code examples for these common functions, and the user only needs to fill in the input parameters according to the specified format. For researchers who are not familiar with programming, the platform also provides a visual form interface to simplify the calling process through drop-down menus and parameter input boxes. No matter which method is adopted, the user needs to clearly specify several key information when submitting the request: firstly, the specific type of the calculation task, which determines the subsequent resource allocation strategy of the system; secondly, the detailed parameters of the input data, such as the SMILES expression of the molecular structure or the PDB file of the protein; finally, the optional resource configuration requirements, including whether GPU acceleration is required, the memory size requirement, and the task priority, etc.

[0060] S32: The FaaS gateway receives the function call request.

[0061] In this embodiment, the FaaS gateway first performs permission verification and parameter legality verification. If it is detected that the function is in the cold start state (first call or image not loaded), the image preheating mechanism is triggered to quickly pull and load from the image repository to the computing node.

[0062] Specifically, the FaaS gateway receives requests and mainly completes three core tasks: security verification, in-depth parameter inspection, and resource preheating preparation. First, the gateway extracts the identity credentials in the request, including API keys or session tokens, and conducts real-time verification with the platform's identity management system to ensure that the user indeed has the permission to execute the target function. At the same time, fine-grained access control is implemented, such as verifying whether the user has the right to use specific GPU resources or access certain sensitive data sets. After the permission verification passes, the system conducts more rigorous semantic checks on all input parameters, not only confirming that the data format is correct, but also verifying the scientific rationality of the parameter values, such as whether the molecular weight is within a reasonable range, whether the pH value conforms to the characteristics of the biological system, etc. This process is implemented through the built-in domain knowledge rule base and machine learning models, which can identify the vast majority of input errors that do not conform to scientific common sense. For functions that are called for the first time or have not been used for a long time, the system can identify the cold start state, and at this time, the intelligent preheating mechanism is triggered. The gateway checks whether the container image corresponding to the function has been cached on the computing node. If not, it immediately pulls it asynchronously from the central image repository.

[0063] S33: The system makes a routing decision based on the task resource requirements.

[0064] In this embodiment, the system platform makes a judgment based on the task resource requirements. For lightweight function tasks (such as molecular scoring), they are allocated to the K8s elastic container resource pool. For high-density long-term tasks (such as structure prediction), HPC resources are used and submitted to the Slurm task queue.

[0065] Specifically, in the function routing decision stage, the system will intelligently select the optimal execution path based on the characteristics of the task, which is a key link to ensure efficient use of computing resources. The system will first parse the metadata in the task request, including key parameters such as function type, input data scale, hardware acceleration requirements, and make decisions based on real-time resource monitoring data. For lightweight tasks with small computational workloads and short expected running times, such as molecular similarity comparison or simple physical and chemical property prediction, the system will prioritize them to the Kubernetes container cluster. Such tasks can usually be completed in seconds, and the containerized execution environment can be quickly started and released, which is particularly suitable for sudden small-scale computing needs. The system will select nodes with low current load from the cluster, considering indicators such as CPU / GPU utilization and remaining memory to ensure that the task can immediately obtain the required resources. At the same time, for batches of small tasks from the same user, the scheduler will try to package and allocate them to the same node to reduce data transmission overhead. For computationally intensive and long-term tasks, such as molecular dynamics simulation or deep learning model training, the system will choose HPC high-performance computing clusters. Such decisions are based on multiple dimensions of evaluation: first, the task's need for parallel computing. Tasks that require MPI or multi-threading support will be automatically routed to HPC; second, the expected running time. Tasks that exceed the preset threshold will be directly placed in the Slurm queue; and finally, special hardware requirements, such as tasks that require multi-GPU collaboration or high-speed RDMA networks, will also be preferentially allocated to HPC. The system will be deeply integrated with the Slurm job system to automatically generate optimized job scripts, including the correct number of nodes, cores, memory allocation and other parameters, and set reasonable timeout limits and checkpoint intervals. When resources are tight, the system will dynamically adjust the queue order according to task priority, while ensuring that high-priority tasks can quickly obtain resources. Regardless of which execution path is chosen, the routing decision process will record detailed logs, including the decision basis, expected resource consumption and actual allocation. These data will be fed back to the resource prediction model for continuous optimization of future scheduling strategies.

[0066] S34: Execute the assigned task.

[0067] In this embodiment, when it is a lightweight function task, kubel et is called to start the container, mount the persistent volume or temporary storage, and run the function. When it is a high-density long-term task, the system automatically generates a Slurm script and calls HPC to execute the MPI job.

[0068] Specifically, the task execution phase is a crucial process where the system actually deploys the computing tasks to the computing resources and runs them. According to the results of the previous routing decisions, the tasks will enter two different execution paths. For tasks allocated to the Kubernetes container cluster, the system first checks whether there is a pre-warmed container image on the target node. If not, it will quickly pull the required image from the repository. Then, Kubernetes will create a dedicated Pod to run the task, configure an appropriate number of CPU cores and memory resources, and for tasks that require GPU acceleration, it will also mount the corresponding device drivers. When the container starts, it will automatically mount a persistent storage volume or temporary storage space to ensure access to the input data and save the calculation results. During the task execution process, the resource manager will continuously monitor the container status. If it detects situations such as memory leaks or extremely high loads, it will automatically restart the instance or migrate it to other nodes. For tasks allocated to the HPC cluster, the system will first automatically generate an optimized Slurm job script, set the correct number of MPI processes, thread binding policies, and memory allocation parameters. The script will include checkpoint settings to periodically save the calculation status in case of unexpected interruptions. After the task is submitted to the Slurm queue, the system will allocate computing nodes according to the current cluster load and priority policy. When the task starts to execute, the system will ensure that all nodes can access the input data in the shared storage and configure a high-speed network interconnection to support inter-process communication. For tasks that require multi-GPU cooperation, the system will ensure that the allocated nodes have high-speed interconnection devices such as NVLink. During the execution process, the monitoring agent will periodically collect performance metrics, including CPU / GPU utilization, memory consumption, network I / O, etc. These data are used for both real-time monitoring and subsequent performance analysis and optimization. Regardless of which execution path, the system will maintain detailed status information for each task, including start time, running duration, resource usage, etc. This information will be updated in real-time to the task management system for users to query and monitor. At the same time, the standard output and error logs on all computing nodes will be centrally collected and indexed for easy problem troubleshooting and result verification.

[0069] S35: Receive the returned operation results and release the system resources.

[0070] In this embodiment, if it is executed by K8s, the Pod destruction or resource scaling down will be automatically triggered. If it is executed by HPC, the result transfer will be triggered after the MPI process ends. The results will be written through object storage and asynchronously returned to the front-end page, and the user will be triggered to view (such as WebSocket, email, etc.).

[0071] Specifically, after the calculation task is completed, for tasks executed through Kubernetes containers, the system will first automatically upload the calculation result files in the Pod to the distributed object storage, including structured data files, log records, and visualization charts, etc. This process adopts a chunk verification mechanism to ensure the integrity of data transmission, and at the same time, sensitive data will be encrypted. After the result storage is completed, the system will decide whether to immediately destroy the Pod according to the preset policy: for one-time tasks, resources are usually directly released, while for functions that may be repeatedly called, the warm-up state will be retained for a period of time. When recycling resources, the temporary storage space will be cleaned up, all intermediate files will be removed, but necessary audit logs will be retained for subsequent analysis. At the same time, the system will update the resource pool status, re-mark the released computing resources as available for other task scheduling. For long-running tasks executed on the HPC cluster, since such tasks usually generate a large amount of output data, the system will start a dedicated data transfer service to merge and organize the result files scattered on each computing node, and store them in the high-performance storage system after compression and optimization. For special tasks such as molecular dynamics simulations, a structured metadata description file will also be automatically generated to record key simulation parameters and time steps, etc. After the MPI job ends, the Slurm controller will notify the system to release the occupied computing nodes. At the same time, the system will check whether certain intermediate results need to be retained for subsequent analysis. Regardless of which execution method, the final result will be notified to the user through a unified message notification mechanism: for interactive tasks, the result will be pushed to the front-end interface in real time through WebSocket; for batch tasks, an email or in-site notification will be sent. The system will also generate a standardized result report, including statistical information such as execution time and resource consumption, as well as visualization charts and molecular structure displays. All results will be associated with the original task request for storage, and users can trace and query at any time through the task ID. The system will also automatically clean up historical data that exceeds the retention period to save storage space.

[0072] The above is the introduction to the molecular drug design method provided by the embodiments of the present application. By encapsulating drug R & D algorithms into standardized FaaS functions (such as molecular docking, ADMET prediction, etc.), an interactive call interface is provided through Jupyter Notebook to support visual process orchestration. The system adopts a hybrid scheduling architecture and automatically allocates tasks to Kubernetes containers (lightweight tasks) or HPC clusters (compute-intensive tasks) according to task characteristics to achieve elastic resource management. Drag-and-drop process design allows multiple functions to be combined to form a complete R & D process, intelligent resource scheduling, real-time monitoring, and optimization of computing resource allocation, result visualization display, supporting 3D rendering of molecular structures and data analysis. This system significantly reduces the technical threshold of AI drug R & D, improves the utilization rate of computing resources, and can accelerate the new drug R & D process.

[0073] It should be understood that the magnitudes of the sequence numbers of the steps in the foregoing embodiments do not imply the order of execution. The order of execution of each process should be determined according to its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present application. In addition, in some possible implementation manners, the steps in the foregoing embodiments may be selectively executed according to actual situations, may be partially executed, or may be all executed, which is not limited herein. All or part of any feature of any embodiment of the present application may be freely combined anywhere without conflict. The combined technical solution is also within the scope of the present application.

[0074] Based on the method in the foregoing embodiments, an embodiment of the present application provides a computer-readable storage medium. The computer-readable storage medium stores a computer program. When the computer program runs on a processor, the processor is caused to execute the method in the foregoing embodiments.

[0075] Based on the method in the foregoing embodiments, an embodiment of the present application provides a computer program product. When the computer program product runs on a processor, the processor is caused to execute the method in the foregoing embodiments.

[0076] It should be understood that the processor in the embodiments of the present application may be a central processing unit (CPU), or may also be other general-purpose processors, digital signal processors (DSPs), application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), or other programmable logic devices, transistor logic devices, hardware components, or any combination thereof. The general-purpose processor may be a microprocessor or any conventional processor.

[0077] The method steps in the embodiments of the present application can be implemented in a hardware manner or by a processor executing software instructions. The software instructions can be composed of corresponding software modules, and the software modules can be stored in a random access memory (RAM), flash memory, read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), registers, hard disk, removable hard disk, CD-ROM, or any other form of storage medium well known in the art. An exemplary storage medium is coupled to the processor so that the processor can read information from the storage medium and write information to the storage medium. Of course, the storage medium can also be a component of the processor. The processor and the storage medium can be located in an ASIC.

[0078] In the above embodiments, it can be implemented in whole or in part by software, hardware, firmware, or any combination thereof. When implemented using software, it can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the processes or functions described in the embodiments of the present application are generated in whole or in part. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable devices. The computer instructions can be stored in a computer-readable storage medium or transmitted through the computer-readable storage medium. The computer instructions can be transmitted from one website, computer, server, or data center to another website, computer, server, or data center by wire (such as coaxial cable, optical fiber, digital subscriber line (DSL)) or wireless (such as infrared, wireless, microwave, etc.). The computer-readable storage medium can be any available medium that the computer can access or a data storage device such as a server or data center that includes one or more integrated available media. The available medium can be a magnetic medium (for example, a floppy disk, a hard disk, a magnetic tape), an optical medium (for example, a DVD), or a semiconductor medium (for example, a solid state disk (SSD)), etc.

[0079] It can be understood that the various numerical numbers involved in the embodiments of the present application are only for the convenience of description and do not limit the scope of the embodiments of the present application.

Claims

1. A small molecule drug design system, characterized in that, The system includes: The FaaS function management module is used to encapsulate and manage algorithm functions in molecular drug design, including at least one of a molecular conformation generation function, a QSAR prediction function, a molecular docking function, an ADMET property estimation function, an activity prediction function, and a toxicity prediction function. Each function is standardized and encapsulated as an independently deployed FaaS microservice unit, supporting RESTful API remote calls; The Jupyter Notebook embedding module is used to provide browsing, testing, debugging, and visualization calling capabilities for FaaS functions. Based on the Jupyter Notebook front-end interface, scripts are written or preset Notebook templates are executed to individually call or comprehensively test the required functions; and communicate with the backend through the Notebook kernel. When a user calls a certain function, call statements, upload parameters, receive results, and render the results are automatically generated; The process orchestration and customization module is used to combine multiple FaaS functions to form a complete drug design process. When the process design is completed, an executable process description file is generated; The execution scheduling and elastic resource module is used to dynamically evaluate the required resources according to the process task parameters submitted by the user, and distribute the functions to computing nodes in a distributed manner, and can intelligently predict computing bottlenecks based on historical execution data and dynamically adjust resource quotas and queue policies.

2. The system according to claim 1, wherein The FaaS function management module includes: The function registration sub-module is used to collect and store function metadata, including input parameter types, output formats, and runtime environment dependencies; The version control sub-module supports the coexistence of multiple versions of the same function, and data can be switched or rolled back to historical versions; The deployment scheduling sub-module automatically allocates according to the function resource requirements to the local HPC cluster or container environment to achieve high-concurrency task scheduling.

3. The system according to claim 1, characterized in that The Jupyter Notebook embedding module is specifically used for: Automatically generating Python code snippets for calling FaaS functions through preset templates; Real-time rendering of the original data returned by the function into an interactive chart or a 3D molecular structure diagram; Debugging function parameters and verifying results through graphical operations.

4. The system according to claim 1, wherein The process orchestration and customization module is specifically used for: Providing a drag-and-drop graphical interface to define the input-output mapping relationship between function nodes; Adding conditional branches, loop control logic, and parameter batch transfer rules; Automatically converting the process designed by the user into a DAG directed acyclic graph or a YAML / JSON format description file.

5. The system according to claim 1, wherein The execution scheduling and elastic resource module is specifically used for: Real-time monitoring of the resource utilization rate of the Kubernetes container cluster and HPC computing nodes; Prioritizing the allocation of lightweight tasks to the elastic container pool of the Kubernetes container cluster, and submitting high-density tasks to the HPC computing node Slurm queue; Dynamically adjusting the number of Pod replicas or the number of HPC computing cores to respond to load fluctuations.

6. The system according to claim 5, wherein The execution scheduling and elastic resource module is also used for: Automatically generating Pod configurations for Kubernetes tasks and mounting persistent storage volumes; Automatically generate an optimized Slurm script for HPC tasks, set MPI parallel parameters and checkpoint intervals.

7. The system according to claim 1, wherein The system adopts a cold start optimization mechanism to automatically warm up the container image to the computing node when the function is called for the first time.

8. The system according to claim 1, wherein The process description file includes at least one of the function execution order and the topological structure of the dependency relationship, the input and output parameter mapping rules of each node, and the resource requirement pre-declaration field, and the resource requirement pre-declaration field includes the number of GPUs and the memory quota.

9. The system according to claim 1, wherein The visualization result rendering includes the 3D dynamic display of the binding site of the molecular docking result, the automatic generation of the ADMET property radar chart and the toxicity heat map, the sorting table of the virtual screening result and the structure comparison view.

10. A small molecule drug design method, characterized in that, Applied to the system according to any one of claims 1-9, the method includes: Encapsulate and manage the algorithm functions in molecular drug design, including at least one of a molecular conformation generation function, a QSAR prediction function, a molecular docking function, an ADMET property estimation function, an activity prediction function, and a toxicity prediction function. Each function is standardized and encapsulated into an independently deployed FaaS microservice unit, supporting RESTful API remote calls; Provide the browsing, testing, debugging and visualization calling capabilities of the FaaS function. Based on the Jupyter Notebook front-end interface, write scripts or execute the preset Notebook template to make individual calls or combined tests on the required functions; and communicate with the backend through the Notebook kernel. When the user calls a certain function, automatically generate the call statement, upload the parameters, receive the results and render the results; Combine multiple FaaS functions to form a complete drug design process. When the process design is completed, generate an executable process description file; Dynamically evaluate the required resources according to the process task parameters submitted by the user, and distribute the functions to the computing nodes. It can also intelligently predict the computing bottleneck based on the historical execution data and dynamically adjust the resource quota and queue strategy.

Images