Medical imaging device failure resolution

Abstract

A method for identifying a log file to address a medical imaging device failure is provided. The method comprises the following steps: obtaining log file browsing data for solving a fault of the medical imaging equipment, wherein the log file browsing data describes one or more log files of the medical imaging equipment which are viewed by a user; obtaining problem data describing the failure of the medical imaging device; inputting the problem data and the log file browsing data into a machine learning algorithm trained to predict a resolution probability for each of a plurality of log files of the medical imaging device and based on the browsing data, the solving probability indicates the possibility that the log file will assist in solving the fault of the medical imaging equipment; obtaining a prediction result from a machine learning algorithm in response to the input, wherein the prediction result comprises a resolution probability of one or more log files in the plurality of log files of the medical imaging device; and identifying a log file for solving the failure of the medical imaging device based on the obtained prediction result.

Description

Technical Field

[0001] The present invention relates to the field of equipment maintenance, and in particular to the field of troubleshooting medical imaging equipment. Background Art

[0002] From time to time, medical imaging equipment may malfunction, i.e. exhibit errors and fail to function properly.

[0003] Typically, in response to a fault occurring in a medical imaging device, one or more service engineers are assigned to diagnose and resolve the fault. These service engineers may perform the diagnosis remotely or on-site.

[0004] During fault diagnosis, the service engineer(s) may need to examine the log files of the medical imaging device to identify relevant diagnostic information, such as error messages. The log files of the medical imaging device may contain critical information that helps the service engineer identify the root cause of the fault.

[0005] Log files can be retrieved on demand, so they contain the latest information about the device. However, due to the size of the data and the number of concurrent requests, downloading and searching log files can take a significant amount of time. The resulting time delays can affect troubleshooting and cause additional system downtime.

[0006] It is therefore desirable to reduce the time required to identify the cause of or solution to a malfunction in a medical imaging device. Summary of the invention

[0007] The invention is defined by the claims.

[0008] According to an example of one aspect of the present invention, there is provided a method for identifying a log file for troubleshooting a fault in a medical imaging device, the method comprising:

[0009] obtaining log file browsing data for troubleshooting a medical imaging device, the log file browsing data describing one or more log files of the medical imaging device that have been viewed by a user;

[0010] obtaining problem data describing the failure of the medical imaging device;

[0011] inputting the problem data and the log file browsing data into a machine learning algorithm, the machine learning algorithm being trained to predict, for each of a plurality of log files of the medical imaging device and based on the browsing data, a resolution probability indicating a likelihood that the log file will assist in resolving the fault of the medical imaging device;

[0012] obtaining a prediction result from a machine learning algorithm in response to the input, the prediction result comprising a probability of resolution of one or more of the plurality of log files of the medical imaging device; and

[0013] Based on the obtained prediction result, a log file for resolving the fault of the medical imaging device is identified.

[0014] Therefore, the proposed concepts are intended to provide schemes, solutions, concepts, designs, methods and systems related to helping troubleshooting by considering the possibility that log files will assist in troubleshooting.

[0015] Specifically, an embodiment of the present invention proposes to generate predicted resolution probabilities for different log files based on log file browsing data to resolve the failure of a medical imaging device, wherein the log file browsing data describes one or more log files of a medical imaging device that have been viewed by a user, or in other words, the user's browsing history of log files. For example, the most relevant or useful log file(s) that the user is going to view next can be suggested or provided to the engineer in a priority manner.

[0016] The proposed concept recognizes that different log files may have different relevance to a particular fault, and such relevance can be identified to aid in the exploration and / or selection of log files for fault diagnosis. It is also proposed that the relevance of log files can be learned (e.g., from historical log browsing data) to make predictions using machine learning.

[0017] Therefore, the embodiment can simplify the work of the service engineer who wants to explore the log file to diagnose the fault by assisting in exploring different log files in a guided and predictive manner. Such embodiments can provide the advantages of reducing search / exploration time and improving diagnostic accuracy. For example, the embodiment can enable the service engineer to select the most suitable next log file when searching for log files, so that irrelevant log files can be ignored (i.e., prevented from being provided to engineers). This can also avoid unnecessary data retrieval / download. For example, when browsing log files, the service engineer can be provided with suggestions for one or more log files to be recorded next, and the service engineer is therefore guided to browse the most suitable for fault resolution.

[0018] In other words, the embodiments propose the use of machine learning to generate predictions of the likelihood that log files will assist in resolving medical imaging device failures. This prediction may be based on a user's browsing history of log files, thereby taking into account the log file search / browsing routes previously taken by the user, and helping to suggest which (one or more) log files to view next (i.e., guiding the user's log file search / exploration to the next (one or more) steps). Therefore, the predictions provided by the embodiments can help prioritize log files for fault analysis and / or diagnosis. Therefore, the embodiments can be used with respect to fault diagnosis, thereby supporting service engineers in diagnosing and resolving faults. Therefore, the proposed concept can provide improved (e.g., faster) fault resolution in medical imaging devices.

[0019] A machine learning algorithm can be trained using a training algorithm configured to receive an array of training inputs and corresponding known outputs, wherein the training inputs include: problem data; and log file browsing data, and wherein the corresponding known outputs include a probability of resolution for each of a plurality of log files for a medical imaging device, the resolution probability indicating the likelihood that the log file will assist in resolving a fault of the medical imaging device based on the browsing data. In this way, when provided with log file browsing data and a description of a medical imaging device fault, a machine learning algorithm can be trained to output a prediction of the probability of resolution for the log file. Thus, previous log file browsing / search routes leading to fault resolution can be learned and utilized so as to provide suggestions for browsing / searching log files when encountering the same (or similar) problem / fault in the future. For example, the corresponding known outputs may also include a description of a solution associated with the problem data. In this way, the previously obtained solution browsing data can be used together for reference / training for similar situations in the future.

[0020] In some embodiments, obtaining log file browsing data may include: monitoring access to multiple log files of a medical imaging device for file access; and generating log file browsing data based on the results of the monitoring. In this way, the user's log file browsing actions and steps can be automatically monitored and recorded, thereby providing data for machine learning algorithms. Therefore, the proposed embodiments can avoid / mitigate the need for service engineers to actively record and / or provide information about (one or more) previous log file interactions.

[0021] The process of obtaining log file browsing data may include analyzing the usage history of the log file viewer application. That is, embodiments may utilize the functionality of the log file viewer application to collect information about a user's prior access to log files. Thus, existing / traditional log file viewer applications may be utilized to facilitate implementation of the proposed embodiments.

[0022] In some embodiments, obtaining problem input data may include: receiving problem data provided by a respondent via an input interface in response to a data request. The data request may include a fault analysis questionnaire, or old maintenance records from reviews of earlier similar faults. In this way, a respondent's (e.g., an end user or a service engineer) response to the questionnaire may be provided as problem input data. Therefore, such a response can be used to identify one or more characteristics of the fault. Therefore, an embodiment can meet the natural language description of medical imaging equipment faults, thereby facilitating simple and intuitive data provision.

[0023] In one embodiment, the step of obtaining problem data describing the failure of the medical imaging device may include performing a natural language processing analysis on the description of the failure of the medical imaging device.

[0024] Some embodiments may also include the step of determining a data visualization method based on the prediction results obtained. For example, this may involve the parameters associated with the identified log files for troubleshooting, thereby ensuring that the type of data involved in the log files can be visualized / displayed in the best or appropriate manner. For example, if the next step is to view the temperature of the parameter, it would be a numerical value in degrees Celsius or Fahrenheit over a period of time. A time series graph can be created and displayed with a regression line or other statistical measure.

[0025] Some embodiments may further include the step of transmitting the identified log files over a communications network. Advantageously, since the transmitted log files have been identified in the manner described herein, the amount of data transmitted from the medical imaging device to resolve a malfunction of the medical imaging device is reduced. This overcomes bandwidth limitations of transmitting large log files over a bandwidth-constrained communications network.

[0026] Some embodiments may further include the steps of analyzing the identified log files to provide an indication of a fault of the medical imaging device, and optionally adjusting one or more operating parameters of the medical imaging device to resolve the fault of the medical imaging device. The identified log files may be analyzed using known analysis techniques. The fault may then be corrected manually or automatically. For example, in some embodiments, the operating parameters of the medical imaging device may be automatically adjusted to correct the fault.

[0027] In some embodiments, the machine learning algorithm may include a graph neural network.

[0028] According to another aspect of the present invention, a method for resolving a medical imaging device failure is provided, the method comprising:

[0029] According to the method of the proposed embodiment, a log file for troubleshooting a medical imaging device is identified;

[0030] generating updated log file browsing data based on the identified log files;

[0031] inputting the question data and the updated log file browsing data into the machine learning algorithm;

[0032] obtaining an updated prediction result from the machine learning algorithm in response to the input, the updated prediction result comprising a probability of resolution for one or more of the log files of the medical imaging device; and

[0033] Based on the obtained prediction result, a second log file for resolving the fault of the medical imaging device is identified.

[0034] Thus, a concept may be proposed for guiding a user along a log file browsing route towards a solution to a medical imaging device failure, and which may then be used to prioritize searching and / or providing log files to an engineer.

[0035] According to another aspect, a computer program product is provided, wherein the computer program product comprises a computer-readable storage medium having a computer-readable program code embodied thereon, wherein the computer-readable program code is configured to execute all the steps in the proposed embodiments.

[0036] Therefore, a computer system may also be provided, comprising: a computer program product according to the proposed embodiments; and one or more processors adapted to perform the method according to the proposed concept by running the computer readable program code of the computer program product.

[0037] According to another aspect of the present invention, there is provided a system for identifying log files for troubleshooting a medical imaging device, the system comprising:

[0038] a data interface configured to obtain: log file browsing data for solving a malfunction of a medical imaging device, the log file browsing data describing one or more log files of the medical imaging device that have been viewed by a user; and problem data describing the malfunction of the medical imaging device;

[0039] a machine learning algorithm configured to: receive problem data and log file browsing data, the machine learning algorithm being trained to output a prediction result, the prediction result comprising a resolution probability for each of a plurality of log files of the medical imaging device, the resolution probability indicating a likelihood of assisting in resolving a fault of the medical imaging device based on the browsing data log file; and

[0040] A processor is configured to: identify a log file for resolving the fault of the medical imaging device based on the obtained prediction result.

[0041] The system can be located remotely from the user's device for analyzing and / or diagnosing medical imaging device failures. In this way, a user (e.g., a service engineer) can have a properly arranged system that can receive information about the relevance and / or usefulness of log files at a location remote from the system. Therefore, an embodiment can enable a user to dynamically adjust or adapt log file browsing and / or retrieval using a local system (e.g., which can include a portable display device, such as a laptop, tablet computer, mobile phone, PDA, etc.). As an example, an embodiment can provide an application for a mobile computing device, and the application can be executed and / or controlled by a user of the mobile computing device.

[0042] The system may also include: a server device including a system for identifying a log file for resolving a medical imaging device failure; and a client device including a user interface. Thus, dedicated data processing means may be employed for the purpose of identifying (150) a log file for resolving a medical imaging device failure, thereby reducing processing requirements or capabilities of other components or devices of the system.

[0043] The system may also include a client device, wherein the client device includes a data interface, a machine learning algorithm, a processor and a display unit. In other words, a user (e.g., a service engineer) may have a suitably arranged client device (e.g., a laptop, a tablet, a mobile phone, a PDA, etc.), which processes received data to identify log files for troubleshooting and generates display control signals. By way of example only, an embodiment may therefore provide a log file analysis system that enables prioritization of log files, wherein, for example, real-time communication between a user (e.g., a service engineer) and a medical imaging device is provided, and its functionality may be extended or modified according to the proposed concept.

[0044] It should be appreciated that processing capabilities may therefore be distributed throughout the system in different manners depending on predetermined constraints and / or availability of processing resources.

[0045] One or more concepts are provided for optimizing the search or review of log files for medical imaging device troubleshooting or resolution. For example, the proposed embodiments can solve the problem of excessive log file search and / or waiting time for engineers to receive log files. The time spent reviewing or downloading irrelevant (or less relevant) log files can be reduced or minimized.

[0046] These and other aspects of the invention will be apparent from and elucidated with reference to the embodiments described hereinafter.

[0047] These and other aspects of the invention will be apparent from and elucidated with reference to the embodiments described hereinafter. BRIEF DESCRIPTION OF THE DRAWINGS

[0048] For a better understanding of the invention, and to show more clearly how it may be put into practice, reference will now be made, by way of example only, to the accompanying drawings, in which:

[0049] Figure 1 is a flow chart of a method for identifying a log file for troubleshooting a medical imaging device according to an embodiment;

[0050] Figure 2 is a diagram illustrating a method for solving a malfunction of a medical imaging device according to an embodiment of the present invention. Figure 1 A flowchart of the method;

[0051] Figure 3A The diagram shows the case where the shortest path first algorithm is used for the first and second browsing graphs;

[0052] Figure 3B It illustrates how to derive the optimized paths in the browsing graph to identify the shortest browsing trajectory;

[0053] Figure 4 An exemplary embodiment for predicting browsing paths and next best steps is illustrated;

[0054] Figure 5 Depicted Figure 4 Example structures of GNNs that can be used by each model in;

[0055] Figure 6 illustrates a simplified block diagram of a system for identifying log files to troubleshoot medical imaging equipment failures according to an embodiment; and

[0056] Figure 7 is a simplified block diagram of a computer in which one or more portions of an embodiment may be employed. DETAILED DESCRIPTION

[0057] The present invention will be described with reference to the accompanying drawings.

[0058] It should be understood that the detailed description and specific examples, although indicating exemplary embodiments of the device, system and method, are intended only for illustrative purposes and are not intended to limit the scope of the invention. These and other features, aspects and advantages of the device, system and method of the present invention will be better understood from the following description, the appended claims and the accompanying drawings. Although specific measures are recorded in mutually different dependent claims, this does not indicate that a combination of these measures cannot be used advantageously.

[0059] Those skilled in the art can understand and implement variations to the disclosed embodiments when practicing the claimed invention by studying the drawings, the disclosure and the claims. In the claims, the word "comprising" does not exclude other elements or steps, and the word "one" or "an" does not exclude a plurality.

[0060] It should be understood that the drawings are schematic and not drawn to scale. It should also be understood that the same reference numerals are used throughout the drawings to indicate the same or similar parts.

[0061] The present invention proposes a concept of assisting fault diagnosis of medical imaging equipment. Specifically, embodiments may provide a method and / or system that considers a user's browsing history of log files and then identifies (e.g., recommends) log files for resolving a current fault. In this way, when an engineer searches / browses log files to diagnose / resolve a fault, one or more log files to view next may be recommended to the engineer.

[0062] The proposed concept may be based on the recognition that different service engineers may take different approaches to diagnosing or resolving a fault. The time required to find a solution may depend on the browsing / searching route taken, some of which may not be optimal. Using machine learning (trained using previous log file search / browsing routes for solutions), the likelihood that a log file and / or the content provided therein may be helpful in resolving a fault may be predicted. Therefore, based on the log files that the user has already reviewed, the "best next log file" may be identified and suggested to the user. In this way, irrelevant log files may be identified and reduced in priority, thereby reducing unnecessary data review and / or retrieval. For example, when searching for log files to resolve a specific fault, an embodiment may conveniently identify and prioritize the next most useful log file for review, thereby enabling the engineer to be guided through the log file browsing route that may be most suitable for resolving the fault. The review process is often conducted remotely over a communication network. In addition, log files often contain very large amounts of data. Therefore, retrieving log files for review at a remote location may cause bandwidth issues for the communication network. Sometimes, the transmission of log files for analysis is delayed until a quieter period with sufficient bandwidth is available, or the risk of interrupting other important communications is reduced, which delays the resolution of the fault. By identifying and prioritizing the most useful log files to review next, these bandwidth issues can be alleviated by reducing the number of irrelevant log files retrieved and transmitted over the communications network.

[0063] Thus, embodiments may be used for medical imaging fault analysis and / or diagnosis.

[0064] Concepts for troubleshooting medical imaging equipment are also presented. This can be used to guide the provision of log files to engineers.

[0065] Thus, the proposed embodiments can facilitate improved (e.g., faster and / or easier) fault analysis and / or diagnosis by improving the identification of relevant information to engineers. Thus, embodiments of the present invention are intended to enable improved searching of log files for medical imaging device fault diagnosis. Embodiments can provide an efficient and predictable log file exploration mechanism that enables prediction of the "next step" (i.e., the next log file suggestion) at each step during log browsing. Embodiments can also facilitate prediction of optimal visualization methods, line graphs / bar graphs, distribution graphs, tables, etc. Thus, the proposed embodiments can reduce the time to diagnose faults / problems.

[0066] By way of example only, the illustrative embodiments may be used in many different types of clinical, medical, or subject-related environments, such as hospitals, physician offices, wards, nursing homes, personal homes, etc. For example, the illustrative embodiments may be used as a clinical decision support system in a digital pathology platform.

[0067] Figure 1 An embodiment of a computer-implemented method 100 for identifying log files to troubleshoot a medical imaging device malfunction is illustrated. The log files to be identified are suggested to the user to review next based on: (i) the current malfunction; and (ii) previous log files that have been reviewed (i.e., the user's previous browsing activity).

[0068] The method begins at step 110, obtaining log file browsing data, the log file browsing data describing one or more log files of the medical imaging device that the user has viewed to solve the fault of the medical imaging device. Here, the step 110 of obtaining initial problem input data includes: monitoring access to multiple log files of the medical imaging device for file access; and generating log file browsing data based on the monitoring results.

[0069] However, in other embodiments, the step 110 of obtaining initial question input data may include analyzing the usage history of the log file viewer application. For example, such an embodiment may utilize the functionality of the log file viewer application (e.g., activity log / recording) to obtain information about the user's previous access to the log file.

[0070] The method then proceeds to step 120 to obtain problem data describing the fault of the medical imaging device. Specifically, step 120 of obtaining problem input data includes: receiving problem data provided by a respondent via an input interface in response to a data request. Specifically, the data request includes a fault analysis questionnaire provided to an engineer (e.g., via a user interface). Therefore, the engineer's answers to the questionnaire questions are obtained as initial problem input data and used to identify one or more characteristics of the fault. Step 120 may also include performing natural language processing (NLP) analysis on the problem data to identify one or more characteristics of the medical imaging device fault. The NLP analysis processes (one or more) natural language descriptions of the fault, thereby being able to identify characteristics / aspects of the fault based on information provided in a simple and intuitive manner.

[0071] At step 130, the problem data and the log file browsing data are provided to a neural network (NN) based machine learning algorithm. The machine learning algorithm is trained to predict a resolution probability for each of a plurality of log files of the medical imaging device and based on the browsing data, the resolution probability indicating the likelihood that the log file will assist in resolving a fault of the medical imaging device.

[0072] The structure of artificial NN (or neural network (NN) for short) is inspired by the human brain. Neural networks consist of layers, each containing multiple neurons. Each neuron includes a mathematical operation. Specifically, each neuron can include a different weighted combination of a single type of transformation (e.g., the same type of transformation, sigmoid, etc., but with different weights). In the process of processing input data, each neuron performs a mathematical operation on the input data and produces a numerical output. The output of each layer in the neural network is sequentially fed into the next layer. The last layer provides the output.

[0073] There are many types of neural networks, such as convolutional neural networks (CNN) and recurrent neural networks (RNN). However, Figure 1 The exemplary embodiment of the invention employs a graph neural network (GNN). For a given graph (relative to a log file browsing trajectory), the GNN model can predict the link to the next best step of one of the candidate nodes. The GNN models the relationships, contexts, and connections between nodes of the browsing trajectory graph. The model is trained on previous browsing trajectory graphs, and it learns different features of each node, the states of neighboring nodes, and features of neighboring nodes to predict the next best step, i.e., link to the best fitting node.

[0074] Methods for training machine learning algorithms are well known. Typically, such methods include obtaining a training data set, the training data set comprising training input data entries and corresponding training output data entries. An initialized machine learning algorithm is applied to each input data entry to generate a predicted output data entry. The error between the predicted output data entry and the corresponding training output data entry is used to modify the machine learning algorithm. The process can be repeated until the error converges and the predicted output data entry is sufficiently similar to the training output data entry (e.g., ±1%). This is generally referred to as a supervised learning technique.

[0075] For example, the weight of the mathematical operation of each neuron can be modified until the error converges. Known methods for modifying neural networks include gradient descent, back propagation algorithms, etc.

[0076] The training input data entries of the machine learning algorithm used in method 100 correspond to example problem data and log file browsing data. The training output data entries correspond to a resolution probability for each of a plurality of log files of a medical imaging device, the resolution probability indicating the likelihood that the log file will assist in resolving a failure of the medical imaging device based on the browsing data. That is, the machine learning algorithm is trained using a training algorithm configured to receive an array of training inputs and corresponding known outputs, wherein the training inputs include problem data and associated log file browsing data, and the corresponding known outputs include a resolution probability for each of a plurality of log files of a medical imaging device, the resolution probability indicating the likelihood that the log file will assist in resolving a failure of the medical imaging device. In this way, the machine learning algorithm is trained to output a prediction of the resolution probability for the log file when a failure description of the medical imaging device and one or more log files of the medical imaging device that a user has viewed to resolve the failure of the medical imaging device (e.g., previously viewed log files) are provided.

[0077] In step 130, a prediction result is obtained from the machine learning algorithm in response to the input. The prediction result includes a resolution probability for one or more log files in a plurality of log files of the medical imaging device.

[0078] Finally, at step 140, a log file for resolving a medical imaging device failure is identified based on the obtained prediction results. Figure 1 In an exemplary embodiment of the present invention, the step of identifying a log file for resolving the fault includes determining a log file having a highest predicted probability of resolution.

[0079] Figure 2 The diagram shows a Figure 1 Use of the method in a computer-implemented method 200 for troubleshooting a malfunction of a medical imaging device.

[0080] Method 200 first implements the above-mentioned Figure 1 Method 100, from which a (first) log file for troubleshooting is identified. That is, according to Figure 1 The (first) prediction result of an embodiment determines a recommendation for the (first) next log file to be reviewed.

[0081] Next, the method proceeds to step 210, where updated log file browsing data is generated based on the identified (first) log file. Thus, the updated log file browsing data is modified to take into account that the identified (first) log file is the last (i.e., most recent) log file reviewed by the user.

[0082] In step 130, the problem data and updated log file browsing data are provided to Figure 1 The embodiment of the invention is a neural network (NN) based machine learning algorithm. As described above, the machine learning algorithm is trained to output a resolution probability prediction for a log file when provided with a fault description of a medical imaging device and an update browsing history of the log file (e.g., a previously reviewed log file).

[0083] At step 140, a (second) prediction result is obtained from the machine learning algorithm. The second prediction result comprises a (second / new / updated) resolution probability for one or more log files of the plurality of log files of the medical imaging device.

[0084] Finally, a (second) log file for resolving the medical imaging device failure is identified based on the obtained prediction result at step 150. That is, a suggestion for the (further) next log file to be reviewed is determined based on the (second) prediction result considering the updated log file browsing data.

[0085] It will be appreciated that the method can be repeated, wherein the log file browsing data is updated to take into account newly identified log files. In this way, a browsing route / path can be suggested to the user and predicted to lead the user to a solution to the fault (taking into account previous solution routes learned by the machine learning algorithm).

[0086] By further explaining the proposed concepts related to the above-mentioned embodiments, the main elements of the exemplary embodiments can be summarized as follows:

[0087] (A) Log file browsing tracking and recording mechanism

[0088] The log files / tables browsed by the service engineer may be monitored and recorded. In addition, the browsing steps of the log files and the browsing patterns of the log contents may be detected and recorded. This may also include marking log files that the service engineer may use to confirm the problem. When logging the browsing history in the log file, the access parameters and the observed patterns may be observed and recorded. The confirmed problem (i.e., failure) may be associated with the actions taken (or parts replaced).

[0089] (B) Identify the next log file (using supervised learning)

[0090] The most likely failure mode can be identified (e.g., using existing / known techniques). The service logs about the issue can then be reviewed to process service comments, estimate related logs, error patterns, parameters, etc. Machine learning algorithms can then be used to predict the next (or multiple) appropriate log files to use.

[0091] (C) Predict the next step

[0092] At each step, a prediction can be made about the next log file to be viewed. In doing so, an estimate of the best visualization method can be generated based on what is to be viewed [e.g. descriptive content, tables, frequency plots, regression lines, etc.]. This may involve trend analysis.

[0093] Any deviation from the prediction step (i.e. the suggested next log file(s)) can be used as a feedback loop for reinforcement learning to improve subsequent predictions.

[0094] Each of the above elements will now be described in more detail, merely to provide example information and explanation of the concepts presented.

[0095] (A) Log file browsing tracking and recording mechanism

[0096] This may involve collecting log file browsing history (i.e., log file browsing data), including log files, tables, and other files viewed by the service engineer. The collection of these operations can be regarded as the browsing trajectory of a specific service engineer.

[0097] Typically, service engineers use log viewer software / applications to view log files, browse log file contents, view different tables / flowcharts, etc. Therefore, the browsing history or browsing trail can be derived / detected from the usage history of the log viewer software, and different components of the browsing trail (e.g., portions of log files viewed, tables viewed, tables queried, error codes viewed, etc.) can be extracted and used to generate log file browsing data. The browsing path may vary from one service engineer to another, depending on how he / she handles the problem / fault at hand.

[0098] When a service engineer starts solving a problem (or performs a solution), the log files used to obtain the solution may be tagged with the problem statement (i.e., associated with the problem / failure). The problem / failure description (e.g., problem statement) may be tagged with one or more browsing tracks, depending on the number of service engineers who have solved the problem / failure in the past.

[0099] Each browsing track may vary in the time to solve and the number of routes / browsing steps in the track. Once a solution to a problem is found, the solution is also tagged with the problem (i.e. associated with the problem) along with the browsing track. This information can then be used to train a machine learning algorithm.

[0100] (B) Identify the next log file (using supervised learning)

[0101] In order to further process the browsing traces / paths (for identifying the cause of the failure and predicting the next appropriate step), the log file browsing traces are constructed into a machine-readable format. A typical approach is to use NLP techniques to summarize the log file browsing traces. Various tools for text summarization are known and widely available and can be used for this purpose.

[0102] For example, the following NLP steps can be used for summarization.

[0103] (i) Convert paragraphs into sentences;

[0104] (ii) Text preprocessing: remove all special characters, stop words and numbers;

[0105] (iii) tokenize the sentences;

[0106] (iv) Find the weighted frequency of occurrence of the term;

[0107] (v) replace words in the original sentence with weighted frequencies;

[0108] (vi) Sort the sentences in descending order of their sum: the sentence with the highest frequency summarizes the text.

[0109] Next, directed graphs are derived from these browsing trajectory components, and each user's browsing trajectory is represented by a corresponding directed graph.

[0110] Using standard graph algorithms, such as shortest path first, the best navigation path for a particular problem can be identified (e.g. Figure 3A ).

[0111] You can also export the optimized path within the graph to identify the shortest browsing trajectory (such as Figure 3B ).

[0112] A summary of the browsing trail (also called an enhanced log) is associated (e.g., tagged) with the fault description for further reference and processing. The point at which the service engineer starts to resolve the problem / fault becomes part of the solution (e.g., replace a part, fix a bug, etc.). The solution is also associated with the fault description so that it can be used for future reference along with the browsing trail (e.g., in case a similar problem arises in the future).

[0113] The association method (e.g. tagging) is similar to clause detection, which consists in linking the main problem description to the cause of the problem (based on the log file browsing path / trace). The failure / problem of the system may depend mainly on the past / previous events recorded in the log file, similar to the following example, such as clause detection:

[0114] The door opened because the man pushed it.

[0115] Clausal subordination connects two clauses so that one clause (the subordinate clause (SC)) is syntactically dependent on and embedded in the other clause (the principal clause). A defining characteristic of an SC is that it is dependent on another clause, meaning that it cannot stand on its own. It must be embedded in another clause and serve as an integral part of that clause. Therefore, the clause “because the man pushed it” is the principal clause and provides information about the cause of the event described by the principal clause (the door opened).

[0116] (C) Predict the next step

[0117] refer to Figure 4 , the enhanced logs (405) associated with the fault description and the new fault description (i.e., problem data 410) are fed as input to a supervised learning algorithm 420 ("Model 1"). Algorithm 420 predicts the best possible browsing path 425 (and a suitable solution) that can solve the fault in the most efficient way and consumes the least time. Another model 430 ("Model 2"), taking the fault description 410 and the browsing trajectory 440 as input, predicts the next best step 450 in the browsing path (i.e., recommends the next log file) based on the previous steps taken (e.g., the previous log files viewed), thereby ensuring the fastest path to the solution. Each of the above models includes a GNN model.

[0118] Figure 5Depicted are example structures of GNNs that each model may adopt. For a given graph (relative to a browsing trajectory), the GNN model is configured to predict a link to the next best step (i.e., log file), where the next best step is one of the candidate nodes. The GNN models the relationships, contexts, and connections between nodes in the browsing trajectory graph. The model is trained on previous log file browsing path graphs and learns different features of each node, the states of neighboring nodes, and features of neighboring nodes to predict the next best step (i.e., the next log file), the link to the most suitable node.

[0119] Explainable AI (XAI) can be used to highlight important words that led to the predicted results. This helps to gain the trust of the service engineer FSE because the highlighted words can explain why the trial and solution were selected for a specific problem statement.

[0120] If the service engineer agrees with the output, the predicted output may be given a higher weight and further prioritized for predicting solutions to similar problems presented.

[0121] To determine the best visualization, the visualization step can be determined by analyzing the parameters of the next step of the prediction / identification. For example, if the next step is to look at the temperature of the parameter, it would be the value of Celsius or Fahrenheit over time. A time series plot can be created and displayed with a regression line or other statistical measures.

[0122] If the next step involves two parameters or distinguishing abnormal from normal at the same time, a scatter plot of the two variables can be used.

[0123] If the next step involves reviewing the text information in the error list, a table associated with the relevant event times may be shown.

[0124] By way of summary of the proposed embodiments, Figure 6 A simplified block diagram of a system 600 for identifying log files to troubleshoot medical imaging equipment is depicted.

[0125] The system includes a data interface 610 configured to obtain log file browsing data describing one or more log files of a medical imaging device that a user has viewed to resolve a fault of the medical imaging device; and problem data describing the fault of the medical imaging device. As described above, the problem input data may include a text description of the fault provided by the user.

[0126] The machine learning algorithm 620 of the system 600 is configured to receive the problem data and the log file browsing data. The machine learning algorithm 630 is trained to output a prediction result of the probability of resolution of each log file in a plurality of log files of the medical imaging device based on the browsing data. Here, the probability of resolution indicates the possibility that the log file assists in resolving the failure of the medical imaging device.

[0127] The system 600 also includes a processor 630 configured to identify a log file for resolving a medical imaging device failure based on the obtained prediction results. The identified log file is provided as an output 640 of the system 600 and can therefore be used to prioritize providing the log file to a user (e.g., a remote service engineer).

[0128] Figure 7 An example of a computer 1000 in which one or more portions of an embodiment may be employed is illustrated. The various operations discussed above may utilize the capabilities of the computer 1000. For example, one or more portions of a system for identifying log files to troubleshoot medical imaging equipment failures may be incorporated into any of the elements, modules, applications, and / or components discussed herein. In this regard, it should be understood that the system functional blocks may run on a single computer or may be distributed across multiple computers and locations (e.g., connected via the Internet).

[0129] Computer 1000 includes, but is not limited to, PCs, workstations, laptops, PDAs, handheld devices, servers, memory, and the like. Typically, in terms of hardware architecture, computer 1000 may include one or more processors 1010, memory 1020, and one or more I / O devices 1030 communicatively coupled via a local interface (not shown). The local interface may be, for example but not limited to, one or more buses or other wired or wireless connections, as known in the art. The local interface may have additional elements, such as controllers, caches (caches), drivers, repeaters, and receivers, to enable communication. In addition, the local interface may include addressing, control, and / or data connections to enable appropriate communication between the above components.

[0130] Processor 1010 is a hardware device for running software that may be stored in memory 1020. Processor 1010 may be virtually any custom or commercial processor, a central processing unit (CPU), a digital signal processor (DSP), or an auxiliary processor among several processors associated with computer 1000, and processor 1010 may be a semiconductor-based microprocessor (in the form of a microchip) or a microprocessor.

[0131] The memory 1020 may include any one or a combination of volatile memory elements (e.g., random access memory (RAM), such as dynamic random access memory (DRAM), static random access memory (SRAM), etc.) and non-volatile memory elements (e.g., ROM, erasable programmable read-only memory (EPROM), electronically erasable programmable read-only memory (EEPROM), programmable read-only memory (PROM), magnetic tape, compact disk read-only memory (CD-ROM), magnetic disk, floppy disk, card, cassette, etc.). In addition, the memory 1020 may contain electronic, magnetic, optical and / or other types of storage media. Note that the memory 1020 may have a distributed architecture in which various components are remote from each other but can be accessed by the processor 1010.

[0132] The software in the memory 1020 may include one or more separate programs, each of which includes an ordered list of executable instructions for implementing logical functions. According to an exemplary embodiment, the software in the memory 1020 includes a suitable operating system (O / S) 1050, a compiler 1060, a source code 1070, and one or more application programs 1080. As shown, the application program 1080 includes numerous functional components for implementing the features and operations of the exemplary embodiment. According to an exemplary embodiment, the application program 1080 of the computer 1000 may represent various application programs, computing units, logic, functional units, processes, operations, virtual entities, and / or modules, but the application program 1080 is not intended to be limiting.

[0133] The operating system 1050 controls the execution of other computer programs and provides scheduling, input-output control, file and data management, memory management, and communication control and related services. The inventors contemplate that the application program 1080 used to implement the exemplary embodiments may be applicable to all commercially available operating systems.

[0134] Application 1080 may be a source program, an executable program (object code), a script, or any other entity that includes a set of instructions to be executed. In the case of a source program, the program is typically translated by a compiler (e.g., compiler 1060), an assembler, an interpreter, etc., which may or may not be included in memory 1020 in order to operate correctly with operating O / S 1050. In addition, application 1080 may be written in an object-oriented programming language having classes of data and methods, or a procedural programming language having routines, subroutines, and / or functions, such as, but not limited to, C, C++, C#, Pascal, BASIC, API calls, HTML, XHTML, XML, ASP scripts, JavaScript, FORTRAN, COBOL, Perl, Java, ADA, .NET, etc.

[0135] I / O devices 1030 may include input devices such as, but not limited to, a mouse, keyboard, scanner, microphone, camera, etc. In addition, I / O devices 1030 may also include output devices such as, but not limited to, a printer, a display, etc. Finally, I / O devices 1030 may also include devices that transmit both input and output such as, but not limited to, a NIC or modulator / demodulator (for accessing remote devices, other files, devices, systems, or networks), a radio frequency (RF) or other transceiver, a telephone interface, a bridge, a router, etc. I / O devices 1030 also include components for communicating over various networks such as the Internet or an intranet.

[0136] If the computer 1000 is a PC, workstation, intelligent device, etc., the software in the memory 1020 may also include a basic input and output system (BIOS) (omitted for simplicity). The BIOS is a set of basic software routines that initialize and test the hardware at startup, start the O / S 1050, and support data transfer between hardware devices. The BIOS is stored in some kind of read-only memory, such as ROM, PROM, EPROM, EEPROM, etc., so that the BIOS is run when the computer 800 is started.

[0137] When the computer 1000 is in operation, the processor 1010 is configured to execute software stored in the memory 1020, to transfer data to and from the memory 1020, and to generally control the operation of the computer 1000 according to the software. The application programs 1080 and the operating O / S 1050 are read in whole or in part by the processor 1010, possibly buffered within the processor 1010, and then executed.

[0138] When the application 1080 is implemented in software, it should be noted that the application 1080 can be stored on virtually any computer-readable medium for use by or in conjunction with any computer-related system or method. In the context of this document, a computer-readable medium can be an electronic, magnetic, optical, or other physical device or means that can contain or store a computer program for use by or in conjunction with a computer-related system or method.

[0139] Application 1080 may be implemented in various computer-readable media for use with or in conjunction with an instruction execution system, apparatus, or device, such as a computer-based system, a system containing a processor, or other system capable of retrieving instructions from an instruction execution system, apparatus, or device and executing the instructions. In the context of this document, a "computer-readable medium" may be any means by which a program may be stored, communicated, propagated, or transmitted for use with or in conjunction with an instruction execution system, apparatus, or device. A computer-readable medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, device, or propagation medium.

[0140] Figure 1 - The method and Figure 4-Figure 6 The system can be implemented in hardware or software or a mixture of the two (for example, as firmware running on a hardware device). To the extent that the embodiments are partially or entirely implemented in software, the functional steps shown in the process flow chart can be performed by appropriately programmed physical computing devices, such as one or more central processing units (CPUs) or graphics processing units (GPUs). Each process and its individual component steps (as shown in the flow chart) can be performed by the same or different computing devices. According to various embodiments, a computer-readable storage medium stores a computer program including a computer program code, and the computer program code is configured to cause one or more physical computing devices to perform the encoding or decoding method as described above when the program is run on one or more physical computing devices.

[0141] Storage media may include volatile and nonvolatile computer memory, such as RAM, PROM, EPROM and EEPROM, optical disks (such as CD, DVD, BD), magnetic storage media (such as hard disk and magnetic tape). The various storage media may be fixed within the computing device, or may be transportable so that one or more programs stored thereon can be loaded into the processor.

[0142] To the extent that the embodiments are implemented partially or entirely in hardware, Figure 4-Figure 6 The blocks shown in the block diagrams in the drawings may be separate physical components, or logical subdivisions of a single physical component, or may all be implemented in one physical component in an integrated manner. The functions of a block shown in the drawings may be divided between multiple components in the implementation, or the functions of multiple blocks shown in the drawings may be combined in a single component in the implementation. Hardware components suitable for use in embodiments of the present invention include, but are not limited to, conventional microprocessors, application specific integrated circuits (ASICs), and field programmable gate arrays (FPGAs). One or more blocks may be implemented as a combination of dedicated hardware for performing some functions and one or more programmed microprocessors and associated circuits for performing other functions.

[0143] Those skilled in the art can understand and realize the variation of the disclosed embodiment when practicing the invention for which protection is requested by studying the drawings, the disclosure and the claims. In the claims, the word "comprising" does not exclude other elements or steps, and the words "one" or "an" do not exclude multiple. A single processor or other unit can complete the functions of several items recorded in the claims. Although specific measures are recorded in mutually different dependent claims, this does not indicate that the combination of these measures cannot be used advantageously. If a computer program is described above, it can be stored / distributed on a suitable medium such as an optical storage medium or a solid-state medium provided together with other hardware or as part of other hardware, but it can also be distributed in other forms such as via the Internet or other wired or wireless telecommunications systems. If the term "suitable for" is used in the claims or the specification, it should be noted that the term "suitable for" is intended to be equivalent to the term "configured to". Any figure mark in the claims should not be interpreted as a limitation on the scope.

[0144] The flowcharts and block diagrams in the accompanying drawings illustrate the possible implementation architectures, functions and operations of the systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagram may represent a module, segment or portion of an instruction, which contains one or more executable instructions for implementing (one or more) specified logical functions. In some alternative embodiments, the functions recorded in the block diagram may not occur in the order shown in the accompanying drawings. For example, depending on the functions involved, two blocks shown in succession can actually be executed substantially simultaneously, or blocks can sometimes be executed in reverse order. It should also be noted that each block in the block diagram and / or flowchart and the combination of blocks in the block diagram and / or flowchart can be implemented by a dedicated hardware system that performs a specified function or action or performs a combination of dedicated hardware and computer instructions.

Claims

1. A method for identifying a log file for troubleshooting a medical imaging device, the method comprising: obtaining (110) log file browsing data for resolving the fault of the medical imaging device, the log file browsing data describing one or more log files of the medical imaging device that have been viewed by a user; obtaining (120) problem data describing the fault of the medical imaging device; inputting (130) the problem data and the log file browsing data into a machine learning algorithm, the machine learning algorithm being trained to predict, for each of a plurality of log files of the medical imaging device and based on the browsing data, a resolution probability indicating a likelihood that the log file will assist in resolving a malfunction of the medical imaging device; obtaining (140) a prediction result from the machine learning algorithm in response to the input, the prediction result comprising a probability of resolution for one or more of the plurality of log files of the medical imaging device; and Based on the obtained prediction results, a log file for resolving the fault of the medical imaging device is identified (150).

2. The method according to claim 1, wherein: The machine learning algorithm is trained using a training algorithm configured to receive an array of training inputs and corresponding known outputs, wherein the training inputs include: problem data; and log file browsing data, and wherein, for each of a plurality of log files of the medical imaging device, the corresponding known outputs include a resolution probability indicating a likelihood that the log file will assist in resolving the fault of the medical imaging device based on the browsing data, And optionally, the corresponding known output also includes a description of a solution associated with the problem data.

3. The method according to claim 1 or 2, wherein: Obtaining (110) log file browsing data includes: monitoring access to the plurality of log files of the medical imaging device for file access; and Generate log file browsing data based on the monitoring results.

4. The method according to any one of claims 1 to 3, wherein: (110) Obtaining log file browsing data includes: Analyze the usage history of the Log File Viewer application.

5. The method according to any one of claims 1 to 4, wherein: Obtaining input data for a problem includes: receiving, in response to the data request, question data provided by a respondent via an input interface, And optionally, wherein the data request includes a failure analysis questionnaire.

6. The method according to any one of claims 1 to 5, wherein: Obtaining problem data describing the fault of the medical imaging device includes: A natural language processing analysis is performed (120) on the description of the malfunction of the medical imaging device.

7. The method according to any one of claims 1 to 6, further comprising transmitting the identified log file over a communication network.

8. The method according to any one of claims 1 to 6, further comprising: The identified log files are analyzed to provide an indication of the malfunction of the medical imaging device, and one or more operating parameters of the medical imaging device are optionally adjusted to address the malfunction of the medical imaging device.

9. A method for resolving a medical imaging device failure, the method comprising: identifying a log file for resolving the failure of the medical imaging device based on the method according to any one of claims 1 to 8; generating updated log file browsing data based on the identified log files; inputting (130) the question data and the updated log file browsing data into the machine learning algorithm; obtaining (140) an updated prediction result from the machine learning algorithm in response to the input, the updated prediction result comprising a probability of resolution for one or more of the log files of the medical imaging device; and Based on the obtained prediction result, a second log file for resolving the fault of the medical imaging device is identified (150).

10. A computer program comprising code means for implementing the method according to any preceding claim when said program is run on a processing system.

11. A system for identifying log files for troubleshooting medical imaging equipment, the system comprising: A data interface (910) configured to obtain: log file browsing data for resolving the fault of the medical imaging device, the log file browsing data describing one or more log files of the medical imaging device that have been viewed by a user; and problem data describing said failure of said medical imaging device; A machine learning algorithm (930) configured to: receive the problem data and the log file browsing data, the machine learning algorithm being trained to output a prediction result, the prediction result comprising a solution probability for each of a plurality of log files of the medical imaging device, the solution probability indicating a likelihood that the log file assists in solving the fault of the medical imaging device based on the browsing data; as well as A processor (940) is configured to: identify a log file for resolving the fault of the medical imaging device based on the obtained prediction result.

12. The system according to claim 11, wherein: The data interface comprises a monitoring component adapted to monitor access to the plurality of log files of the medical imaging device of file accesses and to generate log file browsing data based on a result of the monitoring.

13. The system according to claim 11 or 12, wherein: The data interface includes a natural language processor configured to perform a natural language processing analysis on the description of the malfunction of the medical imaging device.

14. A system according to any one of claims 11 to 13, wherein: The machine learning algorithm includes a graph neural network.

15. A system for resolving a malfunction of a medical imaging device, the system comprising: A system for identifying a log file for resolving the malfunction of the medical imaging device according to any one of claims 11 to 14; a data processor configured to generate updated log file browsing data based on the identified log file; wherein the machine learning algorithm is configured to receive the problem data and the updated log file browsing data and output an updated prediction result, wherein the updated prediction result includes a resolution probability for one or more of the log files of the medical imaging device, And wherein the processor is configured to: identify a second log file for resolving the fault of the medical imaging device based on the obtained prediction result.

Images