Protein-ligand affinity evaluation method based on domestic supercomputing platform

Abstract

The application provides a protein-ligand affinity evaluation method based on a domestic supercomputing platform, comprising: a domestic supercomputing production environment building step comprising: compiling dependent libraries required for running a deep learning model, and completing framework configuration of SWPyTorch; a deep learning model design and implementation step comprising: constructing a deep learning model based on a protein-ligand affinity evaluation dataset, implementing the deep learning model based on a PyTorch framework under an X86 platform, after model implementation, model transplantation, and transplantation of the deep learning model to the domestic supercomputing platform; a deep learning model parallel optimization step comprising: based on the domestic supercomputing platform, optimizing the deep learning model from data parallelism, calculation parallelism, communication parallelism, operator library optimization, and SWPyTorch multi-node parallelism; and a job submission and running step comprising: configuring computing node resources of the domestic supercomputing platform, activating a dependent environment of the domestic supercomputing platform, and submitting a running job.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of high-performance computing, and more particularly, to a protein-ligand affinity evaluation method based on a domestic supercomputing platform. BACKGROUND

[0002] A supercomputer is an important symbol for measuring the development level of science and technology and the comprehensive national power of a country, has the characteristics of strong function, fast operation speed and large storage capacity, supports the calculation of large-scale complex application projects, and can be widely applied in the medical field and high-tech field. In recent years, the domestic supercomputer represented by "Sunway TaihuLight" has developed rapidly. "Sunway TaihuLight" is the world's first supercomputer with a performance of more than 100 PFlops.

[0003] The supercomputer plays an important role in the medical field, especially in the field of drug virtual screening. Protein-ligand affinity evaluation is a key stage in the process of drug virtual screening and drug development. Accurate and efficient protein-ligand affinity evaluation will greatly reduce the development cycle and development cost of drugs. At present, the protein-ligand affinity evaluation method based on a supercomputer relies on the Intel X86 instruction set architecture in hardware, and uses the molecular docking software developed by European and American universities, research institutes or companies in software.

[0004] Therefore, it is urgent to develop a protein-ligand affinity evaluation method based on a domestic supercomputing platform. SUMMARY

[0005] The present application provides a protein-ligand affinity evaluation method based on a domestic supercomputing platform to solve the problem that the existing protein-ligand affinity evaluation method based on a supercomputing platform cannot support large-scale protein-ligand affinity evaluation. The method relies on a domestic supercomputing platform to build a "protein-ligand affinity evaluation method" production environment and realize the design, transplantation and optimization of a "protein-ligand affinity evaluation" model based on deep learning technology under the domestic supercomputing platform.

[0006] To achieve the above purpose, the present application provides a protein-ligand affinity evaluation method based on a domestic supercomputing platform, comprising:

[0007] The steps of building a domestic supercomputing production environment include: compiling the dependent library required for running the deep learning model, and completing the framework configuration of SWPyTorch;

[0008] The design and implementation steps of the deep learning model include: constructing a deep learning model based on a protein-ligand affinity evaluation dataset, implementing the deep learning model based on the PyTorch framework under the X86 platform, after completing the model implementation, model transplantation, and transplanting the deep learning model to a domestic supercomputing platform;

[0009] The parallel optimization steps of the deep learning model include: based on the domestic supercomputing platform, optimizing the deep learning model from data parallelism, computation parallelism, communication parallelism, operator library optimization, and SWPyTorch multi-node parallelism;

[0010] The job submission and running steps include: configuring the computing node resources of the domestic supercomputing platform, activating the dependent environment of the domestic supercomputing platform, and submitting the running job.

[0011] Further, the deep learning model adopts a model based on a Bi-LSTM neural network combined with an attention mechanism.

[0012] Further, the large-scale protein-ligand affinity evaluation dataset contains 342 million protein-ligand interaction data, mainly covering protein-compound interaction data and protein-protein interaction data, and also includes structure sequence data of proteins and compounds. The affinity features of the structure sequence data include pharmacophore, molecular skeleton, hydrophobic group, water solubility, and lipid solubility.

[0013] Further, the model structure based on the Bi-LSTM neural network combined with the attention mechanism includes:

[0014] After inputting the structure sequence data of the protein and the compound, the word embedding vector is obtained through word2vec vectorization processing;

[0015] The word embedding vector is input into the convolution layer for multiple convolution operations to obtain a feature sequence;

[0016] The feature sequence is input into the Bi-LSTM neural network structure, and the feature information output by the Bi-LSTM neural network structure is used as the input of the attention mechanism layer;

[0017] The feature information is processed by the attention mechanism layer to adjust the weight of the feature information, and a text representation covering the special structure features of the molecule is obtained;

[0018] The text representation is integrated to obtain a comprehensive text representation, which is used as the input of the Softmax classifier;

[0019] After classifying the affinity between the protein and the ligand through the Softmax classifier, the affinity evaluation result between the protein and the ligand is obtained.

[0020] Further, the dependent library includes 13 Python libraries, including: torch, torchtext, sklearn, django, fire, os, numpy, random, json, jieba, collections, sys and opt.

[0021] Further, the step of building a domestic supercomputing production environment further includes loading SWPyTorch and SWPython into a specified directory and configuring an environment variable.

[0022] Further, the step of parallel optimization of the deep learning model further includes sequentially compiling the main program, the main core program and the slave core program by using the sw9gcc compiler, and finally generating an executable program, wherein the device adopts CPU when the model is compiled.

[0023] Further, the step of parallel optimization of the deep learning model specifically includes:

[0024] Data parallelism includes setting the minibatch setting space capacity of each computing node to 64K;

[0025] Computational parallelism includes master-slave core operation optimization and multi-node parallel optimization; the master-slave core operation optimization is to automatically call the slave core resource by adding the-cgsp 64 instruction when submitting the supercomputing cluster job;

[0026] Multi-node parallel optimization is to realize distributed data parallelism of the model by calling the algorithm library, and to realize distributed data parallel operation of multiple nodes by adjusting the job submission command;

[0027] Communication parallelism, that is, data transmission optimization between the master core and the slave core, adopts the slave core register to complete the data flow from the memory to the computing unit through the three-level REG-LDM-MEM memory hierarchy access;

[0028] Operator library optimization mainly adopts multi-thread operation optimization method, adds multi-thread operation and code block at the key matrix multiplication operation link, so as to realize the optimization and acceleration of matrix multiplication and deep learning operator library;

[0029] SWPyTorch multi-node parallel, first load the distributed data parallel library in the SWPyTorch framework; model parallel, that is, copy the model to multiple CPUs after obtaining the model; data parallel, the data parallel step includes: obtaining the total number of CPUs in the distributed data parallel, dividing the training set according to the total number of CPUs, distributing the data parallel of the training set, distributing the test set data parallel, distributing the training set data, and distributing the test set data; communication mode setting, initializing the process group, and setting the backend communication mode to mpi.

[0030] Further, the job submission and running step specifically includes:

[0031] The computing node resources include computing nodes, CPU core numbers and storage sizes;

[0032] Activating the dependent environment of the domestic supercomputing platform includes activating the environment of SWPyThon and SWPyTorch and setting the environment variables;

[0033] Job submission and running, that is, submitting to multiple computing nodes for running distributed parallel training of the model by using the bsub command, and completing model prediction by using the bsub command.

[0034] Further, the job submission and running step further includes improving the training performance of the model distributed parallel training through 64 slave cores of each node.

[0035] Compared with the prior art, the advantages and positive effects of the present application are that the present application relies on a domestic supercomputing platform to build a "protein-ligand affinity evaluation method" production environment, the core technology is not subject to foreign manufacturers, and has complete independent intellectual property rights; the present application realizes the design, transplantation and optimization of the "protein-ligand affinity evaluation based on deep learning technology" model under the domestic supercomputing platform, speeds up the machine learning model training and prediction speed, and improves the accuracy and efficiency of large-scale protein-ligand affinity evaluation. BRIEF DESCRIPTION OF DRAWINGS

[0036] Figure 1 The steps of the transplantation method of the deep learning model based on the domestic supercomputing platform provided by the present application are shown;

[0037] Figure 2 The model structure based on the Bi-LSTM neural network fusion attention mechanism of the present application;

[0038] Figure 3 The directory structure after the model implementation based on the PyTorch framework under the X86 platform of the present application;

[0039] Figure 4A framework diagram of a computer device according to an embodiment of the present application;

[0040] In the above figure:

[0041] S1, a step of building a domestic supercomputing production environment; S2, a step of designing and implementing a deep learning model; S3, a step of parallel optimization of the deep learning model; S4, a step of job submission and running; S11, compiling a dependent library; S12, configuring a SWPyTorch framework; S21, constructing a data set; S22, constructing a deep learning model; S23, model implementation; S24, model transplantation; S31, data parallelism; S32, calculation parallelism; S33, communication parallelism; S34, operator library optimization; S35, SWPyTorch multi-node parallelism; S41, configuring computing node resources; S42, activating a dependent environment; S43, job submission and running; 81, a processor; 82, a memory; 83, a communication interface; 80, a bus. DETAILED DESCRIPTION

[0042] The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, not all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative labor fall within the scope of the present application.

[0043] In the description of the present application, it should be understood that the terms "center", "upper", "lower", "front", "back", "left", "right", "vertical", "liquid level", "top", "bottom", "inner", "outer" and the like indicate the orientation or positional relationship shown in the drawings, and are only for the purpose of facilitating the description of the present application and simplifying the description, and do not indicate or imply that the device or element referred to must have a particular orientation, be constructed and operated in a particular orientation, and therefore cannot be understood as a limitation on the present application. The terms "first", "second" are only for the purpose of description, and cannot be understood as indicating or implying relative importance or implicitly indicating the number of the technical features indicated. Therefore, the features limited by "first", "second" can explicitly or implicitly include one or more of the features. In the description of the present application, unless otherwise specified, the meaning of "a plurality of" is two or more.

[0044] In the description of the present application, it should be noted that unless otherwise explicitly specified and limited, the terms "mounting", "connection", "connecting" should be understood in a broad sense, for example, it can be fixed connection, or detachable connection, or integral connection; it can be mechanical connection, or electrical connection; it can be direct connection, or indirect connection through intermediate medium, or internal communication of two elements. For those skilled in the art, the specific meaning of the above terms in the present application can be understood according to the specific circumstances.

[0045] Embodiment one:

[0046] Figure 1 The steps of the method for transplanting the deep learning model based on the domestic supercomputing platform provided by the present application are shown in the schematic diagram as Figure 1 The embodiment discloses a specific implementation of the method for transplanting the deep learning model based on the domestic supercomputing platform.

[0047] Specifically, the method disclosed in the embodiment mainly includes the following steps:

[0048] Step S1: building a domestic supercomputing production environment includes compiling the dependent library required for running the deep learning model, and completing the framework configuration of SWPyTorch;

[0049] Specifically, step S1 specifically includes the following steps:

[0050] Step S11: compile the dependent library, the deep learning model of the present application needs to depend on 13 Python libraries, and the Python library and its version information are shown in Table 1 below. Except for os, random, collections, sys, opt, etc., the remaining Python libraries need to be installed and compiled. In addition, the version of Python is 3.5. The present application performs domestic transplantation of Python, PyTorch and other frameworks based on the domestic supercomputing platform to meet the environmental requirements of the model. The version of Python after transplantation is 3.5, and the version of PyTorch framework is 1.5.

[0051] Dependency library Version number torch ≥1.1.0 torchtext ≥0.4.0 sklearn ≥0.20.3 django ≥3.0.1 fire ≥0.2.1 os ** numpy ≥1.16.2 random ** json ≥2.0.9 jieba ≥0.39 collections ** sys ** opt **

[0052] Table 1

[0053] Step S12: configuring the SWPyTorch framework, SWPytorch is a ported version of Pytorch on a domestic supercomputer, which is a classic multi-dimensional matrix data operation tensor library and is widely used in machine learning and other math-intensive applications. In theory, SWPytorch supports all common models of X86 architecture, and the tested models that have been determined to converge mainly include: AlexNet, RestNet50, Vgg16, Vgg19, LeNet, etc. image recognition models; LSTM, GRU, Transformer, etc. natural language processing models; FasterRCNN, YOLOv3, etc. target detection models. The SWPyTorch framework supports distributed data parallelism, and after the deep learning model is transplanted to the domestic supercomputer, distributed data parallelism and model parallelism under multiple nodes can be realized by changing the source code, thereby improving the efficiency of the model's training, prediction and other functions.

[0054] The SWPyTorch framework used in the application is compiled and transplanted from the PyTorch framework, and the corresponding domestic operation has been completed in the early stage. In the framework configuration process, SWPyTorch and SWPython need to be loaded into the specified directory, and the relevant environment variables are configured, so as to complete the configuration work of the SWPyTorch framework.

[0055] Step S2: design and implementation of a deep learning model, including: constructing a deep learning model based on a protein-ligand affinity evaluation dataset, implementing the deep learning model based on the PyTorch framework on the X86 platform, completing the model implementation, and transplanting the deep learning model to the domestic supercomputer platform after the model implementation;

[0056] Specifically, step S2 specifically includes the following steps:

[0057] Step S21: constructing a dataset, the present application constructs a large-scale protein-compound binding affinity dataset (LPCBDataSet). In terms of data volume, LPCBDataSet contains 342 million protein-compound interaction data. In terms of data composition, it mainly covers: protein-compound interaction data, protein-protein interaction data. In terms of data form, the protein and compound information are both structure sequence data, and certain specific sequence structures often contain active characteristics such as pharmacophore, molecular skeleton, hydrophobic group, water solubility, and fat solubility. The above active characteristics often play a key role in the drugability and activity of drug molecules.

[0058] Step S22: model construction, since the above-mentioned LPCBDataSet dataset covers protein and compound information which are structural sequence data, in some embodiments, the deep learning model is selected to add an attention mechanism on the basis of a bidirectional multi-layer LSTM model, so as to better use the activity features in the molecular structure sequence, thereby improving the performance of the deep learning model.

[0059] As shown in Figure 2 The deep learning model constructed by the present application is a model based on a Bi-LSTM neural network combined with an attention mechanism. The model structure based on the Bi-LSTM neural network combined with the attention mechanism includes: after inputting the structural sequence data of the protein and the compound, word embedding vectors are obtained through word2vec vectorization processing; the word embedding vectors are input into a convolution layer for multiple convolution operations to obtain feature sequences; the feature sequences are input into a Bi-LSTM neural network structure, and the feature information output by the Bi-LSTM neural network structure is used as the input of the attention mechanism layer; the feature information is processed through the attention mechanism layer to adjust the weight of the feature information, and text representation covering special structural features of molecules is obtained; the text representation is integrated to obtain comprehensive text representation, and the comprehensive text representation is used as the input of a Softmax classifier; after classifying the affinity between the protein and the ligand through the Softmax classifier, the affinity evaluation result between the protein and the ligand is obtained.

[0060] Step S23: model implementation, the deep learning model is implemented based on the PyTorch framework under the X86 platform, and the directory structure after implementation is as shown in Figure 3 The data folder stores the dataset, the runs folder stores the model result file, under the src folder, dataset.py is responsible for data set loading and data preprocessing, model.py is a bidirectional LSTM+Attention model file, metrics.py is a model performance metric file, and main.py is the main file of the project.

[0061] Step S24: model transplantation, after the deep learning model is debugged and implemented under the X86 architecture, it needs to be transplanted to a domestic supercomputing platform. On the domestic supercomputing platform, the PyTorch framework has been transplanted (i.e. SWPyTorch framework), and other dependent libraries have also been successfully transplanted. Therefore, the present application only needs to transplant the deep learning model to the domestic supercomputing platform. In the Shenwei environment, the main program, the main core program and the slave core program involved are sequentially compiled through the sw9gcc compiler, and finally an executable program is generated.

[0062] For the deep learning model in the application, since it is based on a python program, it only needs to be compiled successfully in sequence. In addition, the domestic supercomputer does not support GPU acceleration, and the device uses CPU when coding the model. The above completes the transplantation of the deep learning model.

[0063] Step S3: the parallel optimization step of the deep learning model includes: based on the domestic supercomputing platform, optimizing the deep learning model from data parallelism, calculation parallelism, communication parallelism, operator library optimization and SWPyTorch multi-node parallelism;

[0064] Specifically, step S3 specifically includes the following steps:

[0065] Step S31: data parallelism, that is, the training data is divided into blocks. The size of the mini-batch cannot be infinitely expanded, and increasing the mini-batch size of data parallelism will reduce the generalization of the neural network. At the same time, in order to ensure that each computing node has enough computing tasks to play the computing power of the many-core architecture, the mini-batch of each node cannot be too small. Each slave core of the Godson many-core processor has a high-speed local local data storage space LDM, and the total space capacity of LDM is 256KB. The application sets the mini-batch to 64K in combination with the size of the slave core cache.

[0066] Step S32: calculation parallelism, including master-slave core operation optimization and multi-node parallel optimization. Master-slave core operation optimization is mainly based on the many-core architecture of the domestic supercomputer, each node has 1 master core and 64 slave cores, and the slave core is an important computing resource. Fully utilizing the slave core resources can significantly improve the efficiency of model training. The application fully utilizes the slave core resources by adding the-cgsp 64 instruction when submitting the supercomputer cluster job. After adding the instruction, the operation mechanism of the domestic many-core architecture can automatically use the slave core resources, thereby realizing the acceleration of the calculation task. Multi-node parallel optimization is to realize multi-node distributed model training on the basis of single-node operation. The multi-node parallel optimization implementation details mainly cover two aspects: source code, which realizes distributed data parallelism of the model by calling torch.distributed, torch.nn.parallel, torch.utils.data.distributed and other algorithm libraries; and job task submission, which realizes multi-node distributed data parallel operation by adjusting the job submission command. In some embodiments, the following instruction is used as an example:

[0067] bsub -I -akernel-b -o out.log -q q_swhfnl-node 26917-26918-N 10 -cgsp 64 -ro_size 256 -share_size 11000 -mpecg 64 -cache_size 0 python3 main.py -train

[0068] The instruction is to submit a computing task to the q_swhfnl queue, and use 10 nodes between 26917-26918 for parallel operation.

[0069] Step S33: Communication parallelism, that is, optimization of data transmission between the master core and the slave core in the Godson environment. The data flow from the memory to the computing unit is completed by accessing the three-level REG-LDM-MEM memory hierarchy of the slave core register. The data of A and B are loaded into the LDM through the DMA mode, and when each slave core calculates a small block of C, the access to A and B is converted from direct access to the main memory to access to the local LDM.

[0070] Step S34: Operator library optimization, mainly adopting a multi-thread operation optimization method, adding multi-thread operation and code blocks at the key matrix multiplication operation link, thereby realizing optimization and acceleration of matrix multiplication and deep learning operator library. In some embodiments, the added code blocks are as follows:

[0071] #prama omp parallel for num_threads(CORE_NUM)

[0072] Step S35: SWPyTorch multi-node parallelism, first load the distributed data parallel library in the SWPyTorch framework; perform model parallelism, which means copying the model to multiple CPUs after obtaining the model; perform data parallelism, which includes the following steps: obtaining the total number of CPUs in the distributed data parallelism, dividing the training set according to the total number of CPUs, distributing the data parallelism of the training set, distributing the data parallelism of the test set, distributing the training set data, and distributing the test set data; set the communication mode, initialize the process group, and set the backend communication mode to mpi.

[0073] In some embodiments, the specific implementation of SWPyTorch multi-node parallelism is as follows:

[0074] Step S351: Load the distributed data parallel library in the SWPyTorch framework, the instruction is as follows:

[0075] import torch.distributed as dist

[0076] from torch.utils.data.distributed import DistributedSampler

[0077] from torch.nn.parallel import DistributedDataParallel

[0078] Step S352: Model parallel is performed

[0079] Get the custom model

[0080] Model = Model() # Get the model

[0081] Copy the model to multiple CPUs

[0082] model = torch.nn.parallel.DistributedDataParallel(model) # Distributed data parallel

[0083] Step S353: Data parallel is performed

[0084] Get the total number of CPUs in the distributed data parallel

[0085] size = dist.get_world_size()

[0086] Split the training set according to the total number of CPUs

[0087] bsz = int(batch_size / size)

[0088] Training set data parallel distribution

[0089] train_dataset = torch.utils.data.distributed.DistributedSampler(train_dataset)

[0090] Test set data parallel distribution

[0091] test_dataset = torch.utils.data.distributed.DistributedSampler(test_dataset)

[0092] Training set distributed loading

[0093] train_loader=DataLoader(train_dataset,batch_size=bsz,shuffe=(train_dataset is None),sampler=train_dataset)

[0094] Distributed loading of test set data

[0095] test_loader=DataLoader(train_dataset,batch_size=bsz,shuffe=(train_dataset is None),sampler=train_dataset)

[0096] Step S354: Communication method settings

[0097] Initialize the process group and set the backend communication method to MPI.

[0098] dist.init_process_group(backend='mpi')

[0099] Step S4: Job submission and execution, including: configuring the computing node resources of the domestic supercomputing platform, activating the dependent environment of the domestic supercomputing platform, and submitting the job for execution.

[0100] Specifically, step S4 includes the following steps:

[0101] Step S41: Configure compute node resources. Configure compute nodes, number of CPU cores, and storage size according to the actual needs of the task.

[0102] Step S42: Activate the dependent environment, including activating the environments for SWPyThon and SWPyTorch and setting environment variables, specifically including the following steps:

[0103] Step S421: Activate the SWPython environment

[0104] source / usr / sw / swpython / setenv-swpython

[0105] Step S422: Activate the SWPyTorch environment

[0106] . / usr / sw / swpython / setenv-torch

[0107] Step S423: Environment Variable Settings

[0108] export

[0109] LD_LIBRARY_PATH=$dynamic_mpi_lib_path:$LD_LIBRARY_PATH

[0110] export LD_BIND_NOW = 1

[0111] export MPIR_CVAR_ASYNC_PROGRESS=1

[0112] Step S43: Job submission and execution, which involves submitting the job to multiple computing nodes using the bsub command to complete the distributed parallel training of the model, and using the bsub command to complete model prediction. This includes the following steps:

[0113] Step S431: Distributed Parallel Training of the Model

[0114] Submitting to multiple compute nodes using the bsub command:

[0115] bsub-I-akernel-bo out.log-q q_swhfnl-node 26917-26918-N 10-cgsp 64-ro_size 256-share_size 11000-mpecg 6-cache_size 0python3 main.py-train

[0116] Step S432: Model Prediction

[0117] Use the bsub command to perform model prediction:

[0118] bsub-bIo out.log-akernel-q q_sw_expr-shared-n 1-cgsp 64-share_size11000python3 main.py-predict

[0119] Furthermore, the job submission and execution steps also include improving the training performance of the distributed parallel training of the model by utilizing the 64 slave cores on each node. The more node resources used during model training, the higher the training performance; fully utilizing the 64 slave cores on each node can also accelerate training. However, there are capacity limitations in the caching of the master and slave cores, as well as in the LDM communication between the master and slave cores, requiring corresponding optimizations in the model code. Model performance is mainly affected by the dataset size and model structure; given a fixed dataset size, using a pre-trained model results in higher model performance.

[0120] Example 2:

[0121] CombinationFigure 4 As shown, this embodiment discloses a specific implementation of a computer device. The computer device may include a processor 81 and a memory 82 storing computer program instructions.

[0122] Specifically, the processor 81 may include a central processing unit (CPU), an application specific integrated circuit (ASIC), or one or more integrated circuits that can be configured to implement the embodiments of this application.

[0123] The memory 82 may include a mass storage device for data or instructions. For example, and not limitingly, the memory 82 may include a hard disk drive (HDD), a floppy disk drive, a solid-state drive (SSD), flash memory, an optical disk drive, a magneto-optical disk drive, magnetic tape, or a Universal Serial Bus (USB) drive, or a combination of two or more of these. Where appropriate, the memory 82 may include removable or non-removable (or fixed) media. Where appropriate, the memory 82 may be internal or external to a data processing device. In a particular embodiment, the memory 82 is non-volatile memory. In a particular embodiment, the memory 82 includes read-only memory (ROM) and random access memory (RAM). Where appropriate, the ROM may be a mask-programmed ROM, a programmable read-only memory (PROM), an erasable programmable read-only memory (EPROM), an electrically erasable programmable read-only memory (EEPROM), an electrically alterable read-only memory (EAROM), or flash memory, or a combination of two or more of these. Where appropriate, the RAM can be Static Random-Access Memory (SRAM) or Dynamic Random-Access Memory (DRAM). DRAM can be Fast Page Mode Dynamic Random-Access Memory (FPMDRAM), Extended Data Out Dynamic Random-Access Memory (EDODRAM), Synchronous Dynamic Random-Access Memory (SDRAM), etc.

[0124] The memory 82 can be used to store or cache various data files that need to be processed and / or communicated, as well as possible computer program instructions executed by the processor 81.

[0125] The processor 81 reads and executes computer program instructions stored in the memory 82 to implement any of the deep learning model porting methods in the above embodiments.

[0126] In some embodiments, the computer device may further include a communication interface 83 and a bus 80. For example, Figure 4 As shown, the processor 81, memory 82, and communication interface 83 are connected through bus 80 and complete communication with each other.

[0127] The communication interface 83 is used to enable communication between modules, devices, units and / or equipment in the embodiments of this application.

[0128] Communication port 83 can also enable data communication with other components such as external devices, image / data acquisition devices, databases, external storage, and image / data processing workstations.

[0129] Bus 80 includes hardware, software, or both, that couples components of a computer device together. Bus 80 includes, but is not limited to, at least one of the following: data bus, address bus, control bus, expansion bus, and local bus. For example, and not as a limitation, bus 80 may include an Accelerated Graphics Port (AGP) or other graphics bus, an Extended Industry Standard Architecture (EISA) bus, a Front Side Bus (FSB), Hyper Transport (HT) interconnect, an Industry Standard Architecture (ISA) bus, an InfiniBand interconnect, a Low Pin Count (LPC) bus, a memory bus, a Micro Channel Architecture (MCA) bus, a Peripheral Component Interconnect (PCI) bus, a PCI-Express (PCI-X) bus, a Serial Advanced Technology Attachment (SATA) bus, a Video Electronics Standards Association Local Bus (VLB) bus, or other suitable buses, or a combination of two or more of these. Where appropriate, bus 80 may include one or more buses. Although specific buses are described and illustrated in the embodiments of this application, this application considers any suitable bus or interconnection.

[0130] Furthermore, in conjunction with the deep learning model porting methods in the above embodiments, this application embodiment can provide a computer-readable storage medium for implementation. This computer-readable storage medium stores computer program instructions; when these computer program instructions are executed by a processor, they implement any of the deep learning model porting methods in the above embodiments.

[0131] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention in any other way. Any person skilled in the art may make changes or modifications to the above-disclosed technical content to create equivalent embodiments for application in other fields. However, any simple modifications, equivalent changes, and modifications made to the above embodiments based on the technical essence of the present invention without departing from the scope of the present invention shall still fall within the protection scope of the present invention.

Claims

1. A method for evaluating protein-ligand affinity based on a domestically developed supercomputing platform, characterized in that, include: The steps for setting up a domestic supercomputing production environment include: compiling the dependency libraries required for running deep learning models and completing the framework configuration of SWPyTorch; The design and implementation steps of the deep learning model include: constructing a deep learning model based on a protein-ligand affinity evaluation dataset; implementing the deep learning model using the PyTorch framework on the X86 platform; porting the model after implementation; and porting the deep learning model to a domestic supercomputing platform. The parallel optimization steps of the deep learning model include: optimizing the deep learning model based on the domestic supercomputing platform from the aspects of data parallelism, computational parallelism, communication parallelism, operator library optimization, and SWPyTorch multi-node parallelism; The job submission and execution steps include: configuring the computing node resources of the domestic supercomputing platform, activating the dependent environment of the domestic supercomputing platform, and submitting the job for execution.

2. The protein-ligand affinity evaluation method based on a domestic supercomputing platform according to claim 1, characterized in that, The deep learning model is based on a Bi-LSTM neural network with an Attention mechanism.

3. The protein-ligand affinity evaluation method based on a domestic supercomputing platform according to claim 2, characterized in that, The large-scale protein-ligand affinity evaluation dataset contains 34.2 million protein-ligand interaction data, covering protein-compound interaction data and protein-protein interaction data, as well as structural sequence data of proteins and compounds. The affinity characteristics of the structural sequence data include pharmacophores, molecular skeletons, hydrophobic groups, water solubility, and lipid solubility.

4. The protein-ligand affinity evaluation method based on a domestic supercomputing platform according to claim 3, characterized in that, The model structure based on the Bi-LSTM neural network fusion attention mechanism includes: After inputting the structural sequence data of proteins and compounds, word embedding vectors are obtained through word2vec vectorization. The word embedding vector is input into a convolutional layer and subjected to multiple convolution operations to obtain a feature sequence; The feature sequence is input into a Bi-LSTM neural network structure, and the feature information output by the Bi-LSTM neural network structure is used as the input to the attention mechanism layer. The feature information is processed by the attention mechanism layer, and the weights of the feature information are adjusted to obtain a text representation that covers the special structural features of the molecule. The text representations are integrated to obtain a comprehensive text representation, which is then used as input to a Softmax classifier. After classifying the affinity between proteins and ligands using the Softmax classifier, the affinity evaluation results between proteins and ligands are obtained.

5. The protein-ligand affinity evaluation method based on a domestic supercomputing platform according to claim 1, characterized in that, The dependency libraries include 13 Python libraries, including: torch, torchtext, sklearn, django, fire, os, numpy, random, json, jieba, collections, sys, and opt.

6. The protein-ligand affinity evaluation method based on a domestic supercomputing platform according to claim 1, characterized in that, The steps for setting up the domestic supercomputing production environment also include loading SWPyTorch and SWPython into a specified directory and configuring environment variables.

7. The protein-ligand affinity evaluation method based on a domestic supercomputing platform according to claim 1, characterized in that, The parallel optimization steps of the deep learning model also include compiling the main program, main core program, and slave core program in sequence using the sw9gcc compiler to finally generate an executable program. The device uses the CPU during model compilation.

8. The protein-ligand affinity evaluation method based on a domestic supercomputing platform according to claim 1, characterized in that, The parallel optimization steps of the deep learning model specifically include: The data parallelism includes setting the minibatch space capacity of each computing node to 64K; The computational parallelism includes master-slave core operation optimization and multi-node parallelism optimization; the master-slave core operation optimization is achieved by adding the -cgsp 64 instruction when submitting a job in the supercomputing cluster to automatically call slave core resources; The multi-node parallel optimization is achieved by calling the algorithm library to realize the distributed data parallelism of the model, and by adjusting the job submission command to realize the distributed data parallel operation of multiple nodes. The parallel communication, i.e. the optimized data transmission between the master core and the slave core, uses the slave core register to access memory through a three-level REG-LDM-MEM memory hierarchy to complete the flow of data from memory to the computing unit; The operator library optimization adopts a multi-threaded operation optimization method, adding multi-threaded operations and code blocks in the key matrix multiplication operation stage, thereby achieving optimization and acceleration of matrix multiplication and deep learning operator library; The SWPyTorch multi-node parallelism first loads the distributed data parallelism library in the SWPyTorch framework; then it performs model parallelism, which involves copying the model to multiple CPUs after acquisition; finally, it performs data parallelism, which includes: obtaining the total number of CPUs in the distributed data parallelism, dividing the training set according to the total number of CPUs, distributing the training set data in parallel, distributing the test set data in parallel, distributing the training set data in a distributed manner, and distributing the test set data; and finally, it sets the communication mode, initializes the process group, and sets the backend communication mode to MPI.

9. The protein-ligand affinity evaluation method based on a domestic supercomputing platform according to claim 1, characterized in that, The specific steps for submitting and running the job include: The computing node resources include computing nodes, the number of CPU cores, and storage size; The activation of the dependent environment of the domestic supercomputing platform includes activating the SWPyThon and SWPyTorch environments and setting environment variables. The job submission and execution involve using the bsub command to submit the job to multiple computing nodes to complete the distributed parallel training of the model, and using the bsub command to complete the model prediction.

10. The protein-ligand affinity evaluation method based on a domestic supercomputing platform according to claim 9, characterized in that, The job submission and execution steps also include improving the training performance of distributed parallel training of the model through 64 slave cores on each node.

Images