Data processing method, device and computing equipment based on brain-like acceleration card

Abstract

This specification provides a data processing method, device and computing device based on a brain-like accelerator card. Before specific implementation, the brain-like accelerator card can be installed on the target computing device according to the preset installation rules; then, according to the preset construction rules, a program container image that matches the brain-like accelerator card and is compatible with the host machine's environment, software and hardware resources, permissions, etc. is prepared. During specific implementation, multiple associated algorithms related to the requested target data processing are first determined; then the image identifiers of the corresponding multiple target algorithm application container images are determined; based on the image identifiers of the multiple target algorithm application container images, a target computing device deployed with a brain-like accelerator card is constructed and called according to the target image parameter group, and target data processing is performed by running multiple target algorithm application container images. This can simplify the installation and use process of the brain-like accelerator card, and use the brain-like accelerator card to efficiently and accurately complete target data processing.

Description

Technical Field

[0001] This specification belongs to the field of computer technology, and in particular, to a data processing method, device, and computing device based on a brain-like acceleration card. Background Art

[0002] With the development and progress of computer technology, users have put forward higher and higher requirements for computing devices.

[0003] Currently, users want computing devices to support complex and large data processing in business areas such as big data processing, scientific computing, artificial intelligence, cloud computing, etc. However, the computing power of conventional computing devices is relatively limited. Based on existing methods, it is difficult to use conventional computing devices to efficiently and quickly complete the above complex and large data processing.

[0004] To address the above problems, no effective solution has been proposed yet. Summary of the invention

[0005] This specification provides a data processing method, device and computing equipment based on a brain-like acceleration card, which can effectively simplify the installation and use process of the brain-like acceleration card, make full use of the computing power advantages of the brain-like acceleration card, efficiently and accurately complete relatively complex and large target data processing, and improve the overall data processing efficiency.

[0006] This specification provides a data processing method based on a brain-like accelerator card, including:

[0007] receiving a target data processing request;

[0008] According to the target data processing request, determining multiple associated algorithms related to the target data processing;

[0009] According to multiple association algorithms, image identifiers of corresponding multiple target algorithm application container images are determined; wherein the target algorithm application container image is a program container image constructed according to a preset construction rule and matched with a brain-like accelerator card;

[0010] According to the image identifiers of multiple target algorithm application container images, a corresponding target image parameter group is constructed;

[0011] According to the target image parameter group, the target data is processed by calling the target computing device deployed with a brain-like accelerator card to run multiple target algorithm application container images.

[0012] In one embodiment, a corresponding target image parameter group is constructed according to the image identifiers of multiple target algorithm application container images, including:

[0013] In response to a target data processing request, determining an execution relationship between different association algorithms during the target data processing process; wherein the execution relationship includes a parallel relationship and a series relationship;

[0014] According to the execution relationship, the image identifiers of multiple target algorithm application container images are sequentially spliced ​​and combined to obtain a corresponding target image parameter group.

[0015] In one embodiment, according to the target image parameter group, a target computing device deployed with a brain-like accelerator card is called to run multiple target algorithm application container images to perform target data processing, including:

[0016] According to the target data processing request, determine the accelerator card driver container image and the runtime program container image that match the brain-like accelerator card;

[0017] Configure the runtime program container image to obtain the target runtime program container image;

[0018] According to the target image parameter group, a matching component and plug-in container image and a software library container image are determined as the target component and plug-in container image and the target software library container image;

[0019] According to the target image parameter group, the target computing device deployed with the brain-like accelerator card is called, and the matching accelerator card driver container image, target runtime program container image, target component and plug-in container image, target software library container image, and multiple target algorithm application container images are started in sequence to process the target data.

[0020] In one embodiment, the method further comprises:

[0021] According to the preset installation rules, the brain-like accelerator card is installed on the target computing device;

[0022] Start the target computing device and install the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like accelerator card in the operating system environment of the target computing device;

[0023] According to the preset construction rules, an accelerator card driver container image, a runtime program container image, a component and plug-in container image, a software library container image, and a plurality of algorithm application container images corresponding to the accelerator card driver, runtime program, related components and plug-ins, software library, and a plurality of algorithm application programs are produced to construct an accelerator card software integration architecture that meets the requirements.

[0024] In one embodiment, in the operating system environment of the target computing device, after installing an accelerator card driver, a runtime program, related components and plug-ins, a software library, and a plurality of algorithm applications that match the brain-like accelerator card, the method further includes:

[0025] According to preset test rules, in the operating system environment of the target computing device, a first test is performed on the accelerator card driver, runtime program, related components and plug-ins, software libraries, and multiple algorithm applications that match the brain-like accelerator card.

[0026] In one embodiment, according to a preset construction rule, an accelerator card driver container image, a runtime program container image, a component and plug-in container image, a software library container image, and a plurality of algorithm application container images corresponding to the accelerator card driver, the runtime program, the related components and plug-ins, the software library, and the plurality of algorithm application programs are produced, including:

[0027] Obtain and create multiple running containers matching the brain-like accelerator card based on a basic image corresponding to the operating system of the target computing device;

[0028] Through directory mapping, the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications are respectively installed in multiple running containers to obtain corresponding multiple program containers;

[0029] According to preset test rules, a second test is performed on the plurality of program containers in the container environment;

[0030] When it is determined that the second test passes, multiple program containers are exported to obtain corresponding multiple program container images; and the image version number and image name of the program container image are obtained as the corresponding image identifier.

[0031] In one embodiment, in the operating system environment of the target computing device, after installing an accelerator card driver, a runtime program, related components and plug-ins, a software library, and a plurality of algorithm applications that match the brain-like accelerator card, the method further includes:

[0032] According to the preset building rules, obtain and create a running container that matches the brain-like accelerator card based on the basic image corresponding to the operating system of the target computing device;

[0033] Through directory mapping, an accelerator card driver, a runtime program, related components and plug-ins, a software library, and multiple algorithm applications related to target data processing are sequentially installed in the running container to obtain a corresponding target program container;

[0034] According to the preset test rules, a second test is performed on the target program container in the container environment;

[0035] When it is determined that the second test passes, the target program container is exported to obtain a corresponding target program container image; and the image version number and image name of the target program container image are obtained as the corresponding image identifier.

[0036] In one embodiment, after receiving the target data processing request, the method further includes:

[0037] Determine the target data processing type according to the target data processing request;

[0038] Determine a target image identifier of a matching target program container image according to the target data processing type;

[0039] According to the target image identifier, the target computing device deployed with the brain-like accelerator card is called to run the target program container image to perform target data processing.

[0040] This specification also provides a data processing device based on a brain-like acceleration card, including:

[0041] A receiving module, used for receiving a target data processing request;

[0042] A first determination module, configured to determine a plurality of associated algorithms related to target data processing according to a target data processing request;

[0043] The second determination module is used to determine the image identifiers of the corresponding multiple target algorithm application container images according to the multiple association algorithms; wherein the target algorithm application container image is a program container image constructed according to a preset construction rule and matched with the brain-like accelerator card;

[0044] A construction module, used to construct a corresponding target image parameter group according to the image identifiers of multiple target algorithm application container images;

[0045] The running module is used to run multiple target algorithm application container images by calling the target computing device deployed with a brain-like accelerator card according to the target image parameter group to perform target data processing.

[0046] The present specification also provides a computing device, which is deployed with a brain-like acceleration card at least according to a preset installation rule. The computing device also includes a processor and a memory for storing processor executable instructions. When the processor executes the instructions, the following steps are implemented: receiving a target data processing request; determining multiple associated algorithms related to the target data processing according to the target data processing request; determining the image identifiers of the corresponding multiple target algorithm application container images according to the multiple associated algorithms; wherein the target algorithm application container image is a program container image constructed according to preset construction rules and matching the brain-like acceleration card; constructing a corresponding target image parameter group according to the image identifiers of the multiple target algorithm application container images; and running the multiple target algorithm application container images according to the target image parameter group to perform target data processing.

[0047] Based on the data processing method, device and computing device based on the brain-like accelerator card provided in this specification, before specific implementation, the brain-like accelerator card can be installed on the target computing device according to the preset installation rules to enhance the data processing capability of the computing device and obtain the target computing device deployed with the brain-like accelerator card; then, according to the preset construction rules, prepare a program container image that matches the brain-like accelerator card and is compatible with the host machine's environment, software and hardware resources, permissions, etc., and store it in the preset image library. In specific implementation, after receiving the target data processing request, multiple associated algorithms related to the requested target data processing can be determined first; then the corresponding image identifiers of multiple target algorithm application container images can be determined; according to the image identifiers of multiple target algorithm application container images, the corresponding target image parameter group is constructed; and according to the target image parameter group, the target computing device deployed with the brain-like accelerator card is called to perform target data processing by running multiple target algorithm application container images. This can effectively simplify the installation and use process of brain-like acceleration cards, fully utilize the computing power advantages of brain-like acceleration cards, efficiently and accurately complete relatively complex target data processing, improve overall data processing efficiency, and reduce errors during the installation and use of brain-like acceleration cards; in addition, it can also effectively reduce the software level of the application, which helps reduce installation errors caused by hierarchical dependencies. BRIEF DESCRIPTION OF THE DRAWINGS

[0048] In order to more clearly illustrate the embodiments of this specification, the drawings required for use in the embodiments will be briefly introduced below. The drawings described below are only some embodiments recorded in this specification. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0049] Figure 1 is a flowchart of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification;

[0050] Figure 2 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0051] Figure 3 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0052] Figure 4 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0053] Figure 5 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0054] Figure 6 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0055] Figure 7 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0056] Figure 8 It is a schematic diagram of the structure of a server provided by an embodiment of this specification;

[0057] Fig. 9 is a schematic diagram of the structure of a data processing device based on a brain-like acceleration card provided by an embodiment of this specification;

[0058] Fig.10 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0059] Fig.11 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0060] Fig.12 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0061] Fig.13 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example;

[0062] Fig.14 It is a schematic diagram of an embodiment of a data processing method based on a brain-like acceleration card provided by an embodiment of this specification, in a scenario example. DETAILED DESCRIPTION

[0063] In order to enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be described clearly and completely below in conjunction with the drawings in the embodiments of this specification. Obviously, the described embodiments are only part of the embodiments of this specification, not all of the embodiments. Based on the embodiments in this specification, all other embodiments obtained by ordinary technicians in this field without creative work should fall within the scope of protection of this specification.

[0064] Considering that as user needs continue to increase, the data processing operations involved in business areas such as big data processing, scientific computing, artificial intelligence, cloud computing, etc. are becoming increasingly large and complex. However, the computing power of conventional computing devices (such as computers, etc.) is relatively limited and it is difficult to support the processing of such complex and large data.

[0065] In response to the above-mentioned problems and in combination with the root causes of the above-mentioned problems, firstly, this specification considers that brain-like acceleration cards can be introduced and deployed on the basis of conventional computing devices to utilize the performance advantages of brain-like acceleration cards and improve the overall computing power of the computing devices, so that the computing devices can objectively support the above-mentioned complex and huge data processing.

[0066] However, because the architecture and mechanism of brain-like accelerator cards are different from those of conventional accelerator cards, and brain-like accelerator cards are also different from conventional computing devices, users need to spend a lot of time and energy to configure and deploy brain-like accelerator cards when installing and using them. This will increase the user's workload on the one hand, and on the other hand, it is easy to encounter problems such as errors when installing and using brain-like accelerator cards, which will affect the overall processing efficiency.

[0067] Therefore, further, this specification also considers the integrated operation requirements of the brain-like acceleration card and the computing device as the host, and constructs an acceleration card software integration architecture that meets the requirements by pre-preparing a program container image that matches the brain-like acceleration card and is compatible with the host's environment, software and hardware resources, permissions, etc.

[0068] In this way, when it is necessary to process more complex and large target data, you can quickly find the corresponding and pre-configured multiple target algorithm application container images; then call the target computing device deployed with the brain-like accelerator card, and perform target data processing by running multiple target algorithm application container images. This can effectively simplify the installation and use process of the brain-like accelerator card, make full use of the computing power advantage of the brain-like accelerator card, efficiently and accurately complete relatively complex target data processing, improve the overall data processing efficiency, and reduce errors during the installation and use of the brain-like accelerator card. In addition, the use of the above-mentioned accelerator card software integration architecture can effectively reduce the software level of the application, help reduce installation errors caused by hierarchical dependencies, and further reduce errors during the installation and use of the brain-like accelerator card.

[0069] See also Figure 1 As shown, the embodiment of this specification provides a data processing method based on a brain-like acceleration card. The method may include the following contents when it is specifically implemented:

[0070] S101: receiving a target data processing request;

[0071] S102: Determine multiple associated algorithms related to target data processing according to the target data processing request;

[0072] S103: Determine the image identifiers of the corresponding target algorithm application container images according to the multiple association algorithms; wherein the target algorithm application container image is a program container image constructed according to a preset construction rule and matched with the brain-like accelerator card;

[0073] S104: constructing a corresponding target image parameter group according to the image identifiers of the multiple target algorithm application container images;

[0074] S105: According to the target image parameter group, a target computing device deployed with a brain-like accelerator card is called to run multiple target algorithm application container images to perform target data processing.

[0075] The above-mentioned brain-like acceleration card can be specifically understood as a processor that mimics the neural structure of the human brain and supports brain-like computing. It can simulate the high energy efficiency, low power consumption, and real-time characteristics of biological brain neural networks, and has the function of simulating ultra-large-scale pulse real-time communication and computing.

[0076] The above-mentioned brain-like computing can be specifically understood as a general term for a group of technologies that refer to the basic laws of information processing in biological brains, and make changes to the existing computing architecture at multiple levels such as hardware architecture and software algorithms, thereby achieving significant improvements in computing energy efficiency and other aspects. Very Large Scale Integrated (VLSI) systems can be used to imitate the neurobiological architecture presented in the nervous system. Specifically, brain-like computing can be a computing model based on brain-like theory, which refers to a computing model that imitates the structure and function of the brain. Brain-like computing models attempt to simulate the way the brain processes information, including connections and signal transmission between neurons. Its goal is to achieve intelligence and learning capabilities similar to those of the human brain, as well as to handle complex perceptual and cognitive tasks.

[0077] The target data processing request may be specifically understood as request data for requesting relatively complex and large-scale target data processing.

[0078] The above-mentioned target data processing can be specifically, for example, the electromagnetic field fitting calculation of the chip under the high temperature and high pressure environment in the field of scientific computing; it can also be the analysis and prediction of the purchasing preferences of 5 million users based on big data in the field of big data; it can also be the deep reinforcement learning of massive sample data in the field of artificial intelligence, as well as model training, etc.

[0079] Of course, it should be noted that the target data processing listed above is only an illustrative description. In specific implementation, according to specific application scenarios and processing requirements, the target data processing may also include other types of data processing that are more complex and large in other fields and other scenarios. This specification does not limit this.

[0080] During specific implementation, the above-mentioned data processing method based on the brain-like acceleration card can be specifically applied to the server side; wherein, the server can be connected to the target computing device. The above-mentioned target computing device is pre-deployed with a brain-like acceleration card according to the preset installation rules; accordingly, the above-mentioned target computing device can be regarded as a host machine relative to the brain-like acceleration card. In addition, a program container image that matches the brain-like acceleration card and is compatible with the host machine's environment, software and hardware resources, permissions, etc. is prepared in advance according to the preset construction rules; and the above-mentioned program container image is stored in a preset image library for subsequent direct retrieval and use. Among them, each program container image corresponds to an image identifier (for example, a combination of an image name and an image version number).

[0081] Before specific implementation, first, the brain-like acceleration card can be installed on the target computing device according to preset installation rules.

[0082] For details, see Figure 2As shown, the following contents may be included: first inserting the brain-like acceleration card into the PCIE card slot of the motherboard of the target computing device; then combining the parameter information of the brain-like acceleration card and the parameter information of the target computing device, making an acceleration card driver that matches the brain-like acceleration card and is adapted to the target computing device, thereby completing the installation of the brain-like acceleration card and obtaining the target computing device deployed with the brain-like acceleration card. The above-mentioned acceleration card driver is used to combine the brain-like acceleration card based on PCIE communication with containerization.

[0083] Among them, the above-mentioned PCIE (peripheral component interconnect express) can be specifically understood as a high-speed serial computer expansion bus standard.

[0084] Next, according to the preset construction rules, a program container image can be prepared that matches the brain-like acceleration card and is compatible with the host machine's operating environment, software and hardware resources, permissions, etc.; and stored in the preset image library of the target computing device.

[0085] Specifically, it may include the following contents: start the target computing device, and install the accelerator card driver, runtime (or runtime) program, related components and plug-ins, software libraries, and multiple algorithm applications that match the brain-like accelerator card in the operating system environment of the target computing device, such as algorithm application 1, algorithm application 2...algorithm application n, etc. Obtain and create multiple running containers that match the brain-like accelerator card based on the basic image corresponding to the operating system of the target computing device. Through directory mapping, the accelerator card driver, runtime program, related components and plug-ins, software libraries, and multiple algorithm applications are respectively installed in multiple running containers to obtain corresponding multiple program containers. For details, please refer to Fig.13 As shown. Of course, in specific implementation, the relevant components and plug-ins, as well as multiple algorithm applications, can also be installed in multiple running containers through target mapping to obtain multiple corresponding program containers; while the previous architecture does not perform containerization for runtime programs, accelerator card drivers, and software programs with relatively more general software libraries. For details, please refer to Fig.14 shown.

[0086] Then, according to the preset test rules, a second test is performed on multiple program containers in the container environment; when it is determined that the second test passes, multiple program containers are exported to obtain corresponding multiple program container images; and the image version number and image name of the program container image are obtained as the corresponding image identifier; and the above multiple program container images are stored in the preset image library. In this way, an acceleration card software integration architecture that meets the requirements and matches both the brain-like acceleration card and the target computing device can be constructed. Among them, the above runtime (or runtime) can be specifically understood as the state of a program running (or being executed).

[0087] Specifically, a corresponding program container image can be created for each software program. Then, on top of the system software layer that already includes the operating system in the system hardware layer where the target computing device is deployed, a computer software layer that includes multiple program container images, a container engine, and cluster software is constructed to obtain an accelerator card software integration architecture that meets the requirements. In addition, the use of the above accelerator card software integration architecture can effectively reduce the software level of the application program, which helps to reduce installation errors caused by level dependencies. For specific implementation, please refer to Figure 3 As shown, considering the close correlation between software programs at runtime, multiple software programs that are closely related at runtime can be installed in the same runtime container. For example, algorithm applications and software libraries can be installed in the same container 2.

[0088] After completing the above preparations, during the specific implementation, when the user needs to perform more complex and large-scale target data processing, the user terminal he holds can generate a corresponding target data processing request; and then send the target data processing request to the server.

[0089] Among them, the above-mentioned server may specifically include a background server applied to one side of the data computing platform, which can realize functions such as data transmission and data processing. Specifically, the server may be, for example, an electronic device with data computing, storage and network interaction functions. Alternatively, the server may also be a software program running in the electronic device to provide support for data processing, storage and network interaction. In this embodiment, the number of the servers is not specifically limited. The server may specifically be one server, or several servers, or a server cluster formed by several servers.

[0090] The user terminal may specifically include a front end applied to the user side and capable of realizing functions such as data collection and data transmission. Specifically, the front end may be, for example, an electronic device such as a desktop computer, a tablet computer, a laptop computer, a smart phone, etc. Alternatively, the user terminal may also be a software application that can be run in the above electronic devices.

[0091] Specifically, after receiving the target data processing request, the server can first determine the target data processing requested by the target data processing request through data analysis; then, in combination with a preset data processing template, decompose the target data processing to determine the specific data processing logic in the target data processing process; based on the data processing logic, further determine multiple associated algorithms related to the target data processing, as well as the execution relationship between the multiple associated algorithms based on the processing logic.

[0092] The above-mentioned multiple association algorithms may specifically include at least two of the following: Monte Carlo algorithm, QR algorithm, quick sorting algorithm, fast Fourier transform algorithm, fast multipole algorithm, etc.

[0093] The execution relationship may specifically include a parallel relationship and a series relationship. The series relationship may further include information such as the execution order. The parallel relationship may further include information such as parallel triggering conditions.

[0094] Furthermore, the server can determine the image identifiers of the corresponding multiple target algorithm application container images based on multiple association algorithms; and then construct corresponding target image parameter groups based on the image identifiers of the multiple target algorithm application container images; and then, based on the target image parameter group, the server can run multiple target algorithm application container images by calling a target computing device deployed with a brain-like accelerator card, thereby completing relevant target data processing efficiently and conveniently.

[0095] In one embodiment, the above-mentioned construction of a corresponding target image parameter group according to the image identifiers of multiple target algorithm application container images may include the following contents during specific implementation:

[0096] S1: responding to a target data processing request, determining an execution relationship between different association algorithms during the target data processing process; wherein the execution relationship includes a parallel relationship and a series relationship;

[0097] S2: According to the execution relationship, the image identifiers of multiple target algorithm application container images are sequentially spliced ​​and combined to obtain a corresponding target image parameter group.

[0098] Based on the above embodiments, a target mirroring parameter group that meets the requirements can be generated efficiently and accurately.

[0099] In one embodiment, see Figure 4 As shown, according to the target image parameter group, the target computing device deployed with a brain-like accelerator card is called to run multiple target algorithm application container images to process the target data. The specific implementation may include the following contents:

[0100] S1: According to the target data processing request, determine the accelerator card driver container image and runtime program container image that match the brain-like accelerator card;

[0101] S2: Configure the runtime program container image to obtain the target runtime program container image;

[0102] S3: According to the target image parameter group, a matching component and plug-in container image and a software library container image are determined as the target component and plug-in container image and the target software library container image;

[0103] S4: According to the target image parameter group, call the target computing device deployed with the brain-like accelerator card, and start the matching accelerator card driver container image, target runtime program container image, target component and plug-in container image, target software library container image, and multiple target algorithm application container images in sequence to process the target data.

[0104] In specific implementation, the corresponding processing requirements can be determined according to the target data processing request; then the runtime program container image is configured according to the processing requirements to obtain the target runtime program container image corresponding to the target data processing.

[0105] Next, according to the target image parameter group, the preset image library can be queried to determine the components and plug-in container images, and software library container images that match multiple target algorithm application container images as the target components and plug-in container images, and target software library container images.

[0106] Furthermore, according to the target image parameters and the operating requirements of the brain-like accelerator card, the target computing device deployed with the brain-like accelerator card can be called to start the matching accelerator card driver container image, target runtime program container image, target component and plug-in container image, target software library container image, and multiple target algorithm application container images in sequence, so as to fully utilize the computing power advantages of the brain-like accelerator card and realize complex and large target data processing.

[0107] In some embodiments, see Figure 5 As shown, when the method is implemented specifically, it may also include the following contents:

[0108] S1: Install the brain-like accelerator card on the target computing device according to the preset installation rules;

[0109] S2: Start the target computing device and install the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like accelerator card in the operating system environment of the target computing device;

[0110] S3: According to the preset construction rules, an accelerator card driver container image, a runtime program container image, a component and plug-in container image, a software library container image, and a plurality of algorithm application container images are produced corresponding to the accelerator card driver, runtime program, related components and plug-ins, software library, and a plurality of algorithm application programs, respectively, so as to construct an accelerator card software integration architecture that meets the requirements.

[0111] Among them, the above-mentioned algorithm application can be specifically understood as an acceleration card application that matches the brain-like acceleration card.

[0112] Based on the above embodiments, before specific implementation, the hardware-level deployment and software-level deployment of the brain-like acceleration card and the target computing device can be completed in sequence according to the preset installation rules and the preset construction rules. Then, the computing power advantage of the brain-like acceleration card can be effectively utilized through the deployed target computing device to complete the required target data processing.

[0113] In some embodiments, after installing an accelerator card driver, runtime program, related components and plug-ins, software libraries, and multiple algorithm applications that match the brain-like accelerator card in the operating system environment of the target computing device, the method may also include: performing a first test on the accelerator card driver, runtime program, related components and plug-ins, software libraries, and multiple algorithm applications that match the brain-like accelerator card in the operating system environment of the target computing device according to preset test rules.

[0114] Based on the above embodiments, according to the preset test rules, a first test can be performed to ensure that the installed accelerator card driver, runtime program, related components and plug-ins, and software library that match the brain-like accelerator card can operate normally at least in the operating system environment of the target computing device.

[0115] During specific implementation, by performing the first test, the corresponding first test result can be collected. According to the first test result, when it is determined that the first test has passed, subsequent data processing can be continued to construct the acceleration card software integration architecture. On the contrary, according to the first test result, when it is determined that the first test has not passed, the abnormal software program that reports an error can be determined according to the first test result; then the operation log of the abnormal software program during the first test process is queried to determine the cause of the error; combined with the cause of the error, the operating parameters of the operating system environment of the target computing device, and the parameter information of the brain-like acceleration card, the configuration parameters of the abnormal software program (for example, permission parameters, dependencies, etc.) are modified and debugged in a targeted manner to ensure that the above-mentioned software program can run normally under the operating system environment of the target computing device.

[0116] In some embodiments, see Figure 6 As shown, according to the preset construction rules, the accelerator card driver container image, runtime program container image, component and plug-in container image, software library container image, and multiple algorithm application container images corresponding to the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm application programs are produced. When implemented specifically, the following contents may be included:

[0117] S1: Obtain and create multiple running containers matching the brain-like accelerator card based on the basic image corresponding to the operating system of the target computing device;

[0118] S2: installing the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications in multiple running containers respectively through directory mapping to obtain multiple corresponding program containers;

[0119] S3: performing a second test on the plurality of program containers in the container environment according to a preset test rule;

[0120] S4: When it is determined that the second test passes, multiple program containers are exported to obtain corresponding multiple program container images; and the image version number and image name of the program container image are obtained as the corresponding image identifier.

[0121] Based on the above embodiments, a program container image that matches the brain-like accelerator card and the target computing device and can run normally in a container environment can be automatically and efficiently constructed according to preset construction rules, and then a reliable and stable accelerator card software integration architecture can be constructed based on the above program container image.

[0122] In specific implementation, the container engine Docker can be installed on the target computing device; and then a Docker base image based on the operating system of the target computing device is obtained to create a corresponding running container.

[0123] During specific implementation, by performing the second test, the corresponding second test result can be collected. According to the second test result, when it is determined that the second test has passed, subsequent data processing can be continued to construct the acceleration card software integration architecture. On the contrary, according to the second test result, when it is determined that the second test has not passed, the abnormal program container image that reports an error can be determined according to the second test result; then the operation log of the abnormal program container image during the second test process is queried to determine the cause of the error; combined with the cause of the error, the operating parameters of the container environment, and the parameter information of the brain-like acceleration card, the configuration parameters of the abnormal program container image (for example, permission parameters, dependencies, etc.) are modified and debugged in a targeted manner to ensure that the above-mentioned abnormal program container image can run normally in the container environment.

[0124] In specific implementation, after obtaining multiple program container images, the multiple program container images and image identifiers corresponding to the program container images can be stored in a preset image library for subsequent direct retrieval and use.

[0125] In some embodiments, in the operating system environment of the target computing device, after installing an accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like accelerator card, the method may further include the following when implemented:

[0126] S1: According to the preset building rules, obtain and create a running container that matches the brain-like accelerator card based on the basic image corresponding to the operating system of the target computing device;

[0127] S2: through directory mapping, the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications related to target data processing are installed in the running container in sequence to obtain a corresponding target program container;

[0128] S3: performing a second test on the target program container in the container environment according to a preset test rule;

[0129] S4: When it is determined that the second test passes, the target program container is exported to obtain a corresponding target program container image; and the image version number and image name of the target program container image are obtained as the corresponding image identifier.

[0130] Specifically, you can build corresponding program container images for different types of data processing in advance. Figure 7 As shown, a program container image corresponds to a type of data processing, and the program container image may simultaneously contain multiple software programs such as an accelerator card driver, runtime program, related components and plug-ins, software libraries, algorithm applications, etc. related to the type of data processing.

[0131] In some embodiments, after receiving the target data processing request, the method may further include the following when implemented:

[0132] S1: Determine the target data processing type according to the target data processing request;

[0133] S2: Determine a target image identifier of a matching target program container image according to the target data processing type;

[0134] S3: According to the target image identifier, call the target computing device deployed with the brain-like accelerator card to run the target program container image to perform target data processing.

[0135] Based on the above embodiments, the computing power advantage of the brain-like acceleration card can be efficiently utilized to complete relevant target data processing.

[0136] In some embodiments, when the target data processing to be performed is relatively more complex, the method may further include the following when implemented:

[0137] S1: split the target data processing into multiple sub-data processing; and determine the processing relationship between the sub-data processing;

[0138] S2: Construct multiple sub-target mirror parameter groups for each sub-data processing;

[0139] S3: According to the processing relationship between sub-data processing and multiple sub-target image parameter groups, target data processing is performed by calling a target computing device deployed with a brain-like accelerator card to run multiple target algorithm application container images.

[0140] This allows us to take advantage of the computing power of brain-like acceleration cards to complete relatively more complex target data processing.

[0141] As can be seen from the above, the data processing method based on the brain-like acceleration card provided in the embodiment of this specification can be installed on the target computing device according to the preset installation rules before implementation, so as to enhance the data processing capability of the computing device and obtain the target computing device deployed with the brain-like acceleration card; then, according to the preset construction rules, prepare a program container image that matches the brain-like acceleration card and is compatible with the host machine's operating environment, software and hardware resources, permissions, etc., and store it in the preset image library. In specific implementation, after receiving the target data processing request, multiple associated algorithms related to the requested target data processing can be determined first; then the corresponding image identifiers of multiple target algorithm application container images can be determined; according to the image identifiers of multiple target algorithm application container images, the corresponding target image parameter group can be constructed; and according to the target image parameter group, the target computing device deployed with the brain-like acceleration card can be called to perform target data processing by running multiple target algorithm application container images. This can effectively simplify the installation and use process of brain-like acceleration cards, fully utilize the computing power advantages of brain-like acceleration cards, efficiently and accurately complete relatively complex target data processing, improve overall data processing efficiency, and reduce errors during the installation and use of brain-like acceleration cards.

[0142] This specification also provides a server, see Figure 8 The server includes a network communication port 801, a processor 802 and a memory 803, and the above structures are connected through internal cables so that each structure can perform specific data interaction.

[0143] The network communication port 801 may be specifically used to receive a target data processing request.

[0144] The processor 802 can be specifically used to determine multiple associated algorithms related to target data processing according to a target data processing request; determine the corresponding image identifiers of multiple target algorithm application container images according to the multiple associated algorithms; wherein the target algorithm application container image is a program container image constructed according to a preset construction rule and matched with a brain-like acceleration card; construct a corresponding target image parameter group according to the image identifiers of the multiple target algorithm application container images; according to the target image parameter group, perform target data processing by calling a target computing device deployed with a brain-like acceleration card to run the multiple target algorithm application container images.

[0145] The memory 803 may be specifically used to store corresponding instruction programs, target data processing requests, and cache intermediate data such as target image parameter groups, image identifiers, and the like.

[0146] In this embodiment, the network communication port 801 can be a virtual port that is bound to different communication protocols so that different data can be sent or received. For example, the network communication port can be a port responsible for web data communication, a port responsible for FTP data communication, or a port responsible for email data communication. In addition, the network communication port can also be a physical communication interface or communication chip. For example, it can be a wireless mobile network communication chip, such as GSM, CDMA, etc.; it can also be a Wifi chip; it can also be a Bluetooth chip.

[0147] In this embodiment, the processor 802 may be implemented in any appropriate manner. For example, the processor may take the form of a microprocessor or processor and a computer-readable medium storing a computer-readable program code (such as software or firmware) executable by the (micro)processor, a logic gate, a switch, an application specific integrated circuit (ASIC), a programmable logic controller, and an embedded microcontroller, etc. This specification does not limit this.

[0148] In this embodiment, the memory 803 may include multiple levels. In a digital system, anything that can store binary data can be a memory; in an integrated circuit, a circuit with a storage function that has no physical form is also called a memory, such as RAM, FIFO, etc.; in a system, a storage device with a physical form is also called a memory, such as a memory stick, TF card, etc.

[0149] Based on the above algorithm, the relevant structural performance of the server can be effectively utilized, the data processing speed of electronic equipment can be improved, and data processing based on brain-like acceleration cards can be efficiently realized.

[0150] The present specification also provides a computing device, wherein the computing device is deployed with a brain-like acceleration card at least according to a preset installation rule, and the computing device also includes a processor and a memory for storing processor executable instructions, and when the processor executes the instructions, it implements: receiving a target data processing request; determining multiple associated algorithms related to the target data processing according to the target data processing request; determining the image identifiers of the corresponding multiple target algorithm application container images according to the multiple associated algorithms; wherein the target algorithm application container image is a program container image constructed according to preset construction rules and matching the brain-like acceleration card; constructing a corresponding target image parameter group according to the image identifiers of the multiple target algorithm application container images; and running the multiple target algorithm application container images according to the target image parameter group to perform target data processing.

[0151] The embodiments of this specification also provide a computer-readable storage medium based on the above-mentioned data processing method based on the brain-like acceleration card, and the computer-readable storage medium stores computer program instructions, which, when executed, implement: receiving a target data processing request; determining multiple associated algorithms related to the target data processing according to the target data processing request; determining the image identifiers of the corresponding multiple target algorithm application container images according to the multiple associated algorithms; wherein the target algorithm application container image is a program container image constructed according to preset construction rules and matched with the brain-like acceleration card; constructing a corresponding target image parameter group according to the image identifiers of the multiple target algorithm application container images; and performing target data processing according to the target image parameter group by calling a target computing device deployed with a brain-like acceleration card to run the multiple target algorithm application container images.

[0152] In this embodiment, the storage medium includes, but is not limited to, a random access memory (RAM), a read-only memory (ROM), a cache, a hard disk (HDD), or a memory card. The memory may be used to store computer program instructions. The network communication unit may be an interface for network connection communication set in accordance with the standard specified by the communication protocol.

[0153] In this embodiment, the functions and effects specifically implemented by the program instructions stored in the computer-readable storage medium can be explained in comparison with other implementations and will not be described in detail here.

[0154] The embodiments of the present specification also provide a computer program product, which at least includes a computer program, and when the computer program is executed by a processor, it implements the following method steps: receiving a target data processing request; determining multiple associated algorithms related to the target data processing according to the target data processing request; determining the image identifiers of the corresponding multiple target algorithm application container images according to the multiple associated algorithms; wherein the target algorithm application container image is a program container image constructed according to a preset construction rule and matched with a brain-like acceleration card; constructing a corresponding target image parameter group according to the image identifiers of the multiple target algorithm application container images; and performing target data processing according to the target image parameter group by calling a target computing device deployed with a brain-like acceleration card to run the multiple target algorithm application container images.

[0155] See also Fig. 9 As shown, the embodiment of this specification also provides a data processing device based on a brain-like acceleration card, which may specifically include the following structural modules:

[0156] The receiving module 901 may be specifically configured to receive a target data processing request;

[0157] The first determination module 902 may be specifically configured to determine a plurality of associated algorithms related to target data processing according to a target data processing request;

[0158] The second determination module 903 may be specifically used to determine the image identifiers of the corresponding multiple target algorithm application container images according to the multiple association algorithms; wherein the target algorithm application container image is a program container image constructed according to a preset construction rule and matched with the brain-like accelerator card;

[0159] A construction module 904 may be specifically used to construct a corresponding target image parameter group according to the image identifiers of multiple target algorithm application container images;

[0160] The running module 905 can be specifically used to run multiple target algorithm application container images according to the target image parameter group by calling the target computing device deployed with a brain-like accelerator card to perform target data processing.

[0161] In some embodiments, when the above-mentioned construction module 904 is implemented, a corresponding target image parameter group can be constructed according to the image identifiers of multiple target algorithm application container images in the following manner: respond to the target data processing request, and determine the execution relationship when different associated algorithms are executed during the target data processing process; wherein the execution relationship includes a parallel relationship and a series relationship; according to the execution relationship, the image identifiers of multiple target algorithm application container images are sequentially spliced ​​and combined to obtain the corresponding target image parameter group.

[0162] In some embodiments, when the above-mentioned running module 905 is specifically implemented, it can be carried out in the following manner according to the target image parameter group, by calling the target computing device deployed with a brain-like accelerator card to run multiple target algorithm application container images to perform target data processing: according to the target data processing request, determine the accelerator card driver container image and the runtime program container image that match the brain-like accelerator card; configure the runtime program container image to obtain the target runtime program container image; according to the target image parameter group, determine the matching component and plug-in container image, and software library container image as the target component and plug-in container image, and the target software library container image; according to the target image parameter group, call the target computing device deployed with a brain-like accelerator card, and start the matching accelerator card driver container image, the target runtime program container image, the target component and plug-in container image, the target software library container image, and multiple target algorithm application container images in sequence to perform target data processing.

[0163] In some embodiments, when the device is implemented, it can also be used to: install the brain-like acceleration card on the target computing device according to preset installation rules; start the target computing device, and install the acceleration card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like acceleration card under the operating system environment of the target computing device; according to preset construction rules, produce acceleration card driver container images, runtime program container images, component and plug-in container images, software library container images, and multiple algorithm application container images that correspond to the acceleration card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications, respectively, so as to construct an acceleration card software integration architecture that meets the requirements.

[0164] In some embodiments, after installing an accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like accelerator card in the operating system environment of the target computing device, the device can also be used to: perform a first test on the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like accelerator card in the operating system environment of the target computing device according to preset test rules.

[0165] In some embodiments, when the device is implemented, it can be produced according to preset construction rules in the following manner to produce acceleration card driver container images, runtime program container images, component and plug-in container images, software library container images, and multiple algorithm application container images corresponding to the acceleration card driver, runtime program, related components and plug-ins, software libraries, and multiple algorithm applications respectively: obtain and create multiple running containers matching the brain-like acceleration card based on the basic image corresponding to the operating system of the target computing device; through directory mapping, respectively install the acceleration card driver, runtime program, related components and plug-ins, software libraries, and multiple algorithm applications in multiple running containers to obtain corresponding multiple program containers; according to preset test rules, perform a second test on multiple program containers in the container environment; when it is determined that the second test passes, export multiple program containers to obtain corresponding multiple program container images; and obtain the image version number and image name of the program container image as the corresponding image identifier.

[0166] In some embodiments, after installing an accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like accelerator card in the operating system environment of the target computing device, the device can also be used when implemented to: obtain and create a running container that matches the brain-like accelerator card based on a basic image corresponding to the operating system of the target computing device according to preset construction rules; install the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications related to target data processing in the running container in sequence through directory mapping to obtain a corresponding target program container; perform a second test on the target program container in the container environment according to preset test rules; when it is determined that the second test passes, export the target program container to obtain the corresponding target program container image; and obtain the image version number and image name of the target program container image as the corresponding image identifier.

[0167] In some embodiments, after receiving a target data processing request, the device can also be used, when implemented, to: determine a target data processing type based on the target data processing request; determine a target image identifier of a matching target program container image based on the target data processing type; and, based on the target image identifier, call a target computing device deployed with a brain-like accelerator card to run the target program container image to perform target data processing.

[0168] It should be noted that the units, devices or modules described in the above embodiments can be implemented by computer chips or entities, or by products with certain functions. For the convenience of description, the above devices are described separately by functions divided into various modules. Of course, when implementing this specification, the functions of each module can be implemented in the same or more software and / or hardware, or the modules that implement the same function can be implemented by a combination of multiple sub-modules or sub-units. The device embodiments described above are only schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0169] It can be seen from the above that the data processing device based on the brain-like acceleration card provided in the embodiment of this specification can effectively simplify the installation and use process of the brain-like acceleration card, can make full use of the computing power advantage of the brain-like acceleration card, efficiently and accurately complete relatively complex target data processing, improve the overall data processing efficiency, and reduce errors during the installation and use of the brain-like acceleration card.

[0170] In a specific scenario example, the data processing method based on the brain-like accelerator card provided in this specification can be applied to realize the software containerization based on the brain-like computing accelerator card application. The specific implementation process may include the following contents.

[0171] In this scenario example, considering the conventional methods of installing existing containerized accelerator card applications and other related programs, the general deployment is: 1. Run the driver and runtime program on the computer cluster node using the accelerator card; 2. Install the dynamic / static library in the default or specified directory; 3. Containerize the algorithm application, and the hierarchical structure is as shown in the attached figure. Figure 3 This approach is mainly based on the consideration that the accelerator card as a hardware device can be shared by different software applications, and the computer's memory mapping can be uniformly allocated and used, and the installation of the software library can be completed step by step.

[0172] However, when the system or cluster uses various software and hardware resources (such as accelerator cards, memory, drivers, runtimes, dynamic / static libraries, etc.), tedious and complex installation and configuration are required. The applications in the container and the host environment and software and hardware resources often cannot be successfully installed and used due to various version matching, permission setting errors, and failures. Therefore, in order to use the accelerator card application efficiently, conveniently, and correctly, it is hoped to provide a simple framework and method for the containerization of the accelerator card application and the installation of other related programs.

[0173] Based on the above ideas, an organizational framework and implementation method for software containerization of brain-like computing accelerator card applications are provided.

[0174] In this scenario example, the software integration method involved consists of a driver, algorithm application, software library, components, and plug-ins, and is implemented using a container engine. For details, see Fig.10 As shown, including the following:

[0175] 1) According to the clear running order and calling relationship of the driver, algorithm application, software library, components and plug-ins related to the accelerator card application, the driver, algorithm application, software library, components and plug-ins are combined together to facilitate version matching and convenient installation between software;

[0176] 2) Combining PCIE communication with containerization by creating a driver image;

[0177] 3) Adjust and flexibly configure the runtime according to specific needs to customize the operating conditions of the container;

[0178] 4) Implement the integrated installation of consistent software packages at the upper layer of the container engine and cluster software.

[0179] The above method is different from the hierarchical structure of general methods. It effectively reduces the software layers of the application and reduces the installation error rate caused by hierarchical dependencies. Secondly, it provides a new software combination method, which can flexibly configure the conditions and functions of the container and the software operating environment to adapt to different scenarios and needs. Moreover, the integration of drivers, applications and related programs provides a convenient installation method and improves the success rate of installation.

[0180] In the first scenario, all relevant programs and components such as the accelerator card driver, algorithm application, corresponding software library, related components and plug-ins can be integrated into one image. Fig.11 When the image is started and running, it needs to be executed in the following order: driver, runtime, related components and plug-ins, application. Specifically, it can include the following steps:

[0181] Step 1: In the preparation stage, install the brain-like computing accelerator card into the computer PCIE slot;

[0182] Step 2: After starting the computer, install the accelerator card driver, algorithm application, corresponding software library, related components and plug-ins in the operating system environment, and make the application run normally in this environment;

[0183] Step 3: Install the container engine Docker, obtain the Docker base image of the corresponding operating system, and create a running container;

[0184] Step 4: Install the accelerator card driver and algorithm application, related component plug-ins and runtime programs in a container through directory mapping, copy the corresponding software static library to the specified directory, and enable the application to run normally in this container environment;

[0185] Step 5: Export the container as a new image and specify the version number;

[0186] Step 6: Configure the corresponding runtime according to the specific environment and application requirements, start the new image and run the application in the container in the predetermined order.

[0187] In the second scenario example, the accelerator card driver, algorithm application and corresponding software library, related components and plug-ins can also be integrated in different images. Fig.12 When the image is started and running, it needs to be executed in the following order: start the driver image, start the runtime image, start the related components and plug-in images, and start the algorithm application image. Specifically, the following steps may be included:

[0188] Step 1: In the preparation stage, install the brain-like computing accelerator card into the computer PCIE slot;

[0189] Step 2: After starting the computer, install the accelerator card driver, algorithm application, corresponding software library, related components and plug-ins in the operating system environment, and make the application run normally in this environment;

[0190] Step 3: Install the container engine Docker, obtain the Docker base image of the corresponding operating system, and create a running container;

[0191] Step 4: Through directory mapping, install the accelerator card driver image in the first container, install the algorithm application and software static library image in the second container, install the relevant component plug-in in the third container, install the runtime program image in the fourth container, and enable the application to run normally in the container environment;

[0192] Step 5: Export the four containers as new images and specify the version numbers.

[0193] Step 6: Configure the corresponding runtime according to the specific environment and application requirements, start the new image and run the application in the container.

[0194] Through the above scenario examples, it is verified that the data processing method based on the brain-like accelerator card provided in this specification can effectively solve the problem of using the brain-like accelerator card in the container environment, provide a convenient software containerization method, and combine the accelerator card driver with the container. Based on this method, it can also reduce the hierarchical dependencies between software, realize the flexible configuration of program groups, and improve the installation efficiency.

[0195] Although the present specification provides method operation steps as described in the embodiments or flow charts, more or less operation steps may be included based on conventional or non-creative means. The order of steps listed in the embodiments is only one way of executing the order of many steps, and does not represent a unique execution order. When the device or client product in practice is executed, it can be executed in sequence or in parallel according to the method shown in the embodiments or the drawings (for example, a parallel processor or a multi-threaded processing environment, or even a distributed data processing environment). The term "include", "include" or any other variant thereof is intended to cover non-exclusive inclusion, so that the process, method, product or device including a series of elements includes not only those elements, but also includes other elements that are not explicitly listed, or also includes elements inherent to such a process, method, product or device. In the absence of more restrictions, it is not excluded that there are other identical or equivalent elements in the process, method, product or device including the elements. The first, second, etc. words are used to represent the name, and do not represent any particular order.

[0196] Those skilled in the art also know that, in addition to implementing the controller in a purely computer-readable program code, the controller can be made to implement the same function in the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers by logically programming the method steps. Therefore, such a controller can be considered as a hardware component, and the devices for implementing various functions included therein can also be considered as structures within the hardware component. Or even, the devices for implementing various functions can be considered as both software modules for implementing the method and structures within the hardware component.

[0197] This specification may be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, classes, etc. that perform specific tasks or implement specific abstract data types. This specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices connected through a communication network. In a distributed computing environment, program modules may be located in local and remote computer-readable storage media including storage devices.

[0198] Through the description of the above embodiments, it can be known that those skilled in the art can clearly understand that the present specification can be implemented by means of software plus a necessary general hardware platform. Based on such an understanding, the technical solution of the present specification can essentially be embodied in the form of a software product, which can be stored in a storage medium such as ROM / RAM, a disk, an optical disk, etc., and includes a number of instructions for enabling a computer device (which can be a personal computer, a mobile terminal, a server, or a network device, etc.) to execute the methods described in each embodiment of the present specification or some parts of the embodiments.

[0199] The various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. This specification can be used in many general or special computer system environments or configurations. For example: personal computers, server computers, handheld devices or portable devices, tablet devices, multi-processor systems, microprocessor-based systems, set-top boxes, programmable electronic devices, network PCs, minicomputers, mainframe computers, distributed computing environments including any of the above systems or devices, etc.

[0200] Although the present specification is described through embodiments, those skilled in the art will appreciate that there are many modifications and changes to the present specification without departing from the spirit of the present specification, and it is intended that the appended claims include these modifications and changes without departing from the spirit of the present specification.

Claims

1. A data processing method based on a brain-like accelerator card, characterized in that: include: receiving a target data processing request; According to the target data processing request, determining multiple associated algorithms related to the target data processing; According to multiple association algorithms, image identifiers of corresponding multiple target algorithm application container images are determined; wherein the target algorithm application container image is a program container image constructed according to a preset construction rule and matched with a brain-like accelerator card; According to the image identifiers of multiple target algorithm application container images, a corresponding target image parameter group is constructed; including: responding to a target data processing request, determining the execution relationship when different associated algorithms are executed during the target data processing process; wherein the execution relationship includes a parallel relationship and a series relationship; according to the execution relationship, the image identifiers of multiple target algorithm application container images are sequentially spliced ​​and combined to obtain a corresponding target image parameter group; According to the target image parameter group, the target computing device deployed with the brain-like accelerator card is called to run multiple target algorithm application container images to process the target data; The method further includes: installing the brain-like accelerator card on the target computing device according to preset installation rules; starting the target computing device, and installing the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like accelerator card under the operating system environment of the target computing device; according to preset construction rules, creating accelerator card driver container images, runtime program container images, component and plug-in container images, software library container images, and multiple algorithm application container images that correspond to the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications, respectively, so as to construct an accelerator card software integration architecture that meets the requirements.

2. The method according to claim 1, characterized in that According to the target image parameter group, the target computing device deployed with the brain-like accelerator card is called to run multiple target algorithm application container images to process the target data, including: According to the target data processing request, determine the accelerator card driver container image and the runtime program container image that match the brain-like accelerator card; Configure the runtime program container image to obtain the target runtime program container image; According to the target image parameter group, a matching component and plug-in container image and a software library container image are determined as the target component and plug-in container image and the target software library container image; According to the target image parameter group, the target computing device deployed with the brain-like accelerator card is called, and the matching accelerator card driver container image, target runtime program container image, target component and plug-in container image, target software library container image, and multiple target algorithm application container images are started in sequence to process the target data.

3. The method according to claim 1, characterized in that After installing an accelerator card driver, a runtime program, related components and plug-ins, a software library, and a plurality of algorithm applications that match the brain-like accelerator card in an operating system environment of a target computing device, the method further includes: According to preset test rules, in the operating system environment of the target computing device, a first test is performed on the accelerator card driver, runtime program, related components and plug-ins, software libraries, and multiple algorithm applications that match the brain-like accelerator card.

4. The method according to claim 1, characterized in that: According to the preset construction rules, an accelerator card driver container image, a runtime program container image, a component and plug-in container image, a software library container image, and a plurality of algorithm application container images corresponding to the accelerator card driver, the runtime program, the related components and plug-ins, the software library, and the plurality of algorithm application programs are produced, including: Obtain and create multiple running containers matching the brain-like accelerator card based on a basic image corresponding to the operating system of the target computing device; Through directory mapping, the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications are respectively installed in multiple running containers to obtain corresponding multiple program containers; According to preset test rules, a second test is performed on the plurality of program containers in the container environment; When it is determined that the second test passes, multiple program containers are exported to obtain corresponding multiple program container images; and the image version number and image name of the program container image are obtained as the corresponding image identifier.

5. The method according to claim 1, characterized in that After installing an accelerator card driver, a runtime program, related components and plug-ins, a software library, and a plurality of algorithm applications that match the brain-like accelerator card in an operating system environment of a target computing device, the method further includes: According to the preset building rules, obtain and create a running container that matches the brain-like accelerator card based on the basic image corresponding to the operating system of the target computing device; Through directory mapping, an accelerator card driver, a runtime program, related components and plug-ins, a software library, and multiple algorithm applications related to target data processing are sequentially installed in the running container to obtain a corresponding target program container; According to the preset test rules, a second test is performed on the target program container in the container environment; When it is determined that the second test passes, the target program container is exported to obtain a corresponding target program container image; and the image version number and image name of the target program container image are obtained as the corresponding image identifier.

6. The method according to claim 5, characterized in that After receiving the target data processing request, the method further includes: Determine the target data processing type according to the target data processing request; Determine a target image identifier of a matching target program container image according to the target data processing type; According to the target image identifier, the target computing device deployed with the brain-like accelerator card is called to run the target program container image to perform target data processing.

7. A data processing device based on a brain-like acceleration card, characterized in that: include: A receiving module, used for receiving a target data processing request; A first determination module, configured to determine a plurality of associated algorithms related to target data processing according to a target data processing request; A second determination module is used to determine the image identifiers of the corresponding multiple target algorithm application container images according to the multiple association algorithms; wherein the target algorithm application container image is a program container image constructed according to a preset construction rule and matched with the brain-like accelerator card; A construction module, used to construct a corresponding target image parameter group according to the image identifiers of multiple target algorithm application container images; A running module is used to run multiple target algorithm application container images by calling a target computing device deployed with a brain-like accelerator card according to a target image parameter group to perform target data processing; The construction module is specifically used to respond to the target data processing request and determine the execution relationship when different associated algorithms are executed during the target data processing; wherein the execution relationship includes a parallel relationship and a series relationship; according to the execution relationship, the image identifiers of multiple target algorithm application container images are sequentially spliced ​​and combined to obtain a corresponding target image parameter group; The device is also used to install the brain-like acceleration card on the target computing device according to preset installation rules; start the target computing device, and install the acceleration card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like acceleration card under the operating system environment of the target computing device; according to preset construction rules, produce acceleration card driver container images, runtime program container images, component and plug-in container images, software library container images, and multiple algorithm application container images that correspond to the acceleration card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications, respectively, so as to construct an acceleration card software integration architecture that meets the requirements.

8. A computing device, characterized in that A brain-like acceleration card is deployed at least according to a preset installation rule, and the computing device also includes a processor and a memory for storing processor executable instructions. When the processor executes the instructions, it realizes: receiving a target data processing request; determining multiple associated algorithms related to the target data processing according to the target data processing request; determining the image identifiers of the corresponding multiple target algorithm application container images according to the multiple associated algorithms; wherein the target algorithm application container image is a program container image constructed according to the preset construction rules and matched with the brain-like acceleration card; constructing a corresponding target image parameter group according to the image identifiers of the multiple target algorithm application container images; and running the multiple target algorithm application container images according to the target image parameter group to perform target data processing; And, according to the preset installation rules, the brain-like accelerator card is installed on the target computing device; the target computing device is started, and in the operating system environment of the target computing device, an accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications that match the brain-like accelerator card are installed; according to the preset construction rules, an accelerator card driver container image, a runtime program container image, a component and plug-in container image, a software library container image, and multiple algorithm application container images that correspond to the accelerator card driver, runtime program, related components and plug-ins, software library, and multiple algorithm applications are produced, so as to construct an accelerator card software integration architecture that meets the requirements; Among them, according to the image identifiers of multiple target algorithm application container images, a corresponding target image parameter group is constructed, including: responding to the target data processing request, determining the execution relationship when different associated algorithms are executed during the target data processing process; wherein the execution relationship includes a parallel relationship and a series relationship; according to the execution relationship, the image identifiers of multiple target algorithm application container images are sequentially spliced ​​and combined to obtain the corresponding target image parameter group.

Images