JP7135256B2 - METHOD AND APPARATUS FOR GENERATING ERROR NOTIFICATION CONTENT OF DEEP LEARNING FRAMEWORK - Google Patents

Description

TECHNICAL FIELD The present disclosure relates to the field of computer technology, and more particularly to a method, apparatus, electronic device, and readable storage medium for generating error notification content for a deep learning framework in the field of deep learning technology.

As a basic research tool in the field of artificial intelligence, deep learning frameworks are very useful for developers in related fields. However, due to the complexity of deep learning frameworks themselves, developers need a large number of third-party library application interface APIs to realize corresponding functions when using deep learning frameworks to train deep learning models. will be called.

Deep learning frameworks can have issues with call failures when calling third-party library APIs. However, the conventional technology only displays the error code returned by the third-party library to the developer after the deep learning framework fails to call the API, so the developer knows more detailed error information. Therefore, the development cost of the developer increases and the development efficiency of the developer decreases.

The technical solution adopted by the present disclosure to solve the technical problem is to acquire an error code and error information corresponding to the error code, and to create an error file based on the error code and the error information corresponding to it. generating and packaging the error file into a deep learning framework; executing the deep learning framework; and responding to an error when the deep learning framework calls a third-party library application interface API. receiving the error code returned from the third-party library, extracting error information corresponding to the received error code from the error file, and generating error notification content based on the error information; To provide a method for generating error notification content for deep learning frameworks including,

The technical solution adopted by the present disclosure to solve the technical problem is an acquisition unit for acquiring an error code and error information corresponding to the error code, and an error file based on the error code and the error information corresponding thereto and packaging the error file into a deep learning framework; and executing the deep learning framework, wherein an error occurred when the deep learning framework called a third-party library application interface API. , an error notification unit that receives an error code returned from a third-party library in response to and extracts error information corresponding to the received error code from the error file; and an error notification content based on the error information. and a generating unit for generating an error notification content for a deep learning framework.

at least one processor; and a memory communicatively coupled with said at least one processor, wherein said memory stores commands executable by said at least one processor, said commands being executed by said at least one processor When done, an electronic device is provided that causes the at least one processor to perform the above method.

A non-transitory computer readable storage medium having computer commands stored thereon for causing a computer to perform the method is provided.

One embodiment of the disclosure has the following advantages or beneficial effects. In short, the present disclosure enables automatic generation of error notification content such that the generated error notification content contains richer information. The error code returned from the third-party library when the deep learning framework fails to call the third-party library API in the conventional technology, because it adopts a technical means of extracting the error information corresponding to the error code from the error file. It overcomes the technical problem of only being able to obtain an error message, and achieves the technical effect of automatically generating an error notification that contains more information.

Other advantages of the selectable method will be described in conjunction with specific embodiments below.

The drawings are for better understanding of the present technical solution and are not limiting in the present application. In the drawing:
1 is a schematic diagram according to a first embodiment of the present disclosure; FIG. FIG. 5 is a schematic diagram according to a second embodiment of the present disclosure; 1 is a block diagram of an electronic device for implementing a method of generating error notification content for a deep learning framework, in accordance with an embodiment of the present disclosure; FIG.

Exemplary embodiments of the present disclosure will now be described with reference to the drawings. Various details of the embodiments of the disclosure are included for ease of understanding and should be considered as exemplary only. Accordingly, those skilled in the art should appreciate that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of the disclosure. Similarly, for the sake of clarity, descriptions of well-known functions and constructions are omitted in the following description.

FIG. 1 is a schematic diagram according to the first embodiment of the present disclosure. As shown in FIG. 1, the method for generating error notification content by the deep learning framework in this embodiment can specifically include the following steps.

At S101, an error code and error information corresponding to the error code are obtained.

At S102, generate an error file based on the error code and corresponding error information, and package the error file into a deep learning framework.

In S103, executing the deep learning framework and receiving an error code returned from a third party library in response to an error occurring when the deep learning framework calls a third party library application interface API. , extracting error information corresponding to the received error code from the error file.

In S104, error notification content is generated based on the error information.

The method for the deep learning framework in this embodiment to generate the error notification content is to obtain the deep learning framework including the error file by generating an error file from the error code and the error information corresponding to the error code. If a call to a third-party library API (Application Programming Interface) fails while the framework is running, extract the error information corresponding to the error code returned by the third-party library from the error file and add the error information By generating the error notification content based on, the automatic generation of the error notification content can be realized so that the generated error notification content contains richer information.

In this embodiment, the error code obtained by executing step S101 corresponds to different error codes when an error occurs in calling the API for different reasons. Identifies the error type if the call fails. Since the third-party library pre-configures different error codes for different error types, the present embodiment can implement error code acquisition by accessing the third-party library.

In this embodiment, after executing S101 to acquire an error code, error information corresponding to the error code is acquired. The acquired error information describes in detail the cause of the error, the method of solving the error, and the like. In this embodiment, the crawler code may automatically crawl the content of the web page, document, web address, etc. corresponding to the error code from the Internet as error information corresponding to the error code. Error information corresponding to the error code may be artificially created.

It should be understood that in this embodiment, the number of error codes obtained by executing S101 may be one or more. If multiple error codes are acquired, in this embodiment, it is necessary to acquire error information corresponding to each error code.

In this embodiment, after S101 is executed to acquire an error code and error information corresponding to the error code, S102 is executed to generate an error file from the error code and the corresponding error information, and the generated error file is By packaging in a deep learning framework, the deep learning framework can parse the error information corresponding to the error code.

Specifically, the present embodiment uses the programming language used by the deep learning framework, such as Python, C++, and Java, when executing S102 to generate an error file from the error code and corresponding error information. (registered trademark), etc., and generating an error file corresponding to the specified programming language from the error code and the corresponding error information.

In this embodiment, the existing protobuf protocol can be used to serialize error codes and corresponding error information, and the serialized contents can be used as an error file.

That is, in the present embodiment, the language of the error file generated by executing S102 can be made to correspond to the programming language used in the deep learning framework, and an error due to a language mismatch between the error file and the deep learning framework can be corrected. Avoided code parsing failures and improved the success rate of generating error notification content.

Due to frequent updates of APIs in third-party libraries, error codes corresponding to APIs in generated error files have a certain timeliness. If the error file does not contain the updated error code, the deep learning framework cannot parse the error information corresponding to that error code.

In order to ensure that the error file contains the latest error code of the third-party library as much as possible, in this embodiment, after S102 is executed to generate the error file, the generation time of the error file is recorded. , updating the error code and corresponding error information in the error file in response to the time difference between the current time and the previous generation time reaching a preset time interval.

In addition, in order to avoid the error file being too large and occupying more storage space of the deep learning framework, the present embodiment implements S102 when packaging the error file into the deep learning framework Secondly, it adopts an optional implementation method of compressing the generated error file and packaging the compression result of the error file into a deep learning framework, i.e. the deep learning framework contains the compressed error file. can be

The present embodiment completes steps S101 and S102 before the deep learning framework is executed, so that when executing S103 in the present embodiment to execute the deep learning framework, the deep learning framework is third-party Ability to receive error codes returned from third-party libraries in response to errors occurring when calling the third-party library application interface APIs, and extract error information corresponding to the received error codes from error files to

This embodiment can be executed immediately after receiving the error code returned from the third-party library when executing S103 to extract the error information corresponding to the received error code from the error file.

To ensure the runtime stability of the deep learning framework, the deep learning framework has a mechanism for multiple retries when calling third-party library APIs. In other words, it is only when the call fails after multiple retries that the deep learning framework conclusively determines that the call to the third-party library API has failed, and the failed call causes the third-party Get the error information corresponding to the error code returned from the library.

Therefore, the present embodiment executes S103 to receive the error code returned from the third-party library in response to the error occurring when the deep learning framework calls the third-party library API, and the error When extracting the error information corresponding to the error code received from the file, determine the number of retries corresponding to the third-party library API that the deep learning framework is currently calling, and after the number of retries has passed, the deep learning receiving the error code returned by the third-party library in response to an error in the framework's call to the third-party library API and extracting error information corresponding to the received error code from the error file; A selectable realization method may be adopted.

In other words, the deep learning framework in this embodiment extracts the error information corresponding to the error code from the error file only after the call fails even after multiple retries, so the stability of the deep learning framework is improved. to avoid wasting computing resources and improve the accuracy of error information acquisition.

Also, in the present embodiment, if the error file is compressed when executing S102, the deep learning framework executes S103 to extract the error information corresponding to the error code received from the error file. Determine whether the decompression result of the error file is included, if yes, extract the error information corresponding to the received error code from the decompression result; if negative, after decompressing the error file, the received An optional implementation method may be adopted in which error information corresponding to the error code is extracted from the decompression result.

For example, in this embodiment, if an error file is obtained by serializing an error code and corresponding error information using the protobuf protocol when executing S102, the error file is first generated using the protobuf protocol when executing S103. After deserialization, error information corresponding to the received error code can be extracted from the deserialization result.

In this embodiment, S103 is executed to extract the error information corresponding to the received error code from the error file, then S104 is executed to generate error notification content based on the extracted error information, Further, the contents of the error notification are displayed to the user, for example, the contents of the error notification are printed or directly displayed on the screen.

What should be understood is that in this embodiment, when executing S104, the extracted error information can be used as the error notification content as it is. On the other hand, in order to enrich the information included in the error notification content, in the present embodiment, when executing S104 to generate the error notification content from the error information, preset specific information and error information are A selectable implementation method of splicing and using the splicing result as error notification content may be adopted.

Here, the preset specific information in this embodiment may be call stack information, call count information, and call time information when the deep learning framework calls the third party library API this time.

According to the above-described method provided in the present embodiment, when an error occurs in the deep learning framework calling the third-party library API and the error code returned from the third-party library is received, the deep learning framework By automatically analyzing the error code based on the error file included in the , you can get richer error notification contents including error information, greatly reduce the developer's development cost, and improve the developer's development efficiency. can be improved.

FIG. 2 is a schematic diagram according to a second embodiment of the present disclosure. As shown in FIG. 2, the apparatus for generating error notification content of the deep learning framework in this embodiment includes an obtaining unit 201 for obtaining an error code and error information corresponding to the error code; a processing unit 202 for generating an error file based on error information and packaging said error file into a deep learning framework; and executing said deep learning framework, said deep learning framework using a third party library application interface API an error notification unit 203 for receiving an error code returned from a third party library and extracting error information corresponding to the received error code from the error file in response to an error occurring in the call; a generation unit 204 for generating error notification content based on the error information.

The error code acquired by the acquisition unit 201 corresponds to different error codes when an error occurs while calling an API for different reasons, so if a deep learning framework fails when calling a third-party library API, Identifies the error type. Since the third-party library preconfigures different error codes for different error types, the retrieving unit 201 can implement error code retrieval by accessing the third-party library.

After obtaining the error code, the obtaining unit 201 obtains the error information corresponding to the error code. The acquired error information describes in detail the cause of the error and how to solve it. Note that the acquisition unit 201 may automatically crawl the contents of the web page, document, web address, etc. corresponding to the error code from the Internet as the error information corresponding to the error code, according to the crawler code. The acquisition unit 201 may create error information corresponding to the error code artificially by the developer.

It should be understood that the number of error codes obtained by the obtaining unit 201 may be one or more. When obtaining a plurality of error codes, the obtaining unit 201 needs to obtain error information corresponding to each error code.

After the obtaining unit 201 obtains the error code and the error information corresponding to the error code, the processing unit 202 generates an error file from the error code and the corresponding error information, and packages the generated error file into the deep learning framework. By doing so, the deep learning framework can analyze the error information corresponding to the error code.

Specifically, when the processing unit 202 generates the error file from the error codes and corresponding error information, the processing unit 202 identifies the programming language used in the deep learning framework, and generates the error codes and corresponding error information. An optional implementation may be employed to generate an error file corresponding to the programming language identified based on the .

The processing unit 202 may serialize the error codes and corresponding error information using the existing protobuf protocol, and the serialized contents as an error file.

In other words, the language of the error file generated by the processing unit 202 can correspond to the programming language used in the deep learning framework, and the error code analysis failure due to the language mismatch between the error file and the deep learning framework. Avoid problems and improve the success rate of generating error notification content.

Due to frequent updates of APIs in third-party libraries, error codes corresponding to APIs in generated error files have a certain timeliness. If the error file does not contain the updated error code, the deep learning framework cannot parse the error information corresponding to that error code.

In order to ensure that the error file contains the latest error codes in the third-party library as much as possible, after generating the error file, the processing unit 202 records the generation time of the error file, the current time and the previous The method can further include updating the error code and corresponding error information in the error file in response to the time difference from the creation time reaching a preset time interval.

Furthermore, to avoid the error file being too large and occupying more storage space of the deep learning framework, the processing unit 202, when packaging the error file into the deep learning framework, stores the generated An optional implementation of compressing the error file and packaging the result of compressing the error file into a deep learning framework, i.e., the compressed error file is included in the deep learning framework, may be adopted.

The error notification unit 203 can be executed immediately after receiving the error code returned from the third party library in extracting the error information corresponding to the received error code from the error file.

To ensure the runtime stability of the deep learning framework, the deep learning framework has a mechanism for multiple retries when calling third-party library APIs. In other words, it is only when the call fails after multiple retries that the deep learning framework conclusively determines that the call to the third-party library API has failed, and the failed call causes the third-party Get the error information corresponding to the error code returned from the library.

Therefore, the error notification unit 203 receives the error code returned from the third-party library in response to an error in the deep learning framework calling the third-party library API, and the error code received from the error file. When extracting the error information corresponding to the error code, determine the number of retries corresponding to the third-party library API that the deep learning framework is currently calling, and after the number of retries has passed, the deep learning framework will Optional to receive the error code returned by the third-party library in response to an error in the call to the third-party library API, and extract the error information corresponding to the received error code from the error file. Any implementation method may be adopted.

In other words, the deep learning framework in this embodiment extracts the error information corresponding to the error code from the error file only after the call fails even after multiple retries, so the stability of the deep learning framework is improved. to avoid wasting computing resources and improve the accuracy of error information acquisition.

Further, when the processing unit 202 compresses the error file, the error notification unit 203 extracts the error information corresponding to the received error code from the error file, and the deep learning framework receives the decompression result of the error file. If yes, extract the error information corresponding to the received error code from the decompression result; if no, extract the error information corresponding to the received error code after decompressing the error file An optional implementation may be employed to extract the corresponding error information from the decompression result.

After the error notification unit 203 extracts the error information corresponding to the received error code from the error file, the generating unit 204 generates error notification content according to the extracted error information and displays it to the user.

It should be understood that the generating unit 204 may directly take the extracted error information as the error notification content. On the other hand, in order to make the information included in the error notification content richer, the generation unit 204 splices the preset specific information and the error information when generating the error notification content from the error information, and performs the splicing. A selectable method of using the result as the content of the error notification may be adopted.

Here, the preset specific information in the generation unit 204 may be call stack information, call count information, and call time information for the deep learning framework to call the third-party library API this time.

According to embodiments of the disclosure, the disclosure further provides an electronic device and a computer-readable storage medium.

FIG. 3 is a block diagram of an electronic device of a method for generating error notification content for a deep learning framework according to one embodiment of the present disclosure; Electronic devices are intended to be various types of digital computers, such as laptop computers, desktop computers, workstations, PDAs, servers, blade servers, mainframe computers, and other suitable computers. Electronic devices may refer to various types of mobile devices such as PDAs, cell phones, smart phones, wearable devices, and other similar computing devices. The components, their connections and relationships, and their functions shown herein are exemplary only and are not intended to limit the implementation of the present disclosure as described and/or claimed herein. For example, the electronic device of the present embodiment may implement the method for generating a video segment description described above and may implement the method for training a video description model described above.

As shown in Figure 3, the electronic device comprises one or more processors 301, memory 302, and interfaces including high speed and low speed interfaces for connecting to each component. Each component is interconnected by a different bus and may be implemented on a common motherboard or otherwise as desired. The processor may process commands executed within the electronic device and render graphical information of the graphical user interface stored in memory or on memory to an external input/output device (e.g., a display device coupled to the interface). Contains commands to display . In other embodiments, multiple processors and/or multiple buses may be used, along with multiple memories, if desired. Similarly, multiple electronic devices may be connected, each providing a portion of the required operation (eg, a server bank, a collection of blade servers, or a multi-processor system). In FIG. 3, one processor 301 is taken as an example.

Memory 302 is a non-transitory computer-readable storage medium provided in this disclosure. wherein the memory stores commands executable by the at least one processor such that the at least one processor executes the method for generating error notification content of the deep learning framework provided herein. . A non-transitory computer-readable storage medium of the present disclosure stores computer commands for causing a computer to perform a method of generating error notification content for a deep learning framework provided herein.

The memory 302, as a non-transitory computer-readable storage medium, generates non-transitory software programs, non-transitory computer-executable programs, modules, e.g., error notification content of a deep learning framework in embodiments of the present disclosure. It is used to store program commands/modules corresponding to the method (for example, acquisition unit 201, processing unit 202, error notification unit 203, and generation unit 204 shown in FIG. 2). The processor 301 performs the various functional applications and data processing of the server by executing non-transitory software programs, commands and modules stored in the memory 302, i.e. deep learning frames in the above method embodiments. Implement a method for generating work error notification content.

The memory 302 may include a program storage area and a data storage area, where the program storage area may store an operating system, application programs required for at least one function, and the data storage area may be used for error notification of the deep learning framework. Data or the like created through use of an electronic device that implements a method of generating content may be stored. Memory 302 may also include high speed random access memory and may also include non-transitory memory such as at least one magnetic disk storage device, flash memory device, or other non-transitory solid state storage device. In some embodiments, the memory 302 may optionally include memory remotely located with respect to the processor 301, and these remote memories generate error notification content for the deep learning framework over a network. It may be connected to an electronic device that implements the method. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof.

The electronic device implementing the method for generating error notification content of the deep learning framework may further comprise an input device 303 and an output device 304 . The processor 301, the memory 302, the input device 303 and the output device 304 may be connected by a bus or other means, the connection by bus being taken as an example in FIG.

The input device 303 can receive input numeric or character information and generate key signal inputs related to user settings and functional controls of electronic devices that implement methods for generating error notification content for deep learning frameworks, such as , touchscreens, keypads, mice, trackpads, touchpads, pointing sticks, one or more mouse buttons, trackballs, joysticks, and other input devices. Output devices 304 can include displays, supplemental lighting devices (eg, LEDs), tactile feedback devices (eg, vibration motors), and the like. Such display devices may include, but are not limited to, liquid crystal displays (LCDs), light emitting diode displays (LEDs), and plasma displays. In some embodiments, the display device may be a touch panel.

Various embodiments of the systems and techniques described herein may be implemented in digital electronic circuit systems, integrated circuit systems, specialized integrated circuits (ASICs), computer hardware, firmware, software, and/or combinations thereof. can do. These various embodiments receive data and commands from a storage system, at least one input device, and at least one output device, and send data and commands to the storage system, at least one input device, and at least one output device. execution in one or more computer programs executable and/or interpretable on a programmable system comprising at least one programmable processor, which may be special or general purpose, coupled to transmit data and commands may contain.

These computing programs (also referred to as programs, software, software applications, or code) contain machine instructions for programmable processors and are written in high-level process and/or object oriented programming language and/or assembly/machine language. can be run with As used herein, the terms "machine-readable medium" and "computer-readable medium" are used to provide machine instructions and/or data to a programmable processor that includes a machine-readable medium that receives machine instructions as machine-readable signals. refers to any computer program product, apparatus, and/or apparatus (eg, magnetic disks, optical disks, memory, and programmable logic devices (PLDs)) The term "machine-readable signal" refers to any signal used to provide machine instructions and/or data to a programmable processor.

To provide user interaction, the systems and techniques described herein use a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) to display information to the user; It can be implemented on a computer having a keyboard and pointing device (eg, mouse or trackball) that allows a user to provide input to the computer. Other types of devices can also be used to provide interaction with a user, e.g., the feedback provided to the user can be any form of sensing feedback (e.g., visual feedback). , auditory feedback, or tactile feedback), and input from the user may be received in any form (including acoustic, vocal, or tactile input).

The systems and techniques described herein may be computing systems that include back-end components (eg, data servers), or computing systems that include middleware components (eg, application servers), or front-end configurations. A computing system that includes elements (e.g., a client computer having a graphical user interface or web browser through which a user interacts with embodiments of the systems and techniques described herein). can), can be implemented in a computing system that includes any combination of such back-end components, middleware components, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (eg, a communication network). Examples of communication networks include local area networks (“LAN”), wide area networks (“WAN”), and internetworks.

The computer system can include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on corresponding computers and having a client-server relationship to each other.

According to the technical solution according to the embodiment of the present disclosure, when an error occurs when the deep learning framework calls a third-party library API and receives an error code returned from the third-party library, the deep learning framework By automatically analyzing the error code based on the error file included in the , you can get richer error notification contents including error information, greatly reduce the developer's development cost, and improve the developer's development efficiency. can be improved.

It should be appreciated that steps may be rearranged, added, or deleted using the various forms of flow presented above. For example, each step described in this disclosure may be performed in parallel order or sequential order, or may be performed in a different order, and the desired result of the technical solution disclosed in this disclosure is There is no limit here as long as it can be achieved.

The above specific embodiments do not constitute a limitation on the protection scope of this disclosure. Those skilled in the art should understand that various modifications, combinations, subcombinations and substitutions can be made according to design requirements and other factors. Any modification, equivalent replacement or improvement made within the spirit and principle of the present disclosure shall fall within the protection scope of the present disclosure.

Claims (17)

A method for generating error notification content for a deep learning framework, comprising:
obtaining an error code and error information corresponding to the error code;
generating an error file based on the error code and corresponding error information, and packaging the error file into a deep learning framework;
executing the deep learning framework, receiving an error code returned from a third-party library in response to an error occurring when the deep learning framework calls a third-party library application interface API; extracting error information corresponding to the error code from the error file;
generating error notification content based on the error information;
Method. generating an error file based on the error code and corresponding error information;
determining the programming language used in the deep learning framework;
generating an error file corresponding to the determined programming language based on the error code and corresponding error information;
The method of Claim 1. Packaging the error file into a deep learning framework includes:
compressing the error file;
packaging the compression result of the error file into the deep learning framework;
3. A method according to claim 1 or 2. After generating an error file based on the error code and corresponding error information, recording the generation time of the error file;
updating the error code and corresponding error information in the error file in response to the time difference between the current time and the previous generation time reaching a preset time interval;
The method of Claim 1. Receive an error code returned from a third-party library in response to an error occurring when the deep learning framework calls a third-party library application interface API, and provide error information corresponding to the received error code. Extracting from the error file includes:
determining the number of retries corresponding to a third party library API that the deep learning framework is currently calling;
receiving an error code returned from a third-party library in response to an error occurring when said deep learning framework calls a third-party library API after the number of retries has elapsed, and the received error code extracting from the error file error information corresponding to
The method of Claim 1. Extracting error information corresponding to the received error code from the error file includes:
determining whether the deep learning framework includes a decompression result of the error file;
if affirmative, extracting error information corresponding to the received error code from the decompression result;
If not, after decompressing the error file, extracting error information corresponding to the received error code from the decompression result. Generating error notification content based on the error information includes:
splicing preset specific information and the error information, and using the spliced result as the error notification content;
The method of Claim 1. An apparatus for generating error notification content for a deep learning framework,
an acquisition unit for acquiring an error code and error information corresponding to the error code;
a processing unit for generating an error file based on the error code and corresponding error information and packaging the error file into a deep learning framework;
executing the deep learning framework, receiving an error code returned from a third-party library in response to an error occurring when the deep learning framework calls a third-party library application interface API; an error notification unit for extracting error information corresponding to the error code obtained from the error file;
a generation unit that generates error notification content based on the error information;
Device. Specifically, when the obtaining unit generates an error file based on the error code and corresponding error information,
Determine the programming language used in the deep learning framework,
generating an error file corresponding to the determined programming language based on the error code and corresponding error information;
9. Apparatus according to claim 8. Specifically, when the processing unit packages the error file into a deep learning framework,
compress the error file;
packaging the compression result of the error file into the deep learning framework;
10. Apparatus according to claim 8 or 9. The generation unit generates an error file based on the error code and corresponding error information, and then records the generation time of the error file;
updating the error code and corresponding error information in the error file in response to the time difference between the current time and the previous generation time reaching a preset time interval;
9. Apparatus according to claim 8. The error notification unit receives an error code returned from a third-party library in response to an error occurring when the deep learning framework calls a third-party library application interface API; Specifically, when extracting the error information corresponding to from the error file,
determining the number of retries corresponding to the third-party library API that the deep learning framework is currently calling;
receiving an error code returned from a third-party library in response to an error occurring when said deep learning framework calls a third-party library API after the number of retries has elapsed, and the received error code extracting error information corresponding to from the error file;
9. Apparatus according to claim 8. Specifically, when the error notification unit extracts the error information corresponding to the received error code from the error file,
determining whether the deep learning framework includes the decompression result of the error file;
if affirmative, extract error information corresponding to the received error code from the decompression result;
if not, after decompressing the error file, extracting error information corresponding to the received error code from the decompression result;
11. Apparatus according to claim 10. Specifically, when the generation unit generates error notification content based on the error information,
Splicing preset specific information and the error information, and using the spliced result as the error notification content;
9. Apparatus according to claim 8. at least one processor;
a memory communicatively coupled with the at least one processor;
A command executable by the at least one processor is stored in the memory, and when the command is executed by the at least one processor, the command according to any one of claims 1 to 7 is executed by the at least one processor. An electronic device for carrying out the described method. A non-transitory computer-readable storage medium storing computer commands for causing a computer to perform the method of any one of claims 1-5. A program for causing a computer to execute the method according to any one of claims 1 to 5.

Images